def setUp(self): # use a dummy tracer self.tracer = get_dummy_tracer() self._original_tracer = ddtrace.tracer ddtrace.tracer = self.tracer # trace gevent patch()
def make_client(self, mock_socket_values, **kwargs): tracer = get_dummy_tracer() 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 = get_dummy_tracer() Pin.get_from(mongoengine.connect).clone(tracer=tracer).onto( mongoengine.connect) mongoengine.connect(port=MONGO_CONFIG["port"]) return tracer
def setUp(self): super(TestCassandraConfig, self).setUp() patch() self.tracer = get_dummy_tracer() 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 test_patch_unpatch(self): tracer = get_dummy_tracer() writer = tracer.writer # Test patch idempotence patch() patch() r = self._get_test_client() Pin.get_from(r).clone(tracer=tracer).onto(r) r.get('key') spans = writer.pop() assert spans, spans assert len(spans) == 1 # Test unpatch unpatch() r = self._get_test_client() r.get('key') spans = writer.pop() assert not spans, spans # Test patch again patch() r = self._get_test_client() Pin.get_from(r).clone(tracer=tracer).onto(r) r.get('key') spans = writer.pop() assert spans, spans assert len(spans) == 1
def test_pre_v4(): tracer = get_dummy_tracer() MySQL = get_traced_mysql_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_routine(self): """Ensure that the integration routines can be configured.""" routine_config = dict(patch={ 'vertica_python.vertica.connection.Connection': dict(routines=dict(cursor=dict( operation_name='get_cursor', trace_enabled=True, ), ), ), }, ) # Make a copy of the vertica config first before we merge our settings over # DEV: First argument gets merged into the second copy = _deepmerge(config.vertica, dict()) overrides = _deepmerge(routine_config, copy) with self.override_config('vertica', overrides): patch() import vertica_python test_tracer = get_dummy_tracer() conn = vertica_python.connect(**VERTICA_CONFIG) Pin.override(conn, service='mycustomservice', tracer=test_tracer) conn.cursor() # should be traced now conn.close() spans = test_tracer.writer.pop() assert len(spans) == 1 assert spans[0].name == 'get_cursor' assert spans[0].service == 'mycustomservice'
def setUp(self): patch() # prevent cache effects when using Template('code...') jinja2.environment._spontaneous_environments.clear() # provide a dummy tracer self.tracer = get_dummy_tracer() Pin.override(jinja2.environment.Environment, tracer=self.tracer)
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 = get_dummy_tracer() return tracer
def get_tracer_and_client(self): tracer = get_dummy_tracer() client = pymongo.MongoClient(port=MONGO_CONFIG['port']) Pin(service=self.TEST_SERVICE, 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 get_tracer_and_client(self): tracer = get_dummy_tracer() original_client = pymongo.MongoClient(port=MONGO_CONFIG['port']) client = trace_mongo_client(original_client, tracer, service=self.TEST_SERVICE) return tracer, client
def test_patch_unpatch(self): tracer = get_dummy_tracer() writer = tracer.writer # Test patch idempotence patch() patch() client = pymongo.MongoClient(port=MONGO_CONFIG['port']) Pin.get_from(client).clone(tracer=tracer).onto(client) client['testdb'].drop_collection('whatever') spans = writer.pop() assert spans, spans assert len(spans) == 1 # Test unpatch unpatch() client = pymongo.MongoClient(port=MONGO_CONFIG['port']) client['testdb'].drop_collection('whatever') spans = writer.pop() assert not spans, spans # Test patch again patch() client = pymongo.MongoClient(port=MONGO_CONFIG['port']) Pin.get_from(client).clone(tracer=tracer).onto(client) client['testdb'].drop_collection('whatever') spans = writer.pop() assert spans, spans assert len(spans) == 1
def test_patch_unpatch(self): tracer = get_dummy_tracer() writer = tracer.writer # 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 = writer.pop() assert spans, spans assert len(spans) == 1 # Test unpatch unpatch() r = redis.Redis(port=REDIS_CONFIG["port"]) r.get("key") spans = writer.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 = writer.pop() assert spans, spans assert len(spans) == 1
def setUp(self): # provide a dummy tracer self.tracer = get_dummy_tracer() self._original_tracer = ddtrace.tracer ddtrace.tracer = self.tracer # provide a Bottle app self.app = bottle.Bottle()
def _traced_session(self): tracer = get_dummy_tracer() # 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 setUp(self): super(DistributedTracingTestCase, self).setUp() self._service = "falcon" self.tracer = get_dummy_tracer() self.api = get_app(tracer=self.tracer) self.version = falcon.__version__ if self.version[0] != "1": self.client = testing.TestClient(self.api)
def tracer(): tracer = get_dummy_tracer() 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 = get_dummy_tracer() self.traced_app = TraceMiddleware( cherrypy, self.tracer, service="test.cherrypy.service", distributed_tracing=True, )
def get_tracer_and_connect(self): tracer = get_dummy_tracer() # 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 test_redis_legacy(): # ensure the old interface isn't broken, but doesn't trace tracer = get_dummy_tracer() 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.writer.pop()
def get_tracer_and_client(self): tracer = get_dummy_tracer() 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 setUp(self, get_container_info): """ Create a tracer without workers, while spying the ``send()`` method """ # Mock the container id we use for making requests get_container_info.return_value = CGroupInfo( container_id="test-container-id") # create a new API object to test the transport using synchronous calls self.tracer = get_dummy_tracer() self.api_json = API("localhost", 8126, encoder=JSONEncoder()) self.api_msgpack = API("localhost", 8126, encoder=MsgpackEncoder())
def setUp(self): patch() self.tracer = get_dummy_tracer() # Override server pin's tracer with our dummy tracer Pin.override(pymongo.server.Server, tracer=self.tracer) # maxPoolSize controls the number of sockets that the client can instanciate # and choose from to perform classic operations. For the sake of our tests, # let's limit this number to 1 self.client = pymongo.MongoClient(port=MONGO_CONFIG['port'], maxPoolSize=1) # Override TracedMongoClient's pin's tracer with our dummy tracer Pin.override(self.client, tracer=self.tracer)
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 = get_dummy_tracer() 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_less_than_v04(): # interface from < v0.4 from ddtrace.contrib.mongoengine import trace_mongoengine tracer = get_dummy_tracer() connect = trace_mongoengine(tracer, service='my-mongo-db', patch=False) connect(port=config.MONGO_CONFIG['port']) lc = Singer() lc.first_name = 'leonard' lc.last_name = 'cohen' lc.save()
def tracer(): original_tracer = ddtrace.tracer tracer = get_dummy_tracer() 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 setUp(self): self.tracer = get_dummy_tracer() self.app = create_app() self.traced_app = TraceMiddleware( self.app, self.tracer, service="test.flask.service", distributed_tracing=True, ) # make the app testable self.app.config["TESTING"] = True self.client = self.app.test_client()
def test_connect_factory(self): tracer = get_dummy_tracer() services = ['db', 'another'] for service in services: conn, _ = yield from self._get_conn_and_tracer() Pin.get_from(conn).clone(service=service, tracer=tracer).onto(conn) yield from self.assert_conn_is_traced(tracer, conn, service) conn.close() # ensure we have the service types service_meta = tracer.writer.pop_services() expected = {} assert service_meta == expected
def setUp(self): """ Create a tracer without workers, while spying the ``send()`` method """ # create a new API object to test the transport using synchronous calls self.tracer = get_dummy_tracer() self.api_json = API("localhost", 8126, encoder=JSONEncoder(), priority_sampling=True) self.api_msgpack = API("localhost", 8126, encoder=MsgpackEncoder(), priority_sampling=True)
def test_inject(self): tracer = get_dummy_tracer() 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 = {} propagator = HTTPPropagator() propagator.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