def test_opentracing_propagation(self): # ensure OpenTracing plays well with our integration query = """SELECT 'tracing'""" db = self._get_conn() ot_tracer = init_tracer("psycopg-svc", self.tracer) with ot_tracer.start_active_span("db.access"): cursor = db.cursor() cursor.execute(query) rows = cursor.fetchall() self.assertEquals(rows, [("tracing", )]) self.assert_structure( dict(name="db.access", service="psycopg-svc"), (dict(name="postgres.query", resource=query, service="postgres", error=0, span_type="sql"), ), ) assert_is_measured(self.get_spans()[1]) self.reset() with self.override_config("psycopg", dict(trace_fetch_methods=True)): db = self._get_conn() ot_tracer = init_tracer("psycopg-svc", self.tracer) with ot_tracer.start_active_span("db.access"): cursor = db.cursor() cursor.execute(query) rows = cursor.fetchall() self.assertEquals(rows, [("tracing", )]) self.assert_structure( dict(name="db.access", service="psycopg-svc"), ( dict(name="postgres.query", resource=query, service="postgres", error=0, span_type="sql"), dict(name="postgres.query.fetchall", resource=query, service="postgres", error=0, span_type="sql"), ), ) assert_is_measured(self.get_spans()[1])
def test_opentracing_propagation(self): # ensure OpenTracing plays well with our integration query = """SELECT 'tracing'""" db = self._get_conn() ot_tracer = init_tracer('psycopg-svc', self.tracer) with ot_tracer.start_active_span('db.access'): cursor = db.cursor() cursor.execute(query) rows = cursor.fetchall() self.assertEquals(rows, [('tracing', )]) self.assert_structure( dict(name='db.access', service='psycopg-svc'), (dict(name='postgres.query', resource=query, service='postgres', error=0, span_type='sql'), ), ) self.reset() with self.override_config('dbapi2', dict(trace_fetch_methods=True)): db = self._get_conn() ot_tracer = init_tracer('psycopg-svc', self.tracer) with ot_tracer.start_active_span('db.access'): cursor = db.cursor() cursor.execute(query) rows = cursor.fetchall() self.assertEquals(rows, [('tracing', )]) self.assert_structure( dict(name='db.access', service='psycopg-svc'), ( dict(name='postgres.query', resource=query, service='postgres', error=0, span_type='sql'), dict(name='postgres.query.fetchall', resource=query, service='postgres', error=0, span_type='sql'), ), )
def test_traced_client_ot(self): """OpenTracing version of test_traced_client.""" ot_tracer = init_tracer("ec2_svc", self.tracer) with ot_tracer.start_active_span("ec2_op"): ec2 = self.session.create_client("ec2", region_name="us-west-2") Pin(service=self.TEST_SERVICE, tracer=self.tracer).onto(ec2) ec2.describe_instances() spans = self.get_spans() assert spans self.assertEqual(len(spans), 2) ot_span, dd_span = spans # confirm the parenting self.assertIsNone(ot_span.parent_id) self.assertEqual(dd_span.parent_id, ot_span.span_id) self.assertEqual(ot_span.name, "ec2_op") self.assertEqual(ot_span.service, "ec2_svc") self.assertEqual(dd_span.get_tag("aws.agent"), "botocore") self.assertEqual(dd_span.get_tag("aws.region"), "us-west-2") self.assertEqual(dd_span.get_tag("aws.operation"), "DescribeInstances") assert_span_http_status_code(dd_span, 200) self.assertEqual(dd_span.get_metric("retry_attempts"), 0) self.assertEqual(dd_span.service, "test-botocore-tracing.ec2") self.assertEqual(dd_span.resource, "ec2.describeinstances") self.assertEqual(dd_span.name, "ec2.command")
def test_traced_client_ot(self): """OpenTracing version of test_traced_client.""" ot_tracer = init_tracer('ec2_svc', self.tracer) with ot_tracer.start_active_span('ec2_op'): ec2 = self.session.create_client('ec2', region_name='us-west-2') Pin(service=self.TEST_SERVICE, tracer=self.tracer).onto(ec2) ec2.describe_instances() spans = self.get_spans() assert spans self.assertEqual(len(spans), 2) ot_span, dd_span = spans # confirm the parenting self.assertIsNone(ot_span.parent_id) self.assertEqual(dd_span.parent_id, ot_span.span_id) self.assertEqual(ot_span.name, 'ec2_op') self.assertEqual(ot_span.service, 'ec2_svc') self.assertEqual(dd_span.get_tag('aws.agent'), 'botocore') self.assertEqual(dd_span.get_tag('aws.region'), 'us-west-2') self.assertEqual(dd_span.get_tag('aws.operation'), 'DescribeInstances') assert_span_http_status_code(dd_span, 200) self.assertEqual(dd_span.get_metric('retry_attempts'), 0) self.assertEqual(dd_span.service, 'test-botocore-tracing.ec2') self.assertEqual(dd_span.resource, 'ec2.describeinstances') self.assertEqual(dd_span.name, 'ec2.command')
def test_opentracing(self): """Ensure OpenTracing works with vertica.""" conn, cur = self.test_conn ot_tracer = init_tracer('vertica_svc', self.test_tracer) with ot_tracer.start_active_span('vertica_execute'): cur.execute( "INSERT INTO {} (a, b) VALUES (1, 'aa');".format(TEST_TABLE)) conn.close() spans = self.test_tracer.writer.pop() assert len(spans) == 2 ot_span, dd_span = spans # confirm the parenting assert ot_span.parent_id is None assert dd_span.parent_id == ot_span.span_id assert_is_measured(dd_span) assert dd_span.service == 'vertica' assert dd_span.span_type == 'sql' assert dd_span.name == 'vertica.query' assert dd_span.get_metric('db.rowcount') == -1 query = "INSERT INTO test_table (a, b) VALUES (1, 'aa');" assert dd_span.resource == query assert dd_span.get_tag('out.host') == '127.0.0.1' assert dd_span.get_metric('out.port') == 5433
def test_success_handler_ot(self): """OpenTracing version of test_success_handler.""" ot_tracer = init_tracer('tornado_svc', self.tracer, scope_manager=TornadoScopeManager()) with ot_tracer.start_active_span('tornado_op'): response = self.fetch('/success/') assert 200 == response.code traces = self.tracer.writer.pop_traces() assert 1 == len(traces) assert 2 == len(traces[0]) # dd_span will start and stop before the ot_span finishes ot_span, dd_span = traces[0] # confirm the parenting assert ot_span.parent_id is None assert dd_span.parent_id == ot_span.span_id assert ot_span.name == 'tornado_op' assert ot_span.service == 'tornado_svc' assert 'tornado-web' == dd_span.service assert 'tornado.request' == dd_span.name assert 'http' == dd_span.span_type assert 'tests.contrib.tornado.web.app.SuccessHandler' == dd_span.resource assert 'GET' == dd_span.get_tag('http.method') assert '200' == dd_span.get_tag('http.status_code') assert self.get_url('/success/') == dd_span.get_tag(http.URL) assert 0 == dd_span.error
def test_trace_multiple_coroutines_ot_inner(self): """OpenTracing version of test_trace_multiple_coroutines.""" # if multiple coroutines have nested tracing, they must belong # to the same trace ot_tracer = init_tracer('asyncio_svc', self.tracer) @asyncio.coroutine def coro(): # another traced coroutine with ot_tracer.start_active_span('coroutine_2'): return 42 with self.tracer.trace('coroutine_1'): value = yield from coro() # the coroutine has been called correctly assert 42 == value # a single trace has been properly reported traces = self.tracer.writer.pop_traces() assert 1 == len(traces) assert 2 == len(traces[0]) assert 'coroutine_1' == traces[0][0].name assert 'coroutine_2' == traces[0][1].name # the parenting is correct assert traces[0][0] == traces[0][1]._parent assert traces[0][0].trace_id == traces[0][1].trace_id
def test_httplib_request_get_request_ot(self): """ OpenTracing version of test with same name. """ ot_tracer = init_tracer("my_svc", self.tracer) with ot_tracer.start_active_span("ot_span"): conn = self.get_http_connection(SOCKET) with contextlib.closing(conn): conn.request("GET", "/status/200") resp = conn.getresponse() self.assertEqual(self.to_str(resp.read()), "") self.assertEqual(resp.status, 200) spans = self.pop_spans() self.assertEqual(len(spans), 2) ot_span, dd_span = spans # confirm the parenting self.assertEqual(ot_span.parent_id, None) self.assertEqual(dd_span.parent_id, ot_span.span_id) self.assertEqual(ot_span.service, "my_svc") self.assertEqual(ot_span.name, "ot_span") self.assert_is_not_measured(dd_span) self.assertEqual(dd_span.span_type, "http") self.assertEqual(dd_span.name, self.SPAN_NAME) self.assertEqual(dd_span.error, 0) assert dd_span.get_tag("http.method") == "GET" assert_span_http_status_code(dd_span, 200) assert dd_span.get_tag("http.url") == URL_200
def test_simple_query_ot_fetchall(self): """OpenTracing version of test_simple_query.""" with self.override_config("dbapi2", dict(trace_fetch_methods=True)): conn, tracer = self._get_conn_tracer() writer = tracer.writer ot_tracer = init_tracer("mysql_svc", tracer) with ot_tracer.start_active_span("mysql_op"): cursor = conn.cursor() cursor.execute("SELECT 1") rows = cursor.fetchall() assert len(rows) == 1 spans = writer.pop() assert len(spans) == 3 ot_span, dd_span, fetch_span = spans # confirm parenting assert ot_span.parent_id is None assert dd_span.parent_id == ot_span.span_id assert ot_span.service == "mysql_svc" assert ot_span.name == "mysql_op" assert_is_measured(dd_span) assert dd_span.service == "pymysql" assert dd_span.name == "pymysql.query" assert dd_span.span_type == "sql" assert dd_span.error == 0 assert dd_span.get_metric("out.port") == MYSQL_CONFIG.get("port") meta = {} meta.update(self.DB_INFO) assert_dict_issuperset(dd_span.meta, meta) assert fetch_span.name == "pymysql.query.fetchall"
def test_simple_cache_get_ot(self): """OpenTracing version of test_simple_cache_get.""" ot_tracer = init_tracer("my_svc", self.tracer) # create the TracedCache instance for a Flask app Cache = get_traced_cache(self.tracer, service=self.SERVICE) app = Flask(__name__) cache = Cache(app, config={"CACHE_TYPE": "simple"}) with ot_tracer.start_active_span("ot_span"): cache.get(u"á_complex_operation") spans = self.get_spans() self.assertEqual(len(spans), 2) ot_span, dd_span = spans # confirm the parenting self.assertIsNone(ot_span.parent_id) self.assertEqual(dd_span.parent_id, ot_span.span_id) self.assertEqual(ot_span.resource, "ot_span") self.assertEqual(ot_span.service, "my_svc") self.assertEqual(dd_span.service, self.SERVICE) self.assertEqual(dd_span.resource, "get") self.assertEqual(dd_span.name, "flask_cache.cmd") self.assertEqual(dd_span.span_type, "cache") self.assertEqual(dd_span.error, 0) expected_meta = { "flask_cache.key": u"á_complex_operation", "flask_cache.backend": "simple", } assert_dict_issuperset(dd_span.meta, expected_meta)
def test_fn_task_apply_async_ot(self): """OpenTracing version of test_fn_task_apply_async.""" ot_tracer = init_tracer('celery_svc', self.tracer) # it should execute a traced async task that has parameters @self.app.task def fn_task_parameters(user, force_logout=False): return (user, force_logout) with ot_tracer.start_active_span('celery_op'): t = fn_task_parameters.apply_async(args=['user'], kwargs={'force_logout': True}) assert 'PENDING' == t.status traces = self.tracer.writer.pop_traces() assert 1 == len(traces) assert 2 == len(traces[0]) ot_span, dd_span = traces[0] # confirm the parenting assert ot_span.parent_id is None assert dd_span.parent_id == ot_span.span_id assert ot_span.name == 'celery_op' assert ot_span.service == 'celery_svc' assert_is_measured(dd_span) assert dd_span.error == 0 assert dd_span.name == 'celery.apply' assert dd_span.resource == 'tests.contrib.celery.test_integration.fn_task_parameters' assert dd_span.service == 'celery-producer' assert dd_span.get_tag('celery.id') == t.task_id assert dd_span.get_tag('celery.action') == 'apply_async' assert dd_span.get_tag('celery.routing_key') == 'celery'
def test_trace_multiple_coroutines_ot_inner(self): """OpenTracing version of test_trace_multiple_coroutines.""" # if multiple coroutines have nested tracing, they must belong # to the same trace ot_tracer = init_tracer('asyncio_svc', self.tracer) @asyncio.coroutine def coro(): # another traced coroutine with ot_tracer.start_active_span('coroutine_2'): return 42 with self.tracer.trace('coroutine_1'): value = yield from coro() # the coroutine has been called correctly eq_(42, value) # a single trace has been properly reported traces = self.tracer.writer.pop_traces() eq_(1, len(traces)) eq_(2, len(traces[0])) eq_('coroutine_1', traces[0][0].name) eq_('coroutine_2', traces[0][1].name) # the parenting is correct eq_(traces[0][0], traces[0][1]._parent) eq_(traces[0][0].trace_id, traces[0][1].trace_id)
def test_simple_query_ot(self): """OpenTracing version of test_simple_query.""" conn, tracer = self._get_conn_tracer() writer = tracer.writer ot_tracer = init_tracer('mysql_svc', tracer) with ot_tracer.start_active_span('mysql_op'): cursor = conn.cursor() cursor.execute('SELECT 1') rows = cursor.fetchall() assert len(rows) == 1 spans = writer.pop() assert len(spans) == 2 ot_span, dd_span = spans # confirm parenting assert ot_span.parent_id is None assert dd_span.parent_id == ot_span.span_id assert ot_span.service == 'mysql_svc' assert ot_span.name == 'mysql_op' assert dd_span.service == self.TEST_SERVICE assert dd_span.name == 'mysql.query' assert dd_span.span_type == 'sql' assert dd_span.error == 0 assert_dict_issuperset( dd_span.meta, { 'out.host': u'127.0.0.1', 'out.port': u'3306', 'db.name': u'test', 'db.user': u'test', })
def test_sqlite_ot(self): """Ensure sqlite works with the opentracer.""" tracer = get_dummy_tracer() ot_tracer = init_tracer('sqlite_svc', tracer) # Ensure we can run a query and it's correctly traced q = "select * from sqlite_master" with ot_tracer.start_active_span('sqlite_op'): db = sqlite3.connect(":memory:") pin = Pin.get_from(db) assert pin eq_("db", pin.app_type) pin.clone(tracer=tracer).onto(db) cursor = db.execute(q) rows = cursor.fetchall() assert not rows spans = tracer.writer.pop() assert spans print(spans) eq_(len(spans), 2) ot_span, dd_span = spans # confirm the parenting eq_(ot_span.parent_id, None) eq_(dd_span.parent_id, ot_span.span_id) eq_(ot_span.name, 'sqlite_op') eq_(ot_span.service, 'sqlite_svc') eq_(dd_span.name, "sqlite.query") eq_(dd_span.span_type, "sql") eq_(dd_span.resource, q) ok_(dd_span.get_tag("sql.query") is None) eq_(dd_span.error, 0)
def test_simple_query_ot(self): """OpenTracing version of test_simple_query.""" conn, tracer = self._get_conn_tracer() writer = tracer.writer ot_tracer = init_tracer('mysql_svc', tracer) with ot_tracer.start_active_span('mysql_op'): cursor = conn.cursor() cursor.execute("SELECT 1") rows = cursor.fetchall() eq_(len(rows), 1) spans = writer.pop() eq_(len(spans), 3) ot_span, dd_span, fetch_span = spans # confirm parenting eq_(ot_span.parent_id, None) eq_(dd_span.parent_id, ot_span.span_id) eq_(ot_span.service, 'mysql_svc') eq_(ot_span.name, 'mysql_op') eq_(dd_span.service, self.TEST_SERVICE) eq_(dd_span.name, 'pymysql.query') eq_(dd_span.span_type, 'sql') eq_(dd_span.error, 0) meta = {} meta.update(self.DB_INFO) assert_dict_issuperset(dd_span.meta, meta) eq_(fetch_span.name, 'pymysql.query.fetchall')
def test_success_handler_ot(self): """OpenTracing version of test_success_handler.""" from opentracing.scope_managers.tornado import TornadoScopeManager ot_tracer = init_tracer("tornado_svc", self.tracer, scope_manager=TornadoScopeManager()) with ot_tracer.start_active_span("tornado_op"): response = self.fetch("/success/") assert 200 == response.code traces = self.pop_traces() assert 1 == len(traces) assert 2 == len(traces[0]) # dd_span will start and stop before the ot_span finishes ot_span, dd_span = traces[0] # confirm the parenting assert ot_span.parent_id is None assert dd_span.parent_id == ot_span.span_id assert ot_span.name == "tornado_op" assert ot_span.service == "tornado_svc" assert_is_measured(dd_span) assert "tornado-web" == dd_span.service assert "tornado.request" == dd_span.name assert "web" == dd_span.span_type assert "tests.contrib.tornado.web.app.SuccessHandler" == dd_span.resource assert "GET" == dd_span.get_tag("http.method") assert_span_http_status_code(dd_span, 200) assert self.get_url("/success/") == dd_span.get_tag(http.URL) assert 0 == dd_span.error
def test_success_handler_ot(self): """OpenTracing version of test_success_handler.""" ot_tracer = init_tracer('tornado_svc', self.tracer, scope_manager=TornadoScopeManager()) with ot_tracer.start_active_span('tornado_op'): response = self.fetch('/success/') eq_(200, response.code) traces = self.tracer.writer.pop_traces() eq_(1, len(traces)) eq_(2, len(traces[0])) # dd_span will start and stop before the ot_span finishes ot_span, dd_span = traces[0] # confirm the parenting eq_(ot_span.parent_id, None) eq_(dd_span.parent_id, ot_span.span_id) eq_(ot_span.name, 'tornado_op') eq_(ot_span.service, 'tornado_svc') eq_('tornado-web', dd_span.service) eq_('tornado.request', dd_span.name) eq_('http', dd_span.span_type) eq_('tests.contrib.tornado.web.app.SuccessHandler', dd_span.resource) eq_('GET', dd_span.get_tag('http.method')) eq_('200', dd_span.get_tag('http.status_code')) eq_('/success/', dd_span.get_tag('http.url')) eq_(0, dd_span.error)
def test_opentracing(self): """Ensure the opentracer works with mongoengine.""" tracer = self.get_tracer_and_connect() ot_tracer = init_tracer('my_svc', tracer) with ot_tracer.start_active_span('ot_span'): start = time.time() Artist.drop_collection() end = time.time() # ensure we get a drop collection span spans = tracer.writer.pop() assert len(spans) == 2 ot_span, dd_span = spans # confirm the parenting assert ot_span.parent_id is None assert dd_span.parent_id == ot_span.span_id assert ot_span.name == 'ot_span' assert ot_span.service == 'my_svc' assert_is_measured(dd_span) assert dd_span.resource == 'drop artist' assert dd_span.span_type == 'mongodb' assert dd_span.service == self.TEST_SERVICE _assert_timing(dd_span, start, end)
def test_success_200_ot(self): """OpenTracing version of test_success_200.""" ot_tracer = init_tracer("my_svc", self.tracer) writer = self.tracer.writer with ot_tracer.start_active_span("ot_span"): start = time.time() rv = self.client.get("/") end = time.time() # ensure request worked assert rv.status_code == 200 assert rv.data == b"hello" # ensure trace worked assert not self.tracer.current_span(), self.tracer.current_span( ).pprint() spans = writer.pop() assert len(spans) == 2 ot_span, dd_span = spans # confirm the parenting assert ot_span.parent_id is None assert dd_span.parent_id == ot_span.span_id assert ot_span.resource == "ot_span" assert ot_span.service == "my_svc" assert dd_span.resource == "index" assert dd_span.start >= start assert dd_span.duration <= end - start assert dd_span.error == 0 assert_span_http_status_code(dd_span, 200) assert dd_span.meta.get(http.METHOD) == "GET"
def test_opentracing(self): """Ensure the opentracer works with mongoengine.""" tracer = self.get_tracer_and_connect() ot_tracer = init_tracer('my_svc', tracer) with ot_tracer.start_active_span('ot_span'): start = time.time() Artist.drop_collection() end = time.time() # ensure we get a drop collection span spans = tracer.writer.pop() eq_(len(spans), 2) ot_span, dd_span = spans # confirm the parenting eq_(ot_span.parent_id, None) eq_(dd_span.parent_id, ot_span.span_id) eq_(ot_span.name, 'ot_span') eq_(ot_span.service, 'my_svc') eq_(dd_span.resource, 'drop artist') eq_(dd_span.span_type, 'mongodb') eq_(dd_span.service, self.TEST_SERVICE) _assert_timing(dd_span, start, end)
def test_httplib_request_get_request_ot(self): """ OpenTracing version of test with same name. """ ot_tracer = init_tracer('my_svc', self.tracer) with ot_tracer.start_active_span('ot_span'): conn = self.get_http_connection(SOCKET) with contextlib.closing(conn): conn.request('GET', '/status/200') resp = conn.getresponse() self.assertEqual(self.to_str(resp.read()), '') self.assertEqual(resp.status, 200) spans = self.tracer.writer.pop() self.assertEqual(len(spans), 2) ot_span, dd_span = spans # confirm the parenting self.assertEqual(ot_span.parent_id, None) self.assertEqual(dd_span.parent_id, ot_span.span_id) self.assertEqual(ot_span.service, 'my_svc') self.assertEqual(ot_span.name, 'ot_span') self.assertEqual(dd_span.span_type, 'http') self.assertEqual(dd_span.name, self.SPAN_NAME) self.assertEqual(dd_span.error, 0) assert_dict_issuperset(dd_span.meta, { 'http.method': 'GET', 'http.status_code': '200', 'http.url': URL_200, })
def test_200_ot(self): """OpenTracing version of test_200.""" ot_tracer = init_tracer('requests_svc', self.tracer) with ot_tracer.start_active_span('requests_get'): out = self.session.get(URL_200) eq_(out.status_code, 200) # validation spans = self.tracer.writer.pop() eq_(len(spans), 2) ot_span, dd_span = spans # confirm the parenting eq_(ot_span.parent_id, None) eq_(dd_span.parent_id, ot_span.span_id) eq_(ot_span.name, 'requests_get') eq_(ot_span.service, 'requests_svc') eq_(dd_span.get_tag(http.METHOD), 'GET') eq_(dd_span.get_tag(http.STATUS_CODE), '200') eq_(dd_span.error, 0) eq_(dd_span.span_type, http.TYPE)
def test_opentraced_client(self): from tests.opentracer.utils import init_tracer ot_tracer = init_tracer('my_svc', self.tracer) with ot_tracer.start_active_span('ot_outer_span'): with aiobotocore_client('ec2', self.tracer) as ec2: yield from ec2.describe_instances() traces = self.tracer.writer.pop_traces() print(traces) self.assertEqual(len(traces), 1) self.assertEqual(len(traces[0]), 2) ot_span = traces[0][0] dd_span = traces[0][1] self.assertEqual(ot_span.resource, 'ot_outer_span') self.assertEqual(ot_span.service, 'my_svc') # confirm the parenting self.assertEqual(ot_span.parent_id, None) self.assertEqual(dd_span.parent_id, ot_span.span_id) self.assertEqual(dd_span.get_tag('aws.agent'), 'aiobotocore') self.assertEqual(dd_span.get_tag('aws.region'), 'us-west-2') self.assertEqual(dd_span.get_tag('aws.operation'), 'DescribeInstances') self.assertEqual(dd_span.get_tag('http.status_code'), '200') self.assertEqual(dd_span.get_tag('retry_attempts'), '0') self.assertEqual(dd_span.service, 'aws.ec2') self.assertEqual(dd_span.resource, 'ec2.describeinstances') self.assertEqual(dd_span.name, 'ec2.command')
def test_200_ot(self): """OpenTracing version of test_200.""" ot_tracer = init_tracer("my_svc", self.tracer) if self.version[0] == "1": with ot_tracer.start_active_span("ot_span"): out = self.simulate_get("/200") assert out.status_code == 200 else: with ot_tracer.start_active_span("ot_span"): out = self.client.simulate_get("/200") assert out.status[:3] == "200" assert out.content.decode("utf-8") == "Success" traces = self.tracer.writer.pop_traces() assert len(traces) == 1 assert len(traces[0]) == 2 ot_span, dd_span = traces[0] # confirm the parenting assert ot_span.parent_id is None assert dd_span.parent_id == ot_span.span_id assert ot_span.service == "my_svc" assert ot_span.resource == "ot_span" assert_is_measured(dd_span) assert dd_span.name == "falcon.request" assert dd_span.service == self._service assert dd_span.resource == "GET tests.contrib.falcon.app.resources.Resource200" assert_span_http_status_code(dd_span, 200) assert dd_span.get_tag(httpx.URL) == "http://falconframework.org/200" assert dd_span.error == 0
async def test_opentraced_client(tracer): from tests.opentracer.utils import init_tracer ot_tracer = init_tracer("my_svc", tracer) with ot_tracer.start_active_span("ot_outer_span"): with aiobotocore_client("ec2", tracer) as ec2: await ec2.describe_instances() traces = tracer.pop_traces() assert len(traces) == 1 assert len(traces[0]) == 2 ot_span = traces[0][0] dd_span = traces[0][1] assert ot_span.resource == "ot_outer_span" assert ot_span.service == "my_svc" # confirm the parenting assert ot_span.parent_id is None assert dd_span.parent_id == ot_span.span_id assert_is_measured(dd_span) assert dd_span.get_tag("aws.agent") == "aiobotocore" assert dd_span.get_tag("aws.region") == "us-west-2" assert dd_span.get_tag("aws.operation") == "DescribeInstances" assert_span_http_status_code(dd_span, 200) assert dd_span.get_metric("retry_attempts") == 0 assert dd_span.service == "aws.ec2" assert dd_span.resource == "ec2.describeinstances" assert dd_span.name == "ec2.command"
def test_200_ot(self): """OpenTracing version of test_200.""" ot_tracer = init_tracer('my_svc', self.tracer) with ot_tracer.start_active_span('ot_span'): out = self.simulate_get('/200') eq_(out.status_code, 200) eq_(out.content.decode('utf-8'), 'Success') traces = self.tracer.writer.pop_traces() eq_(len(traces), 1) eq_(len(traces[0]), 2) ot_span, dd_span = traces[0] # confirm the parenting eq_(ot_span.parent_id, None) eq_(dd_span.parent_id, ot_span.span_id) eq_(ot_span.service, 'my_svc') eq_(ot_span.resource, 'ot_span') eq_(dd_span.name, 'falcon.request') eq_(dd_span.service, self._service) eq_(dd_span.resource, 'GET tests.contrib.falcon.app.resources.Resource200') eq_(dd_span.get_tag(httpx.STATUS_CODE), '200') eq_(dd_span.get_tag(httpx.URL), 'http://falconframework.org/200')
def test_trace_spawn_multiple_greenlets_multiple_traces_ot(self): """OpenTracing version of the same test.""" ot_tracer = init_tracer("my_svc", self.tracer, scope_manager=GeventScopeManager()) def entrypoint(): with ot_tracer.start_active_span("greenlet.main") as span: span.resource = "base" jobs = [gevent.spawn(green_1), gevent.spawn(green_2)] gevent.joinall(jobs) def green_1(): with self.tracer.trace("greenlet.worker1") as span: span.set_tag("worker_id", "1") gevent.sleep(0.01) # note that replacing the `tracer.trace` call here with the # OpenTracing equivalent will cause the checks to fail def green_2(): with ot_tracer.start_active_span("greenlet.worker2") as scope: scope.span.set_tag("worker_id", "2") gevent.sleep(0.01) gevent.spawn(entrypoint).join() spans = self.tracer.writer.pop() self._assert_spawn_multiple_greenlets(spans)
def test_propagation_ot(self): """OpenTracing version of test_propagation.""" # it must propagate the tracing context if available ot_tracer = init_tracer("my_svc", self.tracer) def fn(): # an active context must be available self.assertTrue(self.tracer.context_provider.active() is not None) with self.tracer.trace("executor.thread"): return 42 with self.override_global_tracer(): with ot_tracer.start_active_span("main.thread"): with concurrent.futures.ThreadPoolExecutor( max_workers=2) as executor: future = executor.submit(fn) result = future.result() # assert the right result self.assertEqual(result, 42) # the trace must be completed self.assert_structure( dict(name="main.thread"), (dict(name="executor.thread"), ), )
def test_opentracing(self): """Ensure OpenTracing works with redis.""" ot_tracer = init_tracer('redis_svc', self.tracer) with ot_tracer.start_active_span('redis_get'): us = self.r.get('cheese') eq_(us, None) spans = self.get_spans() eq_(len(spans), 2) ot_span, dd_span = spans # confirm the parenting eq_(ot_span.parent_id, None) eq_(dd_span.parent_id, ot_span.span_id) eq_(ot_span.name, 'redis_get') eq_(ot_span.service, 'redis_svc') eq_(dd_span.service, self.TEST_SERVICE) eq_(dd_span.name, 'redis.command') eq_(dd_span.span_type, 'redis') eq_(dd_span.error, 0) eq_(dd_span.get_tag('out.redis_db'), '0') eq_(dd_span.get_tag('out.host'), 'localhost') eq_(dd_span.get_tag('redis.raw_command'), u'GET cheese') eq_(dd_span.get_metric('redis.args_length'), 2) eq_(dd_span.resource, 'GET cheese')
def test_opentracing(self): """Ensure that sqlalchemy works with the opentracer.""" ot_tracer = init_tracer('sqlalch_svc', self.tracer) with ot_tracer.start_active_span('sqlalch_op'): with self.connection() as conn: rows = conn.execute('SELECT * FROM players').fetchall() assert len(rows) == 0 traces = self.tracer.writer.pop_traces() # trace composition assert len(traces) == 1 assert len(traces[0]) == 2 ot_span, dd_span = traces[0] # confirm the parenting assert ot_span.parent_id is None assert dd_span.parent_id == ot_span.span_id assert ot_span.name == 'sqlalch_op' assert ot_span.service == 'sqlalch_svc' # span fields assert dd_span.name == '{}.query'.format(self.VENDOR) assert dd_span.service == self.SERVICE assert dd_span.resource == 'SELECT * FROM players' assert dd_span.get_tag('sql.db') == self.SQL_DB assert dd_span.span_type == 'sql' assert dd_span.error == 0 assert dd_span.duration > 0