def test_response_hook(self): redis_client = redis.Redis() connection = redis.connection.Connection() redis_client.connection = connection response_attribute_name = "db.redis.response" def response_hook(span, conn, response): span.set_attribute(response_attribute_name, response) RedisInstrumentor().uninstrument() RedisInstrumentor().instrument(tracer_provider=self.tracer_provider, response_hook=response_hook) test_value = "test_value" with mock.patch.object(connection, "send_command"): with mock.patch.object(redis_client, "parse_response", return_value=test_value): redis_client.get("key") spans = self.memory_exporter.get_finished_spans() self.assertEqual(len(spans), 1) span = spans[0] self.assertEqual(span.attributes.get(response_attribute_name), test_value)
def test_instrument_uninstrument(self): redis_client = redis.Redis() RedisInstrumentor().instrument(tracer_provider=self.tracer_provider) with mock.patch.object(redis_client, "connection"): redis_client.get("key") spans = self.memory_exporter.get_finished_spans() self.assertEqual(len(spans), 1) self.memory_exporter.clear() # Test uninstrument RedisInstrumentor().uninstrument() with mock.patch.object(redis_client, "connection"): redis_client.get("key") spans = self.memory_exporter.get_finished_spans() self.assertEqual(len(spans), 0) self.memory_exporter.clear() # Test instrument again RedisInstrumentor().instrument() with mock.patch.object(redis_client, "connection"): redis_client.get("key") spans = self.memory_exporter.get_finished_spans() self.assertEqual(len(spans), 1)
def instrument_app(self) -> None: logger.info("Activating Opentelemetry tracing to app", app=self.title) trace.set_tracer_provider(tracer_provider) FastAPIInstrumentor.instrument_app(self) RequestsInstrumentor().instrument() HTTPXClientInstrumentor().instrument() RedisInstrumentor().instrument() Psycopg2Instrumentor().instrument() SQLAlchemyInstrumentor().instrument(engine=db.engine, tracer_provider=tracer_provider)
def test_span_properties(self): redis_client = redis.Redis() RedisInstrumentor().instrument(tracer_provider=self.tracer_provider) with mock.patch.object(redis_client, "connection"): redis_client.get("key") spans = self.memory_exporter.get_finished_spans() self.assertEqual(len(spans), 1) span = spans[0] self.assertEqual(span.name, "GET") self.assertEqual(span.kind, SpanKind.CLIENT)
def test_not_recording(self): redis_client = redis.Redis() RedisInstrumentor().instrument(tracer_provider=self.tracer_provider) mock_tracer = mock.Mock() mock_span = mock.Mock() mock_span.is_recording.return_value = False mock_tracer.start_span.return_value = mock_span with mock.patch("opentelemetry.trace.get_tracer") as tracer: with mock.patch.object(redis_client, "connection"): tracer.return_value = mock_tracer redis_client.get("key") self.assertFalse(mock_span.is_recording()) self.assertTrue(mock_span.is_recording.called) self.assertFalse(mock_span.set_attribute.called) self.assertFalse(mock_span.set_status.called)
def __init__(self, app, service='atlas-api', sqlalchemy_engine=None, datadog_agent=None, span_callback=None, ignored_paths: List[str] = None, sql_service=None): self.app = app trace.set_tracer_provider(TracerProvider()) self.tracer = trace.get_tracer(__name__) if datadog_agent: from ddtrace.internal.writer import AgentWriter from opentelemetry.exporter.datadog import DatadogExportSpanProcessor, \ DatadogSpanExporter exporter = DatadogSpanExporter(agent_url=datadog_agent, service=service) exporter._agent_writer = AgentWriter(datadog_agent) span_processor = DatadogExportSpanProcessor(exporter) trace.get_tracer_provider().add_span_processor(span_processor) AtlasFastAPIInstrumentor.instrument_app(app, span_callback=span_callback, ignored_paths=ignored_paths) RequestsInstrumentor().instrument() BotocoreInstrumentor().instrument(tracer_provider=trace.get_tracer_provider()) BotoInstrumentor().instrument(tracer_provider=trace.get_tracer_provider()) RedisInstrumentor().instrument(tracer_provider=trace.get_tracer_provider()) if sqlalchemy_engine: sqlalch_service_name = service if not sql_service else sql_service SQLAlchemyInstrumentor().instrument(engine=sqlalchemy_engine, service=sqlalch_service_name)
def tearDown(self): super().tearDown() RedisInstrumentor().uninstrument()
def setUp(self): super().setUp() self.redis_client = redis.Redis(port=6379) self.redis_client.flushall() RedisInstrumentor().instrument(tracer_provider=self.tracer_provider)
trace.set_tracer_provider(TracerProvider()) tracer = trace.get_tracer(__name__) # create a JaegerSpanExporter jaeger_exporter = jaeger.JaegerSpanExporter( service_name="auth_service", agent_host_name="jaeger", agent_port=6831, ) span_processor = BatchExportSpanProcessor(jaeger_exporter) trace.get_tracer_provider().add_span_processor(span_processor) app = Flask("auth_app") FlaskInstrumentor().instrument_app(app) RedisInstrumentor().instrument(tracer_provider=trace.get_tracer_provider()) RequestsInstrumentor().instrument() redis_connection = redis.Redis.from_url(url="redis://*****:*****@app.route("/login/", methods=["POST"]) def login(): data, errors = LoginValidator.validate_or_error(request.json) if errors: return jsonify(dict(errors)), 400 login_code = str(randrange(1000, 9999)) redis_connection.set(f"validation_code_{data['username']}", login_code) # dummy implementation of otp or email verification return jsonify( { "code": login_code,
trace.set_tracer_provider(TracerProvider()) tracer = trace.get_tracer(__name__) # create a JaegerSpanExporter jaeger_exporter = jaeger.JaegerSpanExporter( service_name='kokowawa', # configure agent agent_host_name='localhost', agent_port=6831, # optional: configure also collector # collector_host_name='localhost', # collector_port=14268, # collector_endpoint='/api/traces?format=jaeger.thrift', # collector_protocol='http', # username=xxxx, # optional # password=xxxx, # optional ) # Create a BatchExportSpanProcessor and add the exporter to it span_processor = BatchExportSpanProcessor(jaeger_exporter) # add to the tracer trace.get_tracer_provider().add_span_processor(span_processor) # This call is what makes the Django application be instrumented DjangoInstrumentor().instrument() # You can optionally pass a custom TracerProvider to RequestsInstrumentor().instrument() SQLite3Instrumentor().instrument() RedisInstrumentor().instrument()
def setUp(self): super().setUp() self.redis_client = redis.asyncio.cluster.RedisCluster( host="localhost", port=7000) async_call(self.redis_client.flushall()) RedisInstrumentor().instrument(tracer_provider=self.tracer_provider)
def setUp(self): super().setUp() RedisInstrumentor().instrument(tracer_provider=self.tracer_provider)