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)