def celery_application(self, celery_active_broker, celery_result_backend):
tracer = MockTracer()
self._tracer['tracer'] = tracer
with CeleryTracing(tracer=tracer,
broker=celery_active_broker,
backend=celery_result_backend) as app:
@app.task
def add(one, two):
span = tracer.active_span
span.set_tag('one', one)
span.set_tag('two', two)
return one + two
self._tasks['add'] = add
@app.task
def blowup():
return 1 / 0
self._tasks['blowup'] = blowup
@app.task(bind=True)
def retry(self, raze=True):
if not raze:
return 'Success'
try:
raise Exception('My Exception!')
except Exception as exc:
self.retry(args=(False, ), exc=exc, countdown=.5)
self._tasks['retry'] = retry
yield app
class TestClient(TestTornadoTracingBase):
def get_app(self):
self.tracer = MockTracer(TornadoScopeManager())
return make_app(self.tracer, trace_all=False)
def test_simple(self):
with tracer_stack_context():
self.http_client.fetch(self.get_url('/'), self.stop)
response = self.wait()
self.assertEqual(response.code, 200)
spans = self.tracer.finished_spans()
self.assertEqual(len(spans), 1)
self.assertTrue(spans[0].finished)
self.assertEqual(spans[0].operation_name, 'GET')
self.assertEqual(
spans[0].tags, {
'component': 'tornado',
'span.kind': 'client',
'http.url': self.get_url('/'),
'http.method': 'GET',
'http.status_code': 200,
})
def test_uninstrument_reverts_wrapper(self):
tracer = MockTracer()
opentracing.tracer = tracer
instrument()
app = self.make_app()
client = app.test_client()
assert client.get('/').status_code == 200
assert len(tracer.finished_spans()) == 1
tracer.reset()
uninstrument()
app = self.make_app()
client = app.test_client()
assert client.get('/').status_code == 200
assert tracer.finished_spans() == []
def test_uninstrumented_connections_no_longer_traces(self):
tracer = MockTracer()
opentracing.tracer = tracer
config.tracer = tracer
with mock.patch.object(psycopg2.extensions, 'connection',
MockDBAPIConnection):
with mock.patch.object(psycopg2.extensions, 'cursor',
MockDBAPICursor):
instrument(tracer)
connection = psycopg2.connect("dbname=test")
with connection.cursor() as cursor:
cursor.execute('traced')
cursor.executemany('traced')
cursor.callproc('traced')
spans = tracer.finished_spans()
assert len(spans) == 3
for span in spans:
assert span.tags[tags.DATABASE_TYPE] == 'PostgreSQL'
assert span.tags[tags.DATABASE_INSTANCE] == 'test'
assert spans[
0].operation_name == 'MockDBAPICursor.execute(traced)'
assert spans[
1].operation_name == 'MockDBAPICursor.executemany(traced)'
assert spans[
2].operation_name == 'MockDBAPICursor.callproc(traced)'
uninstrument()
tracer.reset()
connection = psycopg2.connect(
"dbname=test", connection_factory=MockDBAPIConnection)
with connection.cursor() as cursor:
cursor.execute('traced')
cursor.executemany('traced')
cursor.callproc('traced')
assert not tracer.finished_spans()
def test_uninstrumented_clients_no_longer_traces(self):
tracer = MockTracer()
opentracing.tracer = tracer
config.tracer = tracer
instrument(tracer)
session = requests.Session()
with mock.patch.object(requests.Session, 'request', mocked_request):
session.get('some_url')
spans = tracer.finished_spans()
assert len(spans) == 1
assert spans[0].operation_name == 'requests.get'
uninstrument()
tracer.reset()
session = requests.Session()
with mock.patch.object(requests.Session, 'request', mocked_request):
session.get('some_url')
assert not tracer.finished_spans()
def test_uninstrument_reverts_wrapper(self):
tracer = MockTracer()
instrument(tracer)
with self.mocked_transport() as perform_request:
es = Elasticsearch()
es.index(index='some-index', doc_type='some-doc-type',
id=1, body=self.body)
assert perform_request.called
assert len(tracer.finished_spans()) == 1
tracer.reset()
uninstrument()
with self.mocked_transport() as perform_request:
es = Elasticsearch()
es.index(index='some-index', doc_type='some-doc-type',
id=1, body=self.body)
assert perform_request.called
assert not tracer.finished_spans()
def test_uninstrumented_clients_no_longer_traces(self):
tracer = MockTracer()
opentracing.tracer = tracer
config.tracer = tracer
with mock.patch.object(redis.StrictRedis, 'execute_command', mock_execute_command):
instrument(tracer)
client = redis.StrictRedis()
client.get('some_url')
spans = tracer.finished_spans()
assert len(spans) == 1
assert spans[0].operation_name == 'GET'
uninstrument()
tracer.reset()
client = redis.StrictRedis()
with mock.patch.object(redis.StrictRedis, 'execute_command', mock_execute_command):
client.get('some_url')
assert not tracer.finished_spans()
def test_connection_commands_are_traced_by_default(self):
tracer = MockTracer()
config.tracer = tracer
with mock.patch.object(psycopg2.extensions, 'connection',
MockDBAPIConnection):
with mock.patch.object(psycopg2.extensions, 'cursor',
MockDBAPICursor):
with mock.patch.object(psycopg2.extensions.cursor,
'callproc',
side_effect=Exception) as callproc:
callproc.__name__ = 'callproc'
instrument()
connection = psycopg2.connect(
"dbname=test",
connection_factory=MockDBAPIConnection())
with connection as cursor:
cursor.execute('traced')
spans = tracer.finished_spans()
assert len(spans) == 2
assert spans[
0].operation_name == 'MockDBAPICursor.execute(traced)'
assert spans[
1].operation_name == 'MockDBAPIConnection.commit()'
tracer.reset()
with connection as cursor:
cursor.callproc('traced')
spans = tracer.finished_spans()
assert len(spans) == 2
assert spans[
0].operation_name == 'MockDBAPICursor.callproc(traced)'
assert spans[
1].operation_name == 'MockDBAPIConnection.rollback()'
def test_uninstrumented_clients_no_longer_traces(self):
tracer = MockTracer()
opentracing.tracer = tracer
config.tracer = tracer
instrument(tracer)
client = pymongo.MongoClient(self.server.uri)
fut = go(client.db.collection.insert_many, [dict(one=123), dict(two=234)])
self.server.receives().ok()
fut()
spans = tracer.finished_spans()
assert len(spans) == 1
assert spans[0].operation_name == 'insert'
uninstrument()
tracer.reset()
client = pymongo.MongoClient(self.server.uri)
fut = go(client.db.collection.insert_many, [dict(one=123), dict(two=234)])
self.server.receives().ok()
fut()
assert not tracer.finished_spans()
import logging
from opentracing.mocktracer import MockTracer
from logging_opentracing import OpenTracingHandler
# initialize a mock tracer
tracer = MockTracer()
# prepare the logger
logger = logging.getLogger('mylogger')
logger.setLevel(logging.INFO)
# create a new OpenTracing handler for the logging package
handler = OpenTracingHandler(tracer=tracer)
logger.addHandler(handler)
# start a span
with tracer.start_span('hello-world') as span:
# this log will be propagated to OpenTracing
logger.info('A span has been directly passed', extra={'span': span})
# retrieve the finished span
finished_span = tracer.finished_spans()[0]
# get the log line from
log = finished_span.logs[0]
# print the key_values of the log
print(log.key_values)
expected_output = "{'event': 'info', 'message': 'A span has been directly passed'}\n"
def session_tracing(self, echo_container):
tracer = MockTracer()
session = SessionTracing(tracer,
propagate=True,
span_tags=dict(custom='tag'))
return tracer, session
def setUp(self):
self.tracer = MockTracer()
self.client = redis.StrictRedis()
class TestClient(unittest.TestCase):
def setUp(self):
self.tracer = MockTracer()
self.client = redis.StrictRedis()
def test_trace_client(self):
with patch.object(self.client, 'execute_command',
return_value='1') as exc_command:
exc_command.__name__ = 'execute_command'
redis_opentracing.init_tracing(self.tracer,
trace_all_classes=False)
redis_opentracing.trace_client(self.client)
res = self.client.get('my.key')
self.assertEqual(res, '1')
self.assertEqual(exc_command.call_count, 1)
self.assertTrue(True, exc_command.call_args == (('my.key', ), ))
self.assertEqual(len(self.tracer.finished_spans()), 1)
span = self.tracer.finished_spans()[0]
self.assertEqual(span.operation_name, 'GET')
self.assertEqual(
span.tags, {
'component': 'redis-py',
'db.type': 'redis',
'db.statement': 'GET my.key',
'span.kind': 'client',
})
def test_trace_client_error(self):
with patch.object(self.client,
'execute_command',
side_effect=ValueError('error msg')) as exc_command:
exc_command.__name__ = 'execute_command'
redis_opentracing.init_tracing(self.tracer,
trace_all_classes=False)
redis_opentracing.trace_client(self.client)
call_exc = None
try:
self.client.get('my.key')
except ValueError as exc:
call_exc = exc
self.assertEqual(exc_command.call_count, 1)
self.assertTrue(True, exc_command.call_args == (('my.key', ), ))
self.assertEqual(len(self.tracer.finished_spans()), 1)
span = self.tracer.finished_spans()[0]
self.assertEqual(span.operation_name, 'GET')
tags = {
'component': 'redis-py',
'db.type': 'redis',
'db.statement': 'GET my.key',
'span.kind': 'client',
'error': True,
}
for k, v in tags.items():
assert k in span.tags
assert span.tags[k] == v
self.assertEqual(span.tags['error'], True)
self.assertEqual(span.tags['sfx.error.message'], 'error msg')
self.assertEqual(span.tags['sfx.error.kind'], 'ValueError')
self.assertEqual(span.tags['sfx.error.object'],
'<class \'ValueError\'>')
assert len(span.tags['sfx.error.stack']) > 50
def test_trace_client_start_span_cb(self):
def start_span_cb(span):
span.set_operation_name('Test')
with patch.object(self.client, 'execute_command',
return_value='1') as exc_command:
exc_command.__name__ = 'execute_command'
redis_opentracing.init_tracing(self.tracer,
trace_all_classes=False,
start_span_cb=start_span_cb)
redis_opentracing.trace_client(self.client)
res = self.client.get('my.key')
span = self.tracer.finished_spans()[0]
self.assertEqual(span.operation_name, 'Test')
def test_trace_client_start_span_cb_exc(self):
def start_span_cb(span):
raise RuntimeError('This should not happen')
with patch.object(self.client, 'execute_command',
return_value='1') as exc_command:
exc_command.__name__ = 'execute_command'
redis_opentracing.init_tracing(self.tracer,
trace_all_classes=False,
start_span_cb=start_span_cb)
redis_opentracing.trace_client(self.client)
res = self.client.get('my.key')
span = self.tracer.finished_spans()[0]
self.assertEqual(span.operation_name, 'GET')
self.assertFalse(span.tags.get('error', False))
def test_trace_client_pipeline(self):
redis_opentracing.init_tracing(self.tracer, trace_all_classes=False)
redis_opentracing.trace_client(self.client)
pipe = self.client.pipeline()
pipe.rpush('my:keys', 1, 3)
pipe.rpush('my:keys', 5, 7)
pipe.execute()
self.assertEqual(len(self.tracer.finished_spans()), 1)
span = self.tracer.finished_spans()[0]
self.assertEqual(span.operation_name, 'MULTI')
self.assertEqual(
span.tags, {
'component': 'redis-py',
'db.type': 'redis',
'db.statement': 'RPUSH my:keys 1 3;RPUSH my:keys 5 7',
'span.kind': 'client',
})
def test_trace_client_pubsub(self):
redis_opentracing.init_tracing(self.tracer, trace_all_classes=False)
redis_opentracing.trace_client(self.client)
pubsub = self.client.pubsub()
pubsub.subscribe('test')
# Subscribing can cause more than a SUBSCRIBE call.
self.assertTrue(len(self.tracer.finished_spans()) >= 1)
span = self.tracer.finished_spans()[0]
self.assertEqual(span.operation_name, 'SUBSCRIBE')
self.assertEqual(
span.tags, {
'component': 'redis-py',
'db.type': 'redis',
'db.statement': 'SUBSCRIBE test',
'span.kind': 'client',
})
def setUp(self):
self.tracer = MockTracer()
self.queue = queue.Queue()
self.server = Server(tracer=self.tracer, queue=self.queue)
self.server.start()
def setUp(self):
self.tracer = MockTracer(ScopeManager())
super(TestClient, self).setUp()
class TestTracing(unittest.TestCase):
def setUp(self):
self.tracer = MockTracer()
self.client = redis.StrictRedis()
# Stash away the original methods for
# after-test restoration.
self._execute_command = redis.StrictRedis.execute_command
self._pipeline = redis.StrictRedis.pipeline
def tearDown(self):
redis.StrictRedis.execute_command = self._execute_command
redis.StrictRedis.pipeline = self._pipeline
tracing._reset_tracing()
def test_trace_nothing(self):
with patch.object(self.client, 'execute_command') as exc_command:
exc_command.__name__ = 'execute_command'
redis_opentracing.init_tracing(self.tracer,
trace_all_classes=False)
self.client.get('my.key')
self.assertEqual(exc_command.call_count, 1)
self.assertEqual(len(self.tracer.finished_spans()), 0)
def test_trace_all_client(self):
with patch('redis.StrictRedis.execute_command') as execute_command:
execute_command.__name__ = 'execute_command'
redis_opentracing.init_tracing(self.tracer)
self.client.get('my.key')
self.assertEqual(execute_command.call_count, 1)
self.assertTrue(True,
execute_command.call_args == (('my.key', ), ))
self.assertEqual(len(self.tracer.finished_spans()), 1)
span = self.tracer.finished_spans()[0]
self.assertEqual(span.operation_name, 'GET')
self.assertEqual(
span.tags, {
'component': 'redis-py',
'db.type': 'redis',
'db.statement': 'GET my.key',
'span.kind': 'client',
})
def test_trace_all_pipeline(self):
redis_opentracing.init_tracing(self.tracer)
pipe = self.client.pipeline()
pipe.lpush('my:keys', 1, 3)
pipe.rpush('my:keys', 5, 7)
pipe.execute()
self.assertEqual(len(self.tracer.finished_spans()), 1)
span = self.tracer.finished_spans()[0]
self.assertEqual(span.operation_name, 'MULTI')
self.assertEqual(
span.tags, {
'component': 'redis-py',
'db.type': 'redis',
'db.statement': 'LPUSH my:keys 1 3;RPUSH my:keys 5 7',
'span.kind': 'client',
})
def test_trace_all_pubsub(self):
redis_opentracing.init_tracing(self.tracer)
pubsub = self.client.pubsub()
pubsub.subscribe('test')
# Subscribing can cause more than a SUBSCRIBE call.
self.assertTrue(len(self.tracer.finished_spans()) >= 1)
span = self.tracer.finished_spans()[0]
self.assertEqual(span.operation_name, 'SUBSCRIBE')
self.assertEqual(
span.tags, {
'component': 'redis-py',
'db.type': 'redis',
'db.statement': 'SUBSCRIBE test',
'span.kind': 'client',
})
import logging
from opentracing.mocktracer import MockTracer
from logging_opentracing import OpenTracingHandler
# initialize a mock tracer
tracer = MockTracer()
# prepare the logger
logger = logging.getLogger('mylogger')
logger.setLevel(logging.INFO)
# create a new OpenTracing handler for the logging package
handler = OpenTracingHandler(tracer=tracer)
logger.addHandler(handler)
# start an active span
with tracer.start_active_span('hello-world'):
# this log will be propagated to
logger.info('Hello World from Python logging to OpenTracing')
# retrieve the finished span
finished_span = tracer.finished_spans()[0]
# get the log line from
log = finished_span.logs[0]
# print the key_values of the log
print(log.key_values)
expected_output = "{'event': 'info', 'message': 'Hello World from Python logging to OpenTracing'}\n"
def get_app(self):
self.tracer = MockTracer(ScopeManager())
return make_app(self.tracer,
trace_all=False,
start_span_cb=self.start_span_cb)
def tracer(self):
return MockTracer()
def get_app(self):
self.tracer = MockTracer(ScopeManager())
return make_app(self.tracer, trace_all=False)
class TestTracing(TestTornadoTracingBase):
def get_app(self):
self.tracer = MockTracer(ScopeManager())
return make_app(self.tracer, trace_client=False)
def test_simple(self):
response = self.fetch('/')
self.assertEqual(response.code, 200)
spans = self.tracer.finished_spans()
self.assertEqual(len(spans), 1)
self.assertTrue(spans[0].finished)
self.assertEqual(spans[0].operation_name, 'MainHandler')
self.assertEqual(
spans[0].tags, {
'component': 'tornado',
'span.kind': 'server',
'http.url': '/',
'http.method': 'GET',
'http.status_code': 200,
})
def test_custom_method(self):
response = self.fetch('/',
method='CUSTOM_METHOD',
allow_nonstandard_methods=True)
self.assertEqual(response.code, 200)
spans = self.tracer.finished_spans()
self.assertEqual(len(spans), 1)
self.assertTrue(spans[0].finished)
self.assertEqual(spans[0].operation_name, 'MainHandler')
self.assertEqual(
spans[0].tags, {
'component': 'tornado',
'span.kind': 'server',
'http.url': '/',
'http.method': 'CUSTOM_METHOD',
'http.status_code': 200,
})
def test_error(self):
response = self.http_fetch(self.get_url('/error'))
self.assertEqual(response.code, 500)
spans = self.tracer.finished_spans()
self.assertEqual(len(spans), 1)
self.assertTrue(spans[0].finished)
self.assertEqual(spans[0].operation_name, 'ErrorHandler')
tags = spans[0].tags
self.assertEqual(tags.get('error', None), True)
logs = spans[0].logs
self.assertEqual(len(logs), 1)
self.assertEqual(logs[0].key_values.get('event', None), 'error')
self.assertTrue(
isinstance(logs[0].key_values.get('error.object', None),
ValueError))
@skip_generator_contextvars_on_tornado6
def test_scope_coroutine(self):
response = self.http_fetch(self.get_url('/coroutine_scope'))
self.assertEqual(response.code, 200)
spans = self.tracer.finished_spans()
self.assertEqual(len(spans), 2)
child = spans[0]
self.assertTrue(child.finished)
self.assertEqual(child.operation_name, 'Child')
self.assertEqual(child.tags, {
'start': 0,
'end': 1,
})
parent = spans[1]
self.assertTrue(parent.finished)
self.assertEqual(parent.operation_name, 'CoroutineScopeHandler')
self.assertEqual(
parent.tags, {
'component': 'tornado',
'span.kind': 'server',
'http.url': '/coroutine_scope',
'http.method': 'GET',
'http.status_code': 200,
})
# Same trace.
self.assertEqual(child.context.trace_id, parent.context.trace_id)
self.assertEqual(child.parent_id, parent.context.span_id)
@skip_no_async_await
def test_scope_async(self):
response = self.http_fetch(self.get_url('/async_scope'))
self.assertEqual(response.code, 200)
spans = self.tracer.finished_spans()
self.assertEqual(len(spans), 2)
child = spans[0]
self.assertTrue(child.finished)
self.assertEqual(child.operation_name, 'Child')
self.assertEqual(child.tags, {
'start': 0,
'end': 1,
})
parent = spans[1]
self.assertTrue(parent.finished)
self.assertEqual(parent.operation_name, 'AsyncScopeHandler')
self.assertEqual(
parent.tags, {
'component': 'tornado',
'span.kind': 'server',
'http.url': '/async_scope',
'http.method': 'GET',
'http.status_code': 200,
})
# Same trace.
self.assertEqual(child.context.trace_id, parent.context.trace_id)
self.assertEqual(child.parent_id, parent.context.span_id)
def get_app(self):
self.tracer = MockTracer(ScopeManager())
return make_app(tracer_callable='tests.test_tracing.tracer_callable',
tracer_parameters={'tracer': self.tracer})
def get_app(self):
self.tracer = MockTracer(ScopeManager())
return make_app(tracer_callable=tracer_callable,
tracer_parameters={
'tracer': self.tracer,
})
def test_tracer(self):
tracer = MockTracer()
tracing = tornado_opentracing.TornadoTracing(tracer)
self.assertEqual(tracing.tracer, tracer)
def setUp(self):
self.tracer = MockTracer(TornadoScopeManager())
self.loop = ioloop.IOLoop.current()
def setUp(self):
super(PrepareMixin, self).setUp()
self.patcher = mock.patch(
'opentracing.tracer', MockTracer(self.scope_manager()))
self.patcher.start()
self.client = Client()
class TestClient(AsyncHTTPTestCase):
def setUp(self):
self.tracer = MockTracer(ScopeManager())
super(TestClient, self).setUp()
def tearDown(self):
tornado_opentracing.initialization._unpatch_tornado_client()
super(TestClient, self).tearDown()
def get_app(self):
return make_app()
def test_no_tracer(self):
tornado_opentracing.init_client_tracing()
with mock.patch('opentracing.tracer', new=self.tracer):
with tornado_context():
response = self.http_fetch(self.get_url('/'))
self.assertEqual(response.code, 200)
spans = self.tracer.finished_spans()
self.assertEqual(len(spans), 1)
self.assertTrue(spans[0].finished)
self.assertEqual(spans[0].operation_name, 'GET')
self.assertEqual(spans[0].tags, {
'component': 'tornado',
'span.kind': 'client',
'http.url': self.get_url('/'),
'http.method': 'GET',
'http.status_code': 200,
})
def test_simple(self):
tornado_opentracing.init_client_tracing(self.tracer)
with tornado_context():
response = self.http_fetch(self.get_url('/'))
self.assertEqual(response.code, 200)
spans = self.tracer.finished_spans()
self.assertEqual(len(spans), 1)
self.assertTrue(spans[0].finished)
self.assertEqual(spans[0].operation_name, 'GET')
self.assertEqual(spans[0].tags, {
'component': 'tornado',
'span.kind': 'client',
'http.url': self.get_url('/'),
'http.method': 'GET',
'http.status_code': 200,
})
def test_start_span_cb(self):
def test_cb(span, request):
span.operation_name = 'foo/' + request.method
span.set_tag('component', 'tornado-client')
tornado_opentracing.init_client_tracing(self.tracer,
start_span_cb=test_cb)
with tornado_context():
response = self.http_fetch(self.get_url('/'))
self.assertEqual(response.code, 200)
spans = self.tracer.finished_spans()
self.assertEqual(len(spans), 1)
self.assertTrue(spans[0].finished)
self.assertEqual(spans[0].operation_name, 'foo/GET')
self.assertEqual(spans[0].tags, {
'component': 'tornado-client',
'span.kind': 'client',
'http.url': self.get_url('/'),
'http.method': 'GET',
'http.status_code': 200,
})
def test_start_span_cb_exception(self):
def test_cb(span, request):
raise RuntimeError('This should not happen')
tornado_opentracing.init_client_tracing(self.tracer,
start_span_cb=test_cb)
with tornado_context():
response = self.http_fetch(self.get_url('/'))
self.assertEqual(response.code, 200)
spans = self.tracer.finished_spans()
self.assertEqual(len(spans), 1)
self.assertFalse(spans[0].tags.get('error', False))
def test_explicit_parameters(self):
tornado_opentracing.init_client_tracing(self.tracer)
with tornado_context():
response = self.http_fetch(
self.get_url('/error'),
raise_error=False,
method='POST',
body='')
self.assertEqual(response.code, 500)
spans = self.tracer.finished_spans()
self.assertEqual(len(spans), 1)
self.assertTrue(spans[0].finished)
self.assertEqual(spans[0].operation_name, 'POST')
self.assertEqual(spans[0].tags, {
'component': 'tornado',
'span.kind': 'client',
'http.url': self.get_url('/error'),
'http.method': 'POST',
'http.status_code': 500,
})
def test_request_obj(self):
tornado_opentracing.init_client_tracing(self.tracer)
with tornado_context():
response = self.http_fetch(HTTPRequest(self.get_url('/')))
self.assertEqual(response.code, 200)
spans = self.tracer.finished_spans()
self.assertEqual(len(spans), 1)
self.assertTrue(spans[0].finished)
self.assertEqual(spans[0].operation_name, 'GET')
self.assertEqual(spans[0].tags, {
'component': 'tornado',
'span.kind': 'client',
'http.url': self.get_url('/'),
'http.method': 'GET',
'http.status_code': 200,
})
def test_server_error(self):
tornado_opentracing.init_client_tracing(self.tracer)
with tornado_context():
response = self.http_fetch(self.get_url('/error'))
self.assertEqual(response.code, 500)
spans = self.tracer.finished_spans()
self.assertEqual(len(spans), 1)
self.assertTrue(spans[0].finished)
self.assertEqual(spans[0].operation_name, 'GET')
tags = spans[0].tags
self.assertEqual(tags.get('http.status_code', None), 500)
self.assertEqual(tags.get('error', None), True)
logs = spans[0].logs
self.assertEqual(len(logs), 1)
self.assertEqual(logs[0].key_values.get('event', None),
'error')
self.assertTrue(isinstance(
logs[0].key_values.get('error.object', None), Exception
))
def test_server_not_found(self):
tornado_opentracing.init_client_tracing(self.tracer)
with tornado_context():
response = self.http_fetch(
self.get_url('/doesnotexist'),
raise_error=False
)
self.assertEqual(response.code, 404)
spans = self.tracer.finished_spans()
self.assertEqual(len(spans), 1)
self.assertEqual(spans[0].operation_name, 'GET')
tags = spans[0].tags
self.assertEqual(tags.get('http.status_code', None), 404)
self.assertEqual(tags.get('error', None), None) # no error.
self.assertEqual(len(spans[0].logs), 0)
def setUp(self):
self.tracer = MockTracer(AsyncioScopeManager())
self.loop = asyncio.get_event_loop()
def setUp(self):
self.tracer = MockTracer(GeventScopeManager())
def tracer(self, elasticsearch_container):
yield MockTracer()
