007 add telemetry

tests/observability/test_tracing.py

@@ -0,0 +1,160 @@
+import asyncio
+from decimal import Decimal
+
+import httpx
+from fastapi import FastAPI
+from opentelemetry.instrumentation.httpx import HTTPXClientInstrumentor
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
+from opentelemetry.trace import SpanKind
+
+from app.observability.tracing import (
+    instrument_fastapi_app,
+    instrument_httpx_client,
+    reset_tracing_for_tests,
+    setup_tracing,
+)
+from app.schemas.request import DeliveryEntity, DeliveryRequest
+from app.schemas.response import DeliveryPrice
+from app.services.aggregator import AggregatorService
+
+
+class StubProvider:
+    name = "stub-provider"
+    cache_ttl_seconds = 120
+
+    async def get_price(self, request: DeliveryRequest) -> DeliveryPrice:
+        _ = request
+        return DeliveryPrice(
+            provider=self.name,
+            service_name="economy",
+            price=Decimal("100.10"),
+            currency="RUB",
+            delivery_days_min=2,
+            delivery_days_max=4,
+        )
+
+
+class StubCache:
+    async def get(self, key: str) -> object | None:
+        _ = key
+        return None
+
+    async def set(self, key: str, value: object, ttl: int | None = None) -> None:
+        _ = key, value, ttl
+
+
+def _build_request() -> DeliveryRequest:
+    return DeliveryRequest(
+        entity=DeliveryEntity.INDIVIDUAL,
+        from_city="Moscow",
+        to_city="Kazan",
+        weight_kg=1.5,
+        length_cm=10.0,
+        width_cm=20.0,
+        height_cm=30.0,
+    )
+
+
+def test_manual_spans_capture_required_attributes() -> None:
+    reset_tracing_for_tests()
+    span_exporter = InMemorySpanExporter()
+    tracer_provider = TracerProvider(resource=Resource.create({"service.name": "tests"}))
+    tracer_provider.add_span_processor(SimpleSpanProcessor(span_exporter))
+    setup_tracing(
+        service_name="tests",
+        otlp_endpoint="",
+        tracer_provider=tracer_provider,
+    )
+
+    service = AggregatorService(providers=[StubProvider()], cache=StubCache())
+    asyncio.run(service.get_all_prices(_build_request()))
+
+    spans = span_exporter.get_finished_spans()
+    span_by_name = {span.name: span for span in spans}
+
+    assert "AggregatorService.get_all_prices" in span_by_name
+    assert "DeliveryProvider.get_price" in span_by_name
+    assert "PriceCache.get" in span_by_name
+    assert "PriceCache.set" in span_by_name
+
+    service_span = span_by_name["AggregatorService.get_all_prices"]
+    assert service_span.attributes["from_city"] == "Moscow"
+    assert service_span.attributes["to_city"] == "Kazan"
+    assert service_span.attributes["weight_kg"] == 1.5
+    assert service_span.attributes["tariffs_found"] == 1
+
+    provider_span = span_by_name["DeliveryProvider.get_price"]
+    assert provider_span.attributes["provider"] == "stub-provider"
+    assert provider_span.attributes["cache_hit"] is False
+    assert provider_span.attributes["from_city"] == "Moscow"
+    assert provider_span.attributes["to_city"] == "Kazan"
+    assert provider_span.attributes["weight_kg"] == 1.5
+
+    cache_span = span_by_name["PriceCache.get"]
+    assert cache_span.attributes["cache_hit"] is False
+
+    reset_tracing_for_tests()
+
+
+def test_fastapi_and_httpx_instrumentation_emit_server_and_client_spans() -> None:
+    reset_tracing_for_tests()
+    span_exporter = InMemorySpanExporter()
+    tracer_provider = TracerProvider(resource=Resource.create({"service.name": "tests"}))
+    tracer_provider.add_span_processor(SimpleSpanProcessor(span_exporter))
+    setup_tracing(
+        service_name="tests",
+        otlp_endpoint="",
+        tracer_provider=tracer_provider,
+    )
+
+    app = FastAPI()
+
+    @app.get("/proxy")
+    async def proxy() -> dict[str, int]:
+        def handler(request: httpx.Request) -> httpx.Response:
+            _ = request
+            return httpx.Response(status_code=200, json={"ok": True})
+
+        transport = httpx.MockTransport(handler)
+        async with httpx.AsyncClient(
+            transport=transport,
+            base_url="https://provider.test",
+        ) as client:
+            HTTPXClientInstrumentor.instrument_client(client, tracer_provider=tracer_provider)
+            response = await client.get("/quote")
+        return {"status_code": response.status_code}
+
+    instrument_fastapi_app(app)
+    instrument_httpx_client()
+
+    async def run_request() -> httpx.Response:
+        transport = httpx.ASGITransport(app=app)
+        async with httpx.AsyncClient(
+            transport=transport,
+            base_url="http://testserver",
+        ) as client:
+            return await client.get("/proxy")
+
+    response = asyncio.run(run_request())
+    assert response.status_code == 200
+
+    spans = span_exporter.get_finished_spans()
+    assert any(span.kind == SpanKind.SERVER for span in spans)
+    assert any(span.kind == SpanKind.CLIENT for span in spans)
+    assert any(
+        (
+            "provider.test/quote"
+            in (
+                span.attributes.get("http.url")
+                or span.attributes.get("url.full")
+                or ""
+            )
+        )
+        for span in spans
+        if span.kind == SpanKind.CLIENT
+    )
+
+    reset_tracing_for_tests()