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()
