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)
