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
