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 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_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(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 __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 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]
# 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 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))