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)
fastapi_patch()
yield tracer
setattr(ddtrace, "tracer", original_tracer)
fastapi_unpatch()
def test_encoder_propagates_dd_origin():
tracer = DummyTracer()
encoder = MsgpackEncoder(1 << 20, 1 << 20)
with tracer.trace("Root") as root:
root.context.dd_origin = CI_APP_TEST_ORIGIN
for _ in range(999):
with tracer.trace("child"):
pass
# Ensure encoded trace contains dd_origin tag in all spans
trace = tracer.writer.pop()
encoder.put(trace)
decoded_trace = decode(encoder.encode())[0]
for span in decoded_trace:
assert span[b"meta"][b"_dd.origin"] == b"ciapp-test"
def test_encoder_propagates_dd_origin(Encoder, item):
tracer = DummyTracer()
encoder = Encoder(1 << 20, 1 << 20)
with tracer.trace("Root") as root:
root.context.dd_origin = CI_APP_TEST_ORIGIN
for _ in range(999):
with tracer.trace("child"):
pass
trace = tracer.writer.pop()
encoder.put(trace)
decoded_trace = decode(encoder.encode())
# Ensure encoded trace contains dd_origin tag in all spans
assert all(
(_[item][_ORIGIN_KEY] == b"ciapp-test" for _ in decoded_trace[0]))
def tracer():
tracer = DummyTracer()
# Patch Django and override tracer to be our test tracer
pin = Pin.get_from(django)
original_tracer = pin.tracer
Pin.override(django, tracer=tracer)
# Yield to our test
yield tracer
tracer.pop()
# Reset the tracer pinned to Django and unpatch
# DEV: unable to properly unpatch and reload django app with each test
# unpatch()
Pin.override(django, tracer=original_tracer)
def test_inject_tags_many_large(self):
"""When we have too many tags that cause us to reach the max size limit"""
tracer = DummyTracer()
meta = {"_dd.p.test_{}".format(i): "test" * 10 for i in range(100)}
ctx = Context(trace_id=1234,
sampling_priority=2,
dd_origin="synthetics",
meta=meta)
tracer.context_provider.activate(ctx)
with tracer.trace("global_root_span") as span:
headers = {}
HTTPPropagator.inject(span.context, headers)
assert HTTP_HEADER_TAGS not in headers
assert ctx._meta["_dd.propagation_error"] == "max_size"
def test_inject_tags_unicode(self):
"""Unicode characters are not allowed"""
tracer = DummyTracer()
meta = {u"_dd.p.unicode_☺️": u"unicode value ☺️"}
ctx = Context(trace_id=1234,
sampling_priority=2,
dd_origin="synthetics",
meta=meta)
tracer.context_provider.activate(ctx)
with tracer.trace("global_root_span") as span:
headers = {}
HTTPPropagator.inject(span.context, headers)
assert HTTP_HEADER_TAGS not in headers
assert ctx._meta["_dd.propagation_error"] == "encoding_error"
def test_inject_tags_invalid(self):
tracer = DummyTracer()
# DEV: "=" and "," are not allowed in keys or values
meta = {"_dd.p.test=": ",value="}
ctx = Context(trace_id=1234,
sampling_priority=2,
dd_origin="synthetics",
meta=meta)
tracer.context_provider.activate(ctx)
with tracer.trace("global_root_span") as span:
headers = {}
HTTPPropagator.inject(span.context, headers)
assert HTTP_HEADER_TAGS not in headers
assert ctx._meta["_dd.propagation_error"] == "encoding_error"
def _traced_session(self):
tracer = DummyTracer()
# pin the global Cluster to test if they will conflict
Pin(service=self.TEST_SERVICE, tracer=tracer).onto(Cluster)
self.cluster = Cluster(port=CASSANDRA_CONFIG["port"])
return self.cluster.connect(self.TEST_KEYSPACE), tracer
def make_client(self, mock_socket_values, **kwargs):
tracer = DummyTracer()
Pin.override(pymemcache, tracer=tracer)
self.client = pymemcache.client.base.Client((TEST_HOST, TEST_PORT),
**kwargs)
self.client.sock = MockSocket(list(mock_socket_values))
return self.client
def get_tracer_and_connect(self):
tracer = DummyTracer()
Pin.get_from(mongoengine.connect).clone(tracer=tracer).onto(
mongoengine.connect)
mongoengine.connect(port=MONGO_CONFIG["port"])
return tracer
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_distributed_tracing_disabled_via_int_config(self):
config.falcon["distributed_tracing"] = False
self.tracer = DummyTracer()
self.api = get_app(tracer=self.tracer)
if self.version[0] != "1":
self.client = testing.TestClient(self.api)
headers = {
"x-datadog-trace-id": "100",
"x-datadog-parent-id": "42",
}
if self.version[0] == "1":
out = self.simulate_get("/200", headers=headers)
assert out.status_code == 200
else:
out = self.client.simulate_get("/200", headers=headers)
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]) == 1
assert traces[0][0].parent_id != 42
assert traces[0][0].trace_id != 100
def get_tracer_and_client(self):
tracer = DummyTracer()
client = pymongo.MongoClient(port=MONGO_CONFIG["port"])
Pin.get_from(client).clone(tracer=tracer).onto(client)
# We do not wish to trace tcp spans here
Pin.get_from(pymongo.server.Server).remove_from(pymongo.server.Server)
return tracer, client
def setUp(self):
# provide a dummy tracer
self.tracer = DummyTracer()
self._original_tracer = ddtrace.tracer
ddtrace.tracer = self.tracer
# provide a Bottle app
self.app = bottle.Bottle()
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 setUp(self):
super(TestCassandraConfig, self).setUp()
patch()
self.tracer = DummyTracer()
self.cluster = Cluster(port=CASSANDRA_CONFIG["port"])
Pin.get_from(self.cluster).clone(tracer=self.tracer).onto(self.cluster)
self.session = self.cluster.connect(self.TEST_KEYSPACE)
def tracer():
tracer = DummyTracer()
patch()
try:
yield tracer
finally:
unpatch()
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_configuration_service_name(self):
"""Ensure that the integration can be configured."""
with self.override_config("vertica", dict(service_name="test_svc_name")):
patch()
import vertica_python
test_tracer = DummyTracer()
conn = vertica_python.connect(**VERTICA_CONFIG)
cur = conn.cursor()
Pin.override(cur, tracer=test_tracer)
with conn:
cur.execute("DROP TABLE IF EXISTS {}".format(TEST_TABLE))
spans = test_tracer.pop()
assert len(spans) == 1
assert spans[0].service == "test_svc_name"
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 test_inject_tags_large(self):
"""When we have a single large tag that won't fit"""
tracer = DummyTracer()
# DEV: Limit is 512
meta = {"_dd.p.test": "long" * 200}
ctx = Context(trace_id=1234,
sampling_priority=2,
dd_origin="synthetics",
meta=meta)
tracer.context_provider.activate(ctx)
with tracer.trace("global_root_span") as span:
headers = {}
HTTPPropagator.inject(span.context, headers)
assert HTTP_HEADER_TAGS not in headers
assert ctx._meta["_dd.propagation_error"] == "max_size"
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 test_dd_origin_tagging_spans_via_encoder(benchmark, trace_size):
"""Propagate dd_origin tags to all spans in [1, 50, 200, 1000] span trace via Encoder"""
tracer = DummyTracer()
with tracer.trace("pytest-test") as root:
root.context.dd_origin = CI_APP_TEST_ORIGIN
for _ in range(trace_size - 1):
with tracer.trace("") as span:
span.set_tag("tag", "value")
pass
trace = tracer.writer.pop()
benchmark(trace_encoder.encode_trace, trace)
# Ensure encoded trace contains dd_origin tag in all spans
encoded_trace = trace_encoder.encode_trace(trace)
decoded_trace = trace_encoder._decode(encoded_trace)
for span in decoded_trace:
assert span[b"meta"][b"_dd.origin"] == b"ciapp-test"
def get_tracer_and_connect(self):
tracer = DummyTracer()
# Set a connect-level service, to check that we properly override it
Pin(service="not-%s" % self.TEST_SERVICE).onto(mongoengine.connect)
client = mongoengine.connect(port=MONGO_CONFIG["port"])
Pin(service=self.TEST_SERVICE, tracer=tracer).onto(client)
return tracer
def setUp(self):
super(DistributedTracingTestCase, self).setUp()
self._service = "falcon"
self.tracer = DummyTracer()
self.api = get_app(tracer=self.tracer)
self.version = falcon.__version__
if self.version[0] != "1":
self.client = testing.TestClient(self.api)
def get_tracer_and_client(self):
tracer = DummyTracer()
original_client = pymongo.MongoClient(port=MONGO_CONFIG["port"])
client = trace_mongo_client(original_client,
tracer,
service=self.TEST_SERVICE)
# No need to disable tcp spans tracer here as trace_mongo_client does not call
# patch()
return tracer, client
def make_client_pool(self, hostname, mock_socket_values, serializer=None, **kwargs):
mock_client = pymemcache.client.base.Client(hostname, serializer=serializer, **kwargs)
tracer = DummyTracer()
Pin.override(mock_client, tracer=tracer)
mock_client.sock = MockSocket(mock_socket_values)
client = pymemcache.client.base.PooledClient(hostname, serializer=serializer)
client.client_pool = pymemcache.pool.ObjectPool(lambda: mock_client)
return mock_client
def make_client(self, mock_socket_values, **kwargs):
from pymemcache.client.hash import HashClient
tracer = DummyTracer()
Pin.override(pymemcache, tracer=tracer)
self.client = HashClient([(TEST_HOST, TEST_PORT)], **kwargs)
for _c in self.client.clients.values():
_c.sock = MockSocket(list(mock_socket_values))
return self.client
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 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)
