def test_traced_after_rollback(self): tracer = DummyTracer() sqlalchemy_opentracing.init_tracing(tracer, False, False) sqlalchemy_opentracing.register_engine(self.engine) creat = CreateTable(self.users_table) # Create a table, but don't trace it conn = self.engine.connect() with conn.begin() as tx: conn.execute(creat) try: with conn.begin() as tx: sqlalchemy_opentracing.set_traced(conn) conn.execute(creat) except OperationalError: pass self.assertEqual(1, len(tracer.spans)) # Do something right after with this connection, # no tracing should happen. tracer.clear() ins = self.users_table.insert().values(name='John Doe') with conn.begin() as tx: conn.execute(ins) self.assertEqual(0, len(tracer.spans))
def test_traced_error(self): tracer = DummyTracer() sqlalchemy_opentracing.init_tracing(tracer, False, False) sqlalchemy_opentracing.register_engine(self.engine) creat = CreateTable(self.users_table) self.engine.execute(creat) self.assertEqual(0, len(tracer.spans)) sqlalchemy_opentracing.set_traced(creat) try: self.engine.execute(creat) except OperationalError: pass # Do nothing - it's responsibility of OT to finish tracing it. self.assertEqual(1, len(tracer.spans)) self.assertEqual(tracer.spans[0].is_finished, True) self.assertEqual( tracer.spans[0].tags, { 'component': 'sqlalchemy', 'db.statement': 'CREATE TABLE users (id INTEGER NOT NULL, name VARCHAR, PRIMARY KEY (id))', 'db.type': 'sql', 'sqlalchemy.dialect': 'sqlite', 'sqlalchemy.exception': 'table users already exists', 'error': 'true', }) self.assertEqual(False, sqlalchemy_opentracing.get_traced(creat))
def test_traced_error(self): tracer = DummyTracer() sqlalchemy_opentracing.init_tracing(tracer, False, False) sqlalchemy_opentracing.register_engine(self.engine) # Don't trace this one. session = self.session session.add(User(name='John Doe', id=1)) session.commit() # Trace this one. sqlalchemy_opentracing.set_traced(session) session.add(User(name='John Doe', id=1)) try: session.commit() except IntegrityError: pass self.assertEqual(1, len(tracer.spans)) self.assertEqual('insert', tracer.spans[0].operation_name) self.assertEqual(True, tracer.spans[0].is_finished) self.assertEqual(tracer.spans[0].tags, { 'component': 'sqlalchemy', 'db.statement': 'INSERT INTO users (id, name) VALUES (?, ?)', 'db.type': 'sql', 'sqlalchemy.dialect': 'sqlite', 'sqlalchemy.exception': 'UNIQUE constraint failed: users.id', 'error': 'true', })
def test_traced_clear_session(self): tracer = DummyTracer() sqlalchemy_opentracing.init_tracing(tracer, False, False) sqlalchemy_opentracing.register_engine(self.engine) session = self.session sqlalchemy_opentracing.set_traced(session) session.add(User(name='John Doe')) session.add(User(name='Jason Bourne')) # Clear the tracing info right before committing. sqlalchemy_opentracing.clear_traced(session) session.commit() self.assertEqual(0, len(tracer.spans))
def test_traced_all_engines(self): # Don't register the engine explicitly. tracer = DummyTracer() sqlalchemy_opentracing.init_tracing(tracer, trace_all_engines=True, trace_all_queries=False) creat = CreateTable(self.users_table) sqlalchemy_opentracing.set_traced(creat) self.engine.execute(creat) # Unregister the main Engine class before doing our assertions, # in case we fail. sqlalchemy_opentracing.unregister_engine(Engine) self.assertEqual(1, len(tracer.spans)) self.assertEqual('create_table', tracer.spans[0].operation_name) self.assertEqual(True, tracer.spans[0].is_finished)
def test_traced_savepoint(self): tracer = DummyTracer() sqlalchemy_opentracing.init_tracing(tracer, False, False) sqlalchemy_opentracing.register_engine(self.engine) session = self.session sqlalchemy_opentracing.set_traced(session) session.add(User(name='John Doe')) session.begin_nested() session.add(User(name='Jason Bourne')) session.commit() session.add(User(name='Paris Texas')) session.commit() self.assertEqual(3, len(tracer.spans)) self.assertEqual(True, all(map(lambda x: x.is_finished, tracer.spans)))
def test_unregister_engine(self): tracer = DummyTracer() sqlalchemy_opentracing.init_tracing(tracer, False, trace_all_queries=True) sqlalchemy_opentracing.register_engine(self.engine) creat = CreateTable(self.users_table) self.engine.execute(creat) self.assertEqual(1, len(tracer.spans)) tracer.clear() sqlalchemy_opentracing.unregister_engine(self.engine) # Further events should cause no spans at all. sel = select([self.users_table]) sqlalchemy_opentracing.set_traced(sel) self.engine.execute(sel) self.assertEqual(0, len(tracer.spans))
def test_traced_simple(self): tracer = DummyTracer() sqlalchemy_opentracing.init_tracing(tracer, False, False) sqlalchemy_opentracing.register_engine(self.engine) session = self.session sqlalchemy_opentracing.set_traced(session) session.add(User(name='John Doe')) session.commit() self.assertEqual(1, len(tracer.spans)) self.assertEqual('insert', tracer.spans[0].operation_name) self.assertEqual(True, tracer.spans[0].is_finished) self.assertEqual(tracer.spans[0].tags, { 'component': 'sqlalchemy', 'db.statement': 'INSERT INTO users (name) VALUES (?)', 'db.type': 'sql', 'sqlalchemy.dialect': 'sqlite', })
def test_traced_clear_connection(self): tracer = DummyTracer() sqlalchemy_opentracing.init_tracing(tracer, False, False) sqlalchemy_opentracing.register_engine(self.engine) creat = CreateTable(self.users_table) ins = self.users_table.insert().values(name='John Doe') conn = self.engine.connect() with conn.begin() as tx: sqlalchemy_opentracing.set_traced(conn) conn.execute(creat) # Stop tracing from this point. sqlalchemy_opentracing.clear_traced(conn) conn.execute(ins) self.assertEqual(1, len(tracer.spans)) self.assertEqual('create_table', tracer.spans[0].operation_name)
def test_traced_after_commit(self): tracer = DummyTracer() sqlalchemy_opentracing.init_tracing(tracer, False, False) sqlalchemy_opentracing.register_engine(self.engine) session = self.session sqlalchemy_opentracing.set_traced(session) session.add(User(name='John Doe')) session.commit() self.assertEqual(1, len(tracer.spans)) tracer.clear() # Issue a pair of statements, # making sure we are not tracing # the session's transaction anymore. session.add(User(name='Jason Bourne')) session.query(User).all() session.commit() self.assertEqual(0, len(tracer.spans))
def test_traced(self): tracer = DummyTracer() sqlalchemy_opentracing.init_tracing(tracer, False, False) sqlalchemy_opentracing.register_engine(self.engine) creat = CreateTable(self.users_table) sqlalchemy_opentracing.set_traced(creat) self.engine.execute(creat) self.assertEqual(1, len(tracer.spans)) self.assertEqual(tracer.spans[0].operation_name, 'create_table') self.assertEqual(tracer.spans[0].is_finished, True) self.assertEqual( tracer.spans[0].tags, { 'component': 'sqlalchemy', 'db.statement': 'CREATE TABLE users (id INTEGER NOT NULL, name VARCHAR, PRIMARY KEY (id))', 'db.type': 'sql', 'sqlalchemy.dialect': 'sqlite', }) self.assertEqual(False, sqlalchemy_opentracing.get_traced(creat))
def test_traced_after_rollback(self): tracer = DummyTracer() sqlalchemy_opentracing.init_tracing(tracer, False, False) sqlalchemy_opentracing.register_engine(self.engine) session = self.session sqlalchemy_opentracing.set_traced(session) session.query(User).all() # will be evaluated RIGHT AWAY session.add(User(name='John Doe')) # delayed (not committed) session.rollback() self.assertEqual(1, len(tracer.spans)) self.assertEqual(True, tracer.spans[0].is_finished) self.assertEqual('select', tracer.spans[0].operation_name) tracer.clear() # Rollback should have stopped # the tracing for this session session.query(User).all() session.add(User(name='Jason Bourne')) session.commit() self.assertEqual(0, len(tracer.spans))
class User(Base): __tablename__ = 'users' id = Column(Integer, primary_key=True) name = Column(String) if __name__ == '__main__': if os.path.exists(DB_LOCATION): os.remove(DB_LOCATION) # cleanup engine = create_engine('sqlite:///%s' % DB_LOCATION) session = sessionmaker(bind=engine)() sqlalchemy_opentracing.init_tracing(tracer) sqlalchemy_opentracing.register_engine(engine) User.metadata.create_all(engine) # Register the session for the current transaction. sqlalchemy_opentracing.set_traced(session) # Insert a set of rows. users = [User(name='User-%s' % i) for i in xrange(100)] session.bulk_save_objects(users) # Bulk saves objects without intermmediate steps, # so explicitly stop tracing the session. sqlalchemy_opentracing.clear_traced(session)
import opentracing import sqlalchemy_opentracing # Your OpenTracing-compatible tracer here. tracer = opentracing.Tracer() if __name__ == '__main__': engine = create_engine('sqlite:///:memory:') sqlalchemy_opentracing.init_tracing(tracer) sqlalchemy_opentracing.register_engine(engine) metadata = MetaData() users = Table( 'users', metadata, Column('id', Integer, primary_key=True), Column('name', String), ) creat = CreateTable(users) ins = users.insert().values(name='John Doe') # All statements during this transaction will be traced. with engine.begin() as conn: sqlalchemy_opentracing.set_traced(conn) conn.execute(creat) conn.execute(ins) tracer.flush()
def test_traced_property(self): stmt_obj = CreateTable(self.users_table) sqlalchemy_opentracing.set_traced(stmt_obj) self.assertEqual(True, sqlalchemy_opentracing.get_traced(stmt_obj))
def test_has_parent_none(self): stmt = CreateTable(self.users_table) sqlalchemy_opentracing.set_traced(stmt) self.assertEqual(False, sqlalchemy_opentracing.has_parent_span(stmt)) self.assertEqual(None, sqlalchemy_opentracing.get_parent_span(stmt))
from sqlalchemy import MetaData, Table, Integer, String, Column, create_engine from sqlalchemy.schema import CreateTable import opentracing import sqlalchemy_opentracing # Your OpenTracing-compatible tracer here. tracer = opentracing.Tracer() if __name__ == '__main__': engine = create_engine('sqlite:///:memory:') sqlalchemy_opentracing.init_tracing(tracer) sqlalchemy_opentracing.register_engine(engine) metadata = MetaData() users = Table( 'users', metadata, Column('id', Integer, primary_key=True), Column('name', String), ) creat = CreateTable(users) sqlalchemy_opentracing.set_traced(creat) with engine.begin() as conn: conn.execute(creat) tracer.flush()