def test_patch_unpatch(self):
tracer = DummyTracer()
# Test patch idempotence
patch()
patch()
r = redis.Redis(port=REDIS_CONFIG["port"])
Pin.get_from(r).clone(tracer=tracer).onto(r)
r.get("key")
spans = tracer.pop()
assert spans, spans
assert len(spans) == 1
# Test unpatch
unpatch()
r = redis.Redis(port=REDIS_CONFIG["port"])
r.get("key")
spans = tracer.pop()
assert not spans, spans
# Test patch again
patch()
r = redis.Redis(port=REDIS_CONFIG["port"])
Pin.get_from(r).clone(tracer=tracer).onto(r)
r.get("key")
spans = tracer.pop()
assert spans, spans
assert len(spans) == 1
def test_pre_v4():
tracer = DummyTracer()
MySQL = get_traced_pymysql_connection(tracer, service="my-mysql-server")
conn = MySQL(**config.MYSQL_CONFIG)
cursor = conn.cursor()
cursor.execute("SELECT 1")
assert cursor.fetchone()[0] == 1
def test_log_unfinished_spans_disabled(self, log):
# the trace finished status logging is disabled
tracer = DummyTracer()
ctx = Context()
# manually create a root-child trace
root = Span(tracer=tracer, name="root")
child_1 = Span(tracer=tracer,
name="child_1",
trace_id=root.trace_id,
parent_id=root.span_id)
child_2 = Span(tracer=tracer,
name="child_2",
trace_id=root.trace_id,
parent_id=root.span_id)
child_1._parent = root
child_2._parent = root
ctx.add_span(root)
ctx.add_span(child_1)
ctx.add_span(child_2)
# close only the parent
root.finish()
# the logger has never been invoked to print unfinished spans
for call, _ in log.call_args_list:
msg = call[0]
assert "the trace has %d unfinished spans" not in msg
def nop_tracer():
from ddtrace.opentracer import Tracer
tracer = Tracer(service_name="mysvc", config={})
# use the same test tracer used by the primary tests
tracer._tracer = DummyTracer()
return tracer
def tracer():
tracer = DummyTracer()
if sys.version_info < (3, 7):
# enable legacy asyncio support
from ddtrace.contrib.asyncio.provider import AsyncioContextProvider
tracer.configure(context_provider=AsyncioContextProvider())
yield tracer
def setUp(self):
self.tracer = DummyTracer()
self.traced_app = TraceMiddleware(
cherrypy,
self.tracer,
service="test.cherrypy.service",
distributed_tracing=True,
)
def tracer_with_debug_logging():
# All the tracers, dummy or not, shares the same logging object.
tracer = DummyTracer()
level = tracer.log.level
tracer.log.setLevel(logging.DEBUG)
try:
yield tracer
finally:
tracer.log.setLevel(level)
def test_redis_legacy():
# ensure the old interface isn't broken, but doesn't trace
tracer = DummyTracer()
TracedRedisCache = get_traced_redis(tracer, "foo")
r = TracedRedisCache(port=REDIS_CONFIG["port"])
r.set("a", "b")
got = r.get("a")
assert compat.to_unicode(got) == "b"
assert not tracer.pop()
def make_ot_tracer(service_name="my_svc", config=None, scope_manager=None, context_provider=None):
config = config or {}
tracer = Tracer(service_name=service_name, config=config, scope_manager=scope_manager)
# similar to how we test the ddtracer, use a dummy tracer
dd_tracer = DummyTracer()
if context_provider:
dd_tracer.configure(context_provider=context_provider)
# attach the dummy tracer to the opentracer
tracer._dd_tracer = dd_tracer
return tracer
def tracer():
original_tracer = ddtrace.tracer
tracer = DummyTracer()
if sys.version_info < (3, 7):
# enable legacy asyncio support
from ddtrace.contrib.asyncio.provider import AsyncioContextProvider
tracer.configure(context_provider=AsyncioContextProvider())
setattr(ddtrace, "tracer", tracer)
patch()
yield tracer
setattr(ddtrace, "tracer", original_tracer)
unpatch()
def test_inject(self):
tracer = DummyTracer()
ctx = Context(trace_id=1234,
sampling_priority=2,
dd_origin="synthetics")
tracer.context_provider.activate(ctx)
with tracer.trace("global_root_span") as span:
headers = {}
HTTPPropagator.inject(span.context, headers)
assert int(headers[HTTP_HEADER_TRACE_ID]) == span.trace_id
assert int(headers[HTTP_HEADER_PARENT_ID]) == span.span_id
assert int(headers[HTTP_HEADER_SAMPLING_PRIORITY]
) == span.context.sampling_priority
assert headers[HTTP_HEADER_ORIGIN] == span.context.dd_origin
def test_extract(self):
tracer = DummyTracer()
headers = {
"x-datadog-trace-id": "1234",
"x-datadog-parent-id": "5678",
"x-datadog-sampling-priority": "1",
"x-datadog-origin": "synthetics",
}
context = HTTPPropagator.extract(headers)
tracer.context_provider.activate(context)
with tracer.trace("local_root_span") as span:
assert span.trace_id == 1234
assert span.parent_id == 5678
assert span.context.sampling_priority == 1
assert span.context.dd_origin == "synthetics"
def test_WSGI_extract(self):
"""Ensure we support the WSGI formatted headers as well."""
tracer = DummyTracer()
headers = {
"HTTP_X_DATADOG_TRACE_ID": "1234",
"HTTP_X_DATADOG_PARENT_ID": "5678",
"HTTP_X_DATADOG_SAMPLING_PRIORITY": "1",
"HTTP_X_DATADOG_ORIGIN": "synthetics",
}
context = HTTPPropagator.extract(headers)
tracer.context_provider.activate(context)
with tracer.trace("local_root_span") as span:
assert span.trace_id == 1234
assert span.parent_id == 5678
assert span.context.sampling_priority == 1
assert span.context.dd_origin == "synthetics"
def test_log_unfinished_spans_when_ok(self, log):
# if the unfinished spans logging is enabled but the trace is finished, don't log anything
tracer = DummyTracer()
ctx = Context()
# manually create a root-child trace
root = Span(tracer=tracer, name="root")
child = Span(tracer=tracer,
name="child_1",
trace_id=root.trace_id,
parent_id=root.span_id)
child._parent = root
ctx.add_span(root)
ctx.add_span(child)
# close the trace
child.finish()
root.finish()
# the logger has never been invoked to print unfinished spans
for call, _ in log.call_args_list:
msg = call[0]
assert "the trace has %d unfinished spans" not in msg
def get_dummy_tracer():
return DummyTracer()
def tracer():
tracer = DummyTracer()
return tracer
def tracer():
return DummyTracer()