Fix configuration caching and telemetry exporters (#150)

Author: shayancoin

backend/api/main.py

@@ -23,10 +23,17 @@
 from api.routes_sync import router as sync_router
 from api.routes_observability import router as observability_router
 from prometheus_client import CONTENT_TYPE_LATEST, generate_latest
+from prometheus_fastapi_instrumentator import Instrumentator
 from api.metrics import observe_http_request
 
 setup_instrumentation()
 
+if bootstrap_instrumentation is not None:  # pragma: no branch - simple guard
+    try:
+        bootstrap_instrumentation()
+    except Exception:  # pragma: no cover - defensive guard
+        logger.exception("Failed to bootstrap OpenTelemetry instrumentation")
+
 # Initialize settings
 settings = get_settings()
 
@@ -201,4 +208,4 @@ async def metrics() -> Dict[str, str]:
 
     return {
         "detail": "Metrics are exported via OpenTelemetry OTLP; no local payload is available.",
-    }
+    }

backend/api/metrics.py

@@ -1,6 +1,36 @@
 from __future__ import annotations
+
+from typing import Any
+
 from prometheus_client import Counter, Histogram
 
+_otel_meter: Any | None = None
+_http_request_counter: Any | None = None
+_http_request_duration_histogram: Any | None = None
+_web_vitals_lcp_histogram: Any | None = None
+
+try:  # pragma: no cover - optional dependency guard
+    from opentelemetry import metrics as otel_metrics
+except ImportError:  # pragma: no cover - optional dependency guard
+    otel_metrics = None  # type: ignore[assignment]
+else:
+    _otel_meter = otel_metrics.get_meter(__name__)
+    _http_request_counter = _otel_meter.create_counter(
+        "http.server.request.count",
+        description="HTTP requests processed by the backend",
+        unit="1",
+    )
+    _http_request_duration_histogram = _otel_meter.create_histogram(
+        "http.server.duration",
+        description="Duration of HTTP requests handled by the backend",
+        unit="s",
+    )
+    _web_vitals_lcp_histogram = _otel_meter.create_histogram(
+        "frontend.web_vitals.lcp",
+        description="Largest Contentful Paint reported from the frontend",
+        unit="s",
+    )
+
 REQUEST_LATENCY_BUCKETS = (
     0.005,
     0.01,
@@ -86,21 +116,41 @@ def observe_http_request(
     service: str,
     route: str,
     method: str,
-    status: str,
+    status_code: int | str,
     duration_seconds: float,
 ) -> None:
     """Record a single HTTP request observation."""
 
+    status_label = str(status_code)
     http_requests_total.labels(
-        service=service, route=route, method=method, status=status
+        service=service, route=route, method=method, status=status_label
     ).inc()
     http_request_duration_seconds.labels(
-        service=service, route=route, method=method, status=status
+        service=service, route=route, method=method, status=status_label
     ).observe(duration_seconds)
 
+    if _http_request_counter is not None or _http_request_duration_histogram is not None:
+        attributes: dict[str, str | int] = {
+            "service.name": service,
+            "http.route": route,
+            "http.method": method,
+        }
+        try:
+            attributes["http.status_code"] = int(status_code)
+        except (TypeError, ValueError):
+            # Skip the status code attribute if it cannot be coerced to an int.
+            pass
+
+        if _http_request_counter is not None:
+            _http_request_counter.add(1, attributes)
+        if _http_request_duration_histogram is not None:
+            _http_request_duration_histogram.record(duration_seconds, attributes)
+
 
 def observe_lcp(*, app: str, seconds: float) -> None:
     """Record a Largest Contentful Paint measurement in seconds."""
 
     web_vitals_lcp.labels(app=app).observe(seconds)
+    if _web_vitals_lcp_histogram is not None:
+        _web_vitals_lcp_histogram.record(seconds, {"app": app})