Esempio n. 1
0
    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
Esempio n. 2
0
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,
            })
Esempio n. 3
0
    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()
Esempio n. 5
0
    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()
Esempio n. 6
0
    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()
Esempio n. 7
0
    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()'
Esempio n. 9
0
    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"
Esempio n. 11
0
 def session_tracing(self, echo_container):
     tracer = MockTracer()
     session = SessionTracing(tracer,
                              propagate=True,
                              span_tags=dict(custom='tag'))
     return tracer, session
Esempio n. 12
0
 def setUp(self):
     self.tracer = MockTracer()
     self.client = redis.StrictRedis()
Esempio n. 13
0
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()
Esempio n. 15
0
 def setUp(self):
     self.tracer = MockTracer(ScopeManager())
     super(TestClient, self).setUp()
Esempio n. 16
0
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',
            })
Esempio n. 17
0
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"
Esempio n. 18
0
 def get_app(self):
     self.tracer = MockTracer(ScopeManager())
     return make_app(self.tracer,
                     trace_all=False,
                     start_span_cb=self.start_span_cb)
Esempio n. 19
0
 def tracer(self):
     return MockTracer()
Esempio n. 20
0
 def get_app(self):
     self.tracer = MockTracer(ScopeManager())
     return make_app(self.tracer, trace_all=False)
Esempio n. 21
0
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)
Esempio n. 22
0
 def get_app(self):
     self.tracer = MockTracer(ScopeManager())
     return make_app(tracer_callable='tests.test_tracing.tracer_callable',
                     tracer_parameters={'tracer': self.tracer})
Esempio n. 23
0
 def get_app(self):
     self.tracer = MockTracer(ScopeManager())
     return make_app(tracer_callable=tracer_callable,
                     tracer_parameters={
                         'tracer': self.tracer,
                     })
Esempio n. 24
0
 def test_tracer(self):
     tracer = MockTracer()
     tracing = tornado_opentracing.TornadoTracing(tracer)
     self.assertEqual(tracing.tracer, tracer)
Esempio n. 25
0
 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()
Esempio n. 27
0
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)
Esempio n. 28
0
 def setUp(self):
     self.tracer = MockTracer(AsyncioScopeManager())
     self.loop = asyncio.get_event_loop()
 def setUp(self):
     self.tracer = MockTracer(GeventScopeManager())
Esempio n. 30
0
 def tracer(self, elasticsearch_container):
     yield MockTracer()