def setUp(self):
super(PostgresTimeoutTracerTest, self).setUp()
self.database = create_database(os.environ["STORM_POSTGRES_URI"])
self.connection = self.database.connect()
install_tracer(self.tracer)
self.tracer.get_remaining_time = lambda: self.remaining_time
self.remaining_time = 10.5
def setUp(self):
super(PostgresTimeoutTracerTest, self).setUp()
self.database = create_database(os.environ["STORM_POSTGRES_URI"])
self.connection = self.database.connect()
install_tracer(self.tracer)
self.tracer.get_remaining_time = lambda: self.remaining_time
self.remaining_time = 10.5
def test_remove_tracer(cleanup_tracers):
"""The C{remote_tracer} function removes a specific tracer."""
tracer1 = object()
tracer2 = object()
install_tracer(tracer1)
install_tracer(tracer2)
remove_tracer(tracer1)
assert get_tracers() == [tracer2]
def test_remove_tracer(self):
"""The C{remote_tracer} function removes a specific tracer."""
tracer1 = object()
tracer2 = object()
install_tracer(tracer1)
install_tracer(tracer2)
remove_tracer(tracer1)
self.assertEquals(get_tracers(), [tracer2])
def runTransaction(function, *args, **kwargs):
tracer = StatementTracer(self.timeout)
install_tracer(tracer)
try:
return function(*args, **kwargs)
finally:
transaction['statements'] = tracer.statements
remove_all_tracers()
def test_remove_tracer(self):
"""The C{remote_tracer} function removes a specific tracer."""
tracer1 = object()
tracer2 = object()
install_tracer(tracer1)
install_tracer(tracer2)
remove_tracer(tracer1)
self.assertEquals(get_tracers(), [tracer2])
def start(self):
"""
Install and activate this tracer for all statements executed in this
thread (or greenlet).
"""
# We also need to indicate which particular thread this is installed for
# since it will write for all threads unless told not to
self.threadinfo.active = True
install_tracer(self)
def test_tracing_check_disconnect(self):
tracer = FakeTracer()
tracer_mock = self.mocker.patch(tracer)
tracer_mock.connection_raw_execute(ARGS)
self.mocker.throw(DatabaseError('connection closed'))
self.mocker.replay()
install_tracer(tracer_mock)
self.connection.is_disconnection_error = (
lambda exc: 'connection closed' in str(exc))
self.assertRaises(DisconnectionError,
self.connection.execute, "something")
def test_trace(self):
stash = []
class Tracer(object):
def m1(_, *args, **kwargs):
stash.extend(["m1", args, kwargs])
def m2(_, *args, **kwargs):
stash.extend(["m2", args, kwargs])
install_tracer(Tracer())
trace("m1", 1, 2, c=3)
trace("m2")
trace("m3")
self.assertEquals(stash, ["m1", (1, 2), {"c": 3}, "m2", (), {}])
def test_tracing_check_disconnect(self):
tracer = FakeTracer()
tracer_mock = self.mocker.patch(tracer)
tracer_mock.connection_raw_execute(ARGS)
self.mocker.throw(DatabaseError('connection closed'))
self.mocker.replay()
install_tracer(tracer_mock)
self.connection.is_disconnection_error = (
lambda exc, extra_disconnection_errors=(
): 'connection closed' in str(exc))
self.assertRaises(DisconnectionError, self.connection.execute,
"something")
def test_trace(self):
stash = []
class Tracer(object):
def m1(_, *args, **kwargs):
stash.extend(["m1", args, kwargs])
def m2(_, *args, **kwargs):
stash.extend(["m2", args, kwargs])
install_tracer(Tracer())
trace("m1", 1, 2, c=3)
trace("m2")
trace("m3")
self.assertEquals(stash, ["m1", (1, 2), {"c": 3}, "m2", (), {}])
def test_tracing_success_check_disconnect(self):
tracer = FakeTracer()
tracer_mock = self.mocker.patch(tracer)
tracer_mock.connection_raw_execute(ARGS)
tracer_mock.connection_raw_execute_success(ARGS)
self.mocker.throw(DatabaseError("connection closed"))
self.mocker.replay()
install_tracer(tracer_mock)
self.connection.is_disconnection_error = (
lambda exc, extra_disconnection_errors=():
"connection closed" in ustr(exc))
with pytest.raises(DisconnectionError):
self.connection.execute("something")
def test_trace(cleanup_tracers):
stash = []
class Tracer(object):
def m1(_, *args, **kwargs):
stash.extend(["m1", args, kwargs])
def m2(_, *args, **kwargs):
stash.extend(["m2", args, kwargs])
install_tracer(Tracer())
trace("m1", 1, 2, c=3)
trace("m2")
trace("m3")
assert stash == ["m1", (1, 2), {"c": 3}, "m2", (), {}]
def test_raw_execute_tracing(self):
assert_methods_match(FakeTracer, DebugTracer)
tracer = FakeTracer()
install_tracer(tracer)
self.connection.execute("something")
assert tracer.seen == [
("EXECUTE", self.connection, RawCursor, "something", ()),
("SUCCESS", self.connection, RawCursor, "something", ()),
]
del tracer.seen[:]
self.connection.execute("something", (1, 2))
assert tracer.seen == [
("EXECUTE", self.connection, RawCursor, "something", (1, 2)),
("SUCCESS", self.connection, RawCursor, "something", (1, 2)),
]
def test_raw_execute_error_tracing(self):
cursor_mock = self.mocker.patch(RawCursor)
cursor_mock.execute(ARGS)
error = ZeroDivisionError()
self.mocker.throw(error)
self.mocker.replay()
assert_methods_match(FakeTracer, DebugTracer)
tracer = FakeTracer()
install_tracer(tracer)
with pytest.raises(ZeroDivisionError):
self.connection.execute("something")
assert tracer.seen == [
("EXECUTE", self.connection, RawCursor, "something", ()),
("ERROR", self.connection, RawCursor, "something", (), error),
]
def test_raw_execute_tracing(self):
self.assertMethodsMatch(FakeTracer, DebugTracer)
tracer = FakeTracer()
install_tracer(tracer)
self.connection.execute("something")
self.assertEquals(tracer.seen, [("EXECUTE", self.connection, RawCursor,
"something", ()),
("SUCCESS", self.connection, RawCursor,
"something", ())])
del tracer.seen[:]
self.connection.execute("something", (1, 2))
self.assertEquals(tracer.seen, [("EXECUTE", self.connection, RawCursor,
"something", (1, 2)),
("SUCCESS", self.connection, RawCursor,
"something", (1, 2))])
def test_raw_execute_error_tracing(self):
cursor_mock = self.mocker.patch(RawCursor)
cursor_mock.execute(ARGS)
error = ZeroDivisionError()
self.mocker.throw(error)
self.mocker.replay()
self.assertMethodsMatch(FakeTracer, DebugTracer)
tracer = FakeTracer()
install_tracer(tracer)
self.assertRaises(ZeroDivisionError,
self.connection.execute, "something")
self.assertEquals(tracer.seen, [("EXECUTE", self.connection, RawCursor,
"something", ()),
("ERROR", self.connection, RawCursor,
"something", (), error)])
def test_raw_execute_setup_error_tracing(self):
"""
When an exception is raised in the connection_raw_execute hook of a
tracer, the connection_raw_execute_error hook is called.
"""
cursor_mock = self.mocker.patch(FakeTracer)
cursor_mock.connection_raw_execute(ARGS)
error = ZeroDivisionError()
self.mocker.throw(error)
self.mocker.replay()
tracer = FakeTracer()
install_tracer(tracer)
self.assertRaises(ZeroDivisionError,
self.connection.execute, "something")
self.assertEquals(tracer.seen, [("ERROR", self.connection, RawCursor,
"something", (), error)])
def test_tracing_error_check_disconnect(self):
cursor_mock = self.mocker.patch(RawCursor)
cursor_mock.execute(ARGS)
error = ZeroDivisionError()
self.mocker.throw(error)
tracer = FakeTracer()
tracer_mock = self.mocker.patch(tracer)
tracer_mock.connection_raw_execute(ARGS)
tracer_mock.connection_raw_execute_error(ARGS)
self.mocker.throw(DatabaseError('connection closed'))
self.mocker.replay()
install_tracer(tracer_mock)
self.connection.is_disconnection_error = (
lambda exc, extra_disconnection_errors=():
'connection closed' in ustr(exc))
with pytest.raises(DisconnectionError):
self.connection.execute("something")
def test_tracing_error_check_disconnect(self):
cursor_mock = self.mocker.patch(RawCursor)
cursor_mock.execute(ARGS)
error = ZeroDivisionError()
self.mocker.throw(error)
tracer = FakeTracer()
tracer_mock = self.mocker.patch(tracer)
tracer_mock.connection_raw_execute(ARGS)
tracer_mock.connection_raw_execute_error(ARGS)
self.mocker.throw(DatabaseError('connection closed'))
self.mocker.replay()
install_tracer(tracer_mock)
self.connection.is_disconnection_error = (
lambda exc, extra_disconnection_errors=():
'connection closed' in str(exc))
self.assertRaises(DisconnectionError,
self.connection.execute, "something")
def test_remove_tracer_type(self):
class C(object): pass
class D(C): pass
c = C()
d1 = D()
d2 = D()
install_tracer(d1)
install_tracer(c)
install_tracer(d2)
remove_tracer_type(C)
self.assertEquals(get_tracers(), [d1, d2])
remove_tracer_type(D)
self.assertEquals(get_tracers(), [])
def test_remove_tracer_type(self):
class C(object):
pass
class D(C):
pass
c = C()
d1 = D()
d2 = D()
install_tracer(d1)
install_tracer(c)
install_tracer(d2)
remove_tracer_type(C)
self.assertEquals(get_tracers(), [d1, d2])
remove_tracer_type(D)
self.assertEquals(get_tracers(), [])
def test_remove_tracer_type(cleanup_tracers):
class C(object):
pass
class D(C):
pass
c = C()
d1 = D()
d2 = D()
install_tracer(d1)
install_tracer(c)
install_tracer(d2)
remove_tracer_type(C)
assert get_tracers() == [d1, d2]
remove_tracer_type(D)
assert get_tracers() == []
def enable():
install_tracer(StoqlibDebugTracer())
def test_rollback_tracing(self):
assert_methods_match(FakeTracer, DebugTracer)
tracer = FakeTracer()
install_tracer(tracer)
self.connection.rollback()
assert tracer.seen == [("ROLLBACK", self.connection, None)]
def setUp(self):
super(CaptureTracer, self).setUp()
install_tracer(self)
self.addCleanup(remove_tracer, self)
# separately anyhow.
sys.stderr.write('%d-%d@%s %s\n' % data[:4])
sys.stderr.write("-" * 70 + "\n")
def connection_raw_execute_error(self, connection, raw_cursor,
statement, params, error):
# Since we are just logging durations, we execute the same
# hook code for errors as successes.
self.connection_raw_execute_success(
connection, raw_cursor, statement, params)
# The LaunchpadTimeoutTracer needs to be installed last, as it raises
# TimeoutError exceptions. When this happens, tracers installed later
# are not invoked.
install_tracer(LaunchpadStatementTracer())
install_tracer(LaunchpadTimeoutTracer())
class StoreSelector:
"""See `lp.services.database.interfaces.IStoreSelector`."""
classProvides(IStoreSelector)
@staticmethod
def push(db_policy):
"""See `IStoreSelector`."""
if not safe_hasattr(_local, 'db_policies'):
_local.db_policies = []
db_policy.install()
_local.db_policies.append(db_policy)
def test_commit_tracing(self):
self.assertMethodsMatch(FakeTracer, DebugTracer)
tracer = FakeTracer()
install_tracer(tracer)
self.connection.commit()
self.assertEquals(tracer.seen, [("COMMIT", self.connection, None)])
def test_rollback_tracing(self):
self.assertMethodsMatch(FakeTracer, DebugTracer)
tracer = FakeTracer()
install_tracer(tracer)
self.connection.rollback()
self.assertEquals(tracer.seen, [("ROLLBACK", self.connection, None)])
def enable_timeout_tracer(max_time=20):
"""Enable transaction timeouts."""
disable_timeout_tracer()
install_tracer(StorageTimeoutTracer(max_time))
def test_remove_all_tracers(self):
install_tracer(object())
remove_all_tracers()
self.assertEquals(get_tracers(), [])
def test_install_tracer(self):
c = object()
d = object()
install_tracer(c)
install_tracer(d)
self.assertEquals(get_tracers(), [c, d])
def setUp(self):
super(TimeoutTracerWithDBTest, self).setUp()
self.tracer = StuckInTimeTimeoutTracer(10)
install_tracer(self.tracer)
database = create_database(os.environ["STORM_POSTGRES_URI"])
self.connection = database.connect()
def install(self):
self.reset()
install_tracer(self)
def initStormTracing():
tracer.install_tracer(StormDebugTracer())
def install(self):
self.reset()
install_tracer(self)
def __enter__(self):
install_tracer(self)
def processRequest(self, request):
if settings.debug:
tracer.remove_all_tracers()
tracer.install_tracer(tracer.DebugTracer(self.sql_log))
def setUp(self):
super(CaptureTracer, self).setUp()
install_tracer(self)
self.addCleanup(remove_tracer, self)
def test_remove_all_tracers(cleanup_tracers):
install_tracer(object())
remove_all_tracers()
assert get_tracers() == []
def test_install_tracer(cleanup_tracers):
c = object()
d = object()
install_tracer(c)
install_tracer(d)
assert get_tracers() == [c, d]
def enable():
install_tracer(StoqlibDebugTracer())
def test_install_tracer(self):
c = object()
d = object()
install_tracer(c)
install_tracer(d)
self.assertEquals(get_tracers(), [c, d])
def setUp(self):
super(TimeoutTracerWithDBTest, self).setUp()
self.tracer = StuckInTimeTimeoutTracer(10)
install_tracer(self.tracer)
database = create_database(os.environ["STORM_POSTGRES_URI"])
self.connection = database.connect()
# separately anyhow.
sys.stderr.write('%d-%d@%s %s\n' % data[:4])
sys.stderr.write("-" * 70 + "\n")
def connection_raw_execute_error(self, connection, raw_cursor, statement,
params, error):
# Since we are just logging durations, we execute the same
# hook code for errors as successes.
self.connection_raw_execute_success(connection, raw_cursor, statement,
params)
# The LaunchpadTimeoutTracer needs to be installed last, as it raises
# TimeoutError exceptions. When this happens, tracers installed later
# are not invoked.
install_tracer(LaunchpadStatementTracer())
install_tracer(LaunchpadTimeoutTracer())
@provider(IStoreSelector)
class StoreSelector:
"""See `lp.services.database.interfaces.IStoreSelector`."""
@staticmethod
def push(db_policy):
"""See `IStoreSelector`."""
if not safe_hasattr(_local, 'db_policies'):
_local.db_policies = []
db_policy.install()
_local.db_policies.append(db_policy)
@staticmethod
def test_remove_all_tracers(self):
install_tracer(object())
remove_all_tracers()
self.assertEquals(get_tracers(), [])
def processRequest(self, request):
if self.application.debug and tracer:
self.sql_log = StringIO()
tracer.remove_all_tracers()
tracer.install_tracer(tracer.DebugTracer(self.sql_log))
def processRequest(self, request):
self.sql_log = StringIO()
tracer.remove_all_tracers()
tracer.install_tracer(tracer.DebugTracer(self.sql_log))
