def test_span_tags_are_sourced(self):
        tracer = MockTracer()
        config.tracer = tracer
        config.span_tags = dict(custom='tag')

        with mock.patch.object(psycopg2.extensions, 'connection',
                               MockDBAPIConnection):
            with mock.patch.object(psycopg2.extensions, 'cursor',
                                   MockDBAPICursor):
                instrument()
                connection = psycopg2.connect(
                    "dbname=test", connection_factory=MockDBAPIConnection)
                with connection as cursor:
                    cursor.executemany('traced')
                    cursor.execute('traced')

                spans = tracer.finished_spans()
                assert len(spans) == 3
                assert spans[
                    0].operation_name == 'MockDBAPICursor.executemany(traced)'
                assert spans[
                    1].operation_name == 'MockDBAPICursor.execute(traced)'
                assert spans[
                    2].operation_name == 'MockDBAPIConnection.commit()'
                for span in spans:
                    assert span.tags['custom'] == 'tag'
    def test_undesired_connection_commands_are_not_traced(self):
        config.traced_commands = ['rollback']
        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.executemany('untraced')
                        cursor.execute('traced')

                    assert not tracer.finished_spans()

                    with connection as cursor:
                        cursor.callproc('untraced')

                    spans = tracer.finished_spans()
                    assert len(spans) == 1
                    assert spans[
                        0].operation_name == 'MockDBAPIConnection.rollback()'
Exemple #3
0
    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()
Exemple #4
0
    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()'
Exemple #5
0
    def test_undesired_cursor_commands_are_not_traced(self):
        config.traced_commands = ['execute']
        tracer = MockTracer()
        config.tracer = tracer

        with mock.patch.object(psycopg2.extensions, 'connection', MockDBAPIConnection):
            with mock.patch.object(psycopg2.extensions, 'cursor', MockDBAPICursor):
                instrument()
                connection = psycopg2.connect("dbname=test", connection_factory=MockDBAPIConnection)
                with connection.cursor() as cursor:
                    cursor.executemany('untraced')
                    cursor.callproc('untraced')
                    cursor.execute('traced')

        spans = tracer.finished_spans()
        assert len(spans) == 1
        assert spans[0].operation_name == 'MockDBAPICursor.execute(traced)'
Exemple #6
0
    def test_global_tracer_used_by_default(self):
        tracer = MockTracer()
        opentracing.tracer = tracer

        with mock.patch.object(psycopg2.extensions, 'cursor', MockDBAPICursor):
            instrument()
            connection = psycopg2.connect("dbname=test", connection_factory=MockDBAPIConnection)
            with connection.cursor() as cursor:
                cursor.execute('traced')
                cursor.executemany('traced')
                cursor.callproc('traced')

        spans = tracer.finished_spans()
        assert len(spans) == 3
        assert spans[0].operation_name == 'MockDBAPICursor.execute(traced)'
        assert spans[1].operation_name == 'MockDBAPICursor.executemany(traced)'
        assert spans[2].operation_name == 'MockDBAPICursor.callproc(traced)'