def test_traced_transaction_nested(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')
sel = select([self.users_table])
parent_span = DummySpan('parent span')
conn = self.engine.connect()
with conn.begin() as trans:
sqlalchemy_opentracing.set_parent_span(conn, parent_span)
conn.execute(creat)
with conn.begin() as trans2:
conn.execute(ins)
conn.execute(sel)
self.assertEqual(3, len(tracer.spans))
self.assertEqual(True, all(map(lambda x: x.is_finished, tracer.spans)))
self.assertEqual(
True, all(map(lambda x: x.child_of == parent_span, tracer.spans)))
self.assertEqual(['create_table', 'insert', 'select'],
map(lambda x: x.operation_name, tracer.spans))
def test_traced_rollback(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')
# Don't trace this.
self.engine.execute(creat)
parent_span = DummySpan('parent span')
conn = self.engine.connect()
try:
with conn.begin() as tx:
sqlalchemy_opentracing.set_parent_span(conn, parent_span)
conn.execute(ins)
conn.execute(creat)
except OperationalError:
pass
self.assertEqual(2, len(tracer.spans))
self.assertEqual(True, all(map(lambda x: x.is_finished, tracer.spans)))
self.assertEqual(
True, all(map(lambda x: x.child_of == parent_span, tracer.spans)))
self.assertEqual(['insert', 'create_table'],
map(lambda x: x.operation_name, tracer.spans))
self.assertEqual(['false', 'true'],
map(lambda x: x.tags.get('error', 'false'),
tracer.spans))
def test_traced_text_error(self):
tracer = DummyTracer()
sqlalchemy_opentracing.init_tracing(tracer, False, False)
sqlalchemy_opentracing.register_engine(self.engine)
session = self.session
span = DummySpan('parent span')
sqlalchemy_opentracing.set_parent_span(session, span)
try:
session.execute('SELECT zipcode FROM addresses')
except OperationalError:
pass
self.assertEqual(1, len(tracer.spans))
self.assertEqual(tracer.spans[0].operation_name, 'textclause')
self.assertEqual(tracer.spans[0].is_finished, True)
self.assertEqual(tracer.spans[0].child_of, span)
self.assertEqual(tracer.spans[0].tags, {
'component': 'sqlalchemy',
'db.statement': 'SELECT zipcode FROM addresses',
'db.type': 'sql',
'sqlalchemy.dialect': 'sqlite',
'sqlalchemy.exception': 'no such table: addresses',
'error': 'true',
})
def test_traced_parent(self):
tracer = DummyTracer()
sqlalchemy_opentracing.init_tracing(tracer, False, False)
sqlalchemy_opentracing.register_engine(self.engine)
session = self.session
parent_span = DummySpan('parent')
sqlalchemy_opentracing.set_parent_span(session, parent_span)
session.query(User).all()
session.query(User).all()
session.commit()
self.assertEqual(2, len(tracer.spans))
self.assertEqual(True, all(map(lambda x: x.operation_name == 'select', tracer.spans)))
self.assertEqual(True, all(map(lambda x: x.is_finished, tracer.spans)))
self.assertEqual(True, all(map(lambda x: x.child_of == parent_span, tracer.spans)))
def login():
if request.method == 'POST':
logging.info("Request headers: {}".format(request.headers))
span = tracer.get_span()
payload = request.get_json()
email = payload['email']
password = payload['password']
sp = opentracing_tracer.start_span('query', child_of=span)
session = Session()
sqlalchemy_opentracing.set_parent_span(session, sp)
user = session.query(Users).filter_by(email=email).first()
sp.finish()
if user is None:
return Response(status=404, mimetype='application/json')
elif user.password == password:
return Response(status=200, mimetype='application/json')
else:
return Response(status=401, mimetype='application/json')
def test_traced_bulk_insert(self):
tracer = DummyTracer()
sqlalchemy_opentracing.init_tracing(tracer, False, False)
sqlalchemy_opentracing.register_engine(self.engine)
parent_span = DummySpan('parent')
session = self.session
sqlalchemy_opentracing.set_parent_span(session, parent_span)
users = [User(name = 'User-%s' % i) for i in range(10)]
session.bulk_save_objects(users)
self.assertEqual(1, len(tracer.spans))
self.assertEqual(True, tracer.spans[0].is_finished)
self.assertEqual(parent_span, tracer.spans[0].child_of)
self.assertEqual(tracer.spans[0].tags, {
'component': 'sqlalchemy',
'db.statement': 'INSERT INTO users (name) VALUES (?)',
'db.type': 'sql',
'sqlalchemy.dialect': 'sqlite',
})
def test_traced_text(self):
tracer = DummyTracer()
sqlalchemy_opentracing.init_tracing(tracer, False, False)
sqlalchemy_opentracing.register_engine(self.engine)
session = self.session
span = DummySpan('parent span')
sqlalchemy_opentracing.set_parent_span(session, span)
session.execute('SELECT name FROM users')
self.assertEqual(1, len(tracer.spans))
self.assertEqual(tracer.spans[0].operation_name, 'textclause')
self.assertEqual(tracer.spans[0].is_finished, True)
self.assertEqual(tracer.spans[0].child_of, span)
self.assertEqual(tracer.spans[0].tags, {
'component': 'sqlalchemy',
'db.statement': 'SELECT name FROM users',
'db.type': 'sql',
'sqlalchemy.dialect': 'sqlite',
})
def test_traced_commit_repeat(self):
tracer = DummyTracer()
sqlalchemy_opentracing.init_tracing(tracer, False, False)
sqlalchemy_opentracing.register_engine(self.engine)
parent_span1 = DummySpan('parent1')
session = self.session
sqlalchemy_opentracing.set_parent_span(session, parent_span1)
session.add(User(name='John Doe'))
session.commit()
self.assertEqual(1, len(tracer.spans))
self.assertEqual(True, tracer.spans[0].is_finished)
self.assertEqual(parent_span1, tracer.spans[0].child_of)
# Register the session again for tracing,
# now with a different parent span
parent_span2 = DummySpan('parent2')
sqlalchemy_opentracing.set_parent_span(session, parent_span2)
session.add(User(name='Jason Bourne'))
session.commit()
self.assertEqual(2, len(tracer.spans))
self.assertEqual(True, tracer.spans[1].is_finished)
self.assertEqual(parent_span2, tracer.spans[1].child_of)
def test_has_parent(self):
span = DummySpan()
stmt = CreateTable(self.users_table)
sqlalchemy_opentracing.set_parent_span(stmt, span)
self.assertEqual(True, sqlalchemy_opentracing.has_parent_span(stmt))
self.assertEqual(span, sqlalchemy_opentracing.get_parent_span(stmt))
engine = create_engine('sqlite:///%s' % DB_LOCATION)
conn = engine.connect()
sqlalchemy_opentracing.init_tracing(tracer)
sqlalchemy_opentracing.register_engine(engine)
span = tracer.start_span('create sample')
# 1. Create a table
metadata = MetaData()
users = Table('users', metadata,
Column('id', Integer, primary_key=True),
Column('name', String),
)
creat = CreateTable(users)
sqlalchemy_opentracing.set_parent_span(creat, span)
conn.execute(creat)
# 2. Insert a single value.
ins = users.insert().values(name='John Doe', id=1)
sqlalchemy_opentracing.set_parent_span(ins, span)
conn.execute(ins)
# 3. Select the new value.
sel = select([users])
sqlalchemy_opentracing.set_parent_span(sel, span)
print conn.execute(sel).fetchone()
span.finish()
tracer.flush()
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)
# Create a parent span
span = tracer.start_span('parent span')
# Register the session for the current transaction.
sqlalchemy_opentracing.set_parent_span(session, span)
session.add(User(name='John Doe'))
session.add(User(name='Jason Bourne'))
users = session.query(User).all()
for user in users:
print user.name
session.add(User(name='Who'))
# Commit the session and close the parent span.
session.commit()
span.finish()
