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