fastapi-observer 1.6.0__tar.gz → 1.7.0__tar.gz

{fastapi_observer-1.6.0/src/fastapi_observer.egg-info → fastapi_observer-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-observer
-Version: 1.6.0
+Version: 1.7.0
 Summary: Zero-glue FastAPI observability with security presets and runtime controls
 Author-email: Vitaee <opensource@vitaee.dev>
 License-Expression: MIT

{fastapi_observer-1.6.0 → fastapi_observer-1.7.0/src/fastapi_observer.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-observer
-Version: 1.6.0
+Version: 1.7.0
 Summary: Zero-glue FastAPI observability with security presets and runtime controls
 Author-email: Vitaee <opensource@vitaee.dev>
 License-Expression: MIT

{fastapi_observer-1.6.0 → fastapi_observer-1.7.0}/src/fastapi_observer.egg-info/SOURCES.txt

@@ -33,18 +33,7 @@ src/fastapiobserver/logging/queueing.py
 src/fastapiobserver/logging/setup.py
 src/fastapiobserver/logging/state.py
 src/fastapiobserver/metrics/__init__.py
-src/fastapiobserver/metrics/builder.py
-src/fastapiobserver/metrics/contracts.py
-src/fastapiobserver/metrics/endpoint.py
-src/fastapiobserver/metrics/noop.py
-src/fastapiobserver/metrics/pathing.py
-src/fastapiobserver/metrics/registry.py
-src/fastapiobserver/metrics/prometheus/__init__.py
-src/fastapiobserver/metrics/prometheus/backend.py
-src/fastapiobserver/metrics/prometheus/client.py
-src/fastapiobserver/metrics/prometheus/collector.py
-src/fastapiobserver/metrics/prometheus/exemplars.py
-src/fastapiobserver/metrics/prometheus/multiprocess.py
+src/fastapiobserver/metrics/prometheus.py
 src/fastapiobserver/middleware/__init__.py
 src/fastapiobserver/middleware/body_capture.py
 src/fastapiobserver/middleware/context.py
@@ -53,7 +42,6 @@ src/fastapiobserver/middleware/headers.py
 src/fastapiobserver/middleware/ip.py
 src/fastapiobserver/middleware/metrics.py
 src/fastapiobserver/middleware/request_logging.py
-src/fastapiobserver/middleware/span_errors.py
 src/fastapiobserver/otel/__init__.py
 src/fastapiobserver/otel/exclusions.py
 src/fastapiobserver/otel/lifecycle.py
@@ -62,7 +50,6 @@ src/fastapiobserver/otel/metrics.py
 src/fastapiobserver/otel/resource.py
 src/fastapiobserver/otel/settings.py
 src/fastapiobserver/otel/tracing.py
-src/fastapiobserver/otel/types.py
 src/fastapiobserver/security/__init__.py
 src/fastapiobserver/security/normalize.py
 src/fastapiobserver/security/policy.py

fastapi_observer-1.7.0/src/fastapiobserver/_version.py

@@ -0,0 +1 @@
+__version__ = "1.7.0"

{fastapi_observer-1.6.0 → fastapi_observer-1.7.0}/src/fastapiobserver/db_tracing.py

@@ -12,7 +12,7 @@ Usage::
 
     engine = create_engine("postgresql://...")
     instrument_sqlalchemy(engine)
-    # SELECT * FROM users /*traceparent='00-abc123...',route='/api/users'*/
+    # SELECT * FROM users /*db_driver='psycopg2',traceparent='00-abc123...'*/
 
 Or for async engines::
 
@@ -35,9 +35,12 @@ _DEFAULT_COMMENTER_OPTIONS: dict[str, bool] = {
     "opentelemetry_values": True,  # injects traceparent
     "db_driver": True,
     "db_framework": False,  # noisy — omit by default
-    "route": True,
 }
 
+# OpenTelemetry's instrumentor is a singleton that ignores a second
+# ``instrument()`` call, so every call re-instruments all engines seen so far.
+_ENGINES: list[Any] = []
+
 _PACKAGE_HINT = "fastapi-observer[otel-sqlalchemy]"
 
 
@@ -58,38 +61,46 @@ def instrument_sqlalchemy(
         context to every query.
     commenter_options:
         Key-value pairs controlling which fields appear in the SQL
-        comment.  Defaults to ``traceparent``, ``db_driver``, and
-        ``route``.
+        comment (``opentelemetry_values``, ``db_driver``, ``db_framework``).
+        Defaults to the trace context and ``db_driver``.
+
+    Call it once per engine. The commenter settings of the latest call apply
+    to every instrumented engine.
     """
     try:
         instrumentor_module = lazy_import(
             "opentelemetry.instrumentation.sqlalchemy",
             package_hint=_PACKAGE_HINT,
         )
-        instrumentor = instrumentor_module.SQLAlchemyInstrumentor()
-
-        options = commenter_options or _DEFAULT_COMMENTER_OPTIONS
-
-        instrumentor.instrument(
-            engine=engine,
-            enable_commenter=enable_commenter,
-            commenter_options=options,
-        )
-        _LOGGER.info(
-            "db_tracing.instrumented",
-            extra={
-                "event": {
-                    "engine_url": str(engine.url),
-                    "commenter_enabled": enable_commenter,
-                },
-                "_skip_enrichers": True,
-            },
-        )
     except RuntimeError as exc:
         raise RuntimeError(
             "SQLAlchemy instrumentation requires "
             f"`pip install {_PACKAGE_HINT}`"
         ) from exc
+    instrumentor = instrumentor_module.SQLAlchemyInstrumentor()
+
+    if not any(known is engine for known in _ENGINES):
+        _ENGINES.append(engine)
+    if instrumentor.is_instrumented_by_opentelemetry:
+        instrumentor.uninstrument()
+    instrumentor.instrument(
+        engines=list(_ENGINES),
+        enable_commenter=enable_commenter,
+        commenter_options=commenter_options or _DEFAULT_COMMENTER_OPTIONS,
+    )
+
+    event = {"engine_url": str(engine.url), "commenter_enabled": enable_commenter}
+    if not instrumentor.is_instrumented_by_opentelemetry:
+        # OpenTelemetry refuses unsupported SQLAlchemy versions and only logs it.
+        _LOGGER.warning(
+            "db_tracing.not_instrumented",
+            extra={"event": event, "_skip_enrichers": True},
+        )
+        return
+    _LOGGER.info(
+        "db_tracing.instrumented",
+        extra={"event": event, "_skip_enrichers": True},
+    )
 
 
 def instrument_sqlalchemy_async(
@@ -134,6 +145,7 @@ def uninstrument_sqlalchemy() -> None:
         instrumentor_module.SQLAlchemyInstrumentor().uninstrument()
     except (ModuleNotFoundError, RuntimeError):
         pass
+    _ENGINES.clear()
 
 
 __all__ = [

{fastapi_observer-1.6.0 → fastapi_observer-1.7.0}/src/fastapiobserver/fastapi.py

@@ -146,6 +146,9 @@ def _setup_structured_logging(
     security_policy: SecurityPolicy,
     audit_key_provider: object | None,
 ) -> None:
+    # Hook the lifespan before install_otel_logs does, so on shutdown the log
+    # queue drains into the OTLP handler before its provider is shut down.
+    _register_logging_shutdown_hook(app)
     otel_log_handler = None
     logs_mode: Literal["local_json", "otlp", "both"] = "local_json"
     if otel_logs_settings and otel_logs_settings.enabled:
@@ -172,7 +175,6 @@ def _setup_structured_logging(
         extra_handlers=extra_handlers,
         audit_key_provider=audit_key_provider,
     )
-    _register_logging_shutdown_hook(app)
 
 
 def _setup_metrics_backend(

{fastapi_observer-1.6.0 → fastapi_observer-1.7.0}/src/fastapiobserver/logging/circuit_breaker.py

@@ -69,10 +69,22 @@ class SinkCircuitBreakerHandler(logging.Handler):
         self._half_open_total = 0
         self._closes_total = 0
 
+        # Stdlib handlers catch their own write errors and only report them
+        # through handleError(), so count those reports as failures too.
+        self._delegate_failed = False
+        report_error = delegate.handleError
+
+        def _count_and_report(record: logging.LogRecord) -> None:
+            self._delegate_failed = True
+            report_error(record)
+
+        delegate.handleError = _count_and_report  # type: ignore[method-assign]
+
     def emit(self, record: logging.LogRecord) -> None:
         if self._should_skip():
             return
 
+        self._delegate_failed = False
         try:
             self._delegate.handle(record)
         except Exception:
@@ -80,7 +92,10 @@ class SinkCircuitBreakerHandler(logging.Handler):
             self.handleError(record)
             return
 
-        self._record_success()
+        if self._delegate_failed:
+            self._record_failure()
+        else:
+            self._record_success()
 
     def setFormatter(self, fmt: logging.Formatter | None) -> None:  # noqa: N802
         super().setFormatter(fmt)

fastapi_observer-1.7.0/src/fastapiobserver/metrics/__init__.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+import re
+from typing import Callable, Protocol
+
+from fastapi import FastAPI
+
+from ..config import MetricsFormat
+from .prometheus import (
+    PrometheusMetricsBackend,
+    _build_prometheus_metrics_backend,
+    mark_prometheus_process_dead,
+    mount_metrics_endpoint,
+)
+
+
+class MetricsBackend(Protocol):
+    """Interface for metrics recording backends."""
+
+    def observe(
+        self,
+        method: str,
+        path: str,
+        status_code: int,
+        duration_seconds: float,
+    ) -> None: ...
+
+
+class MountableMetricsBackend(Protocol):
+    """Optional extension for backends that can mount their endpoint."""
+
+    def mount_endpoint(
+        self,
+        app: FastAPI,
+        *,
+        path: str = "/metrics",
+        metrics_format: MetricsFormat = "negotiate",
+    ) -> None: ...
+
+
+MetricsBackendFactory = Callable[..., MetricsBackend]
+
+
+class NoopMetricsBackend:
+    """No-op backend that silently discards all observations."""
+
+    def observe(
+        self,
+        method: str,
+        path: str,
+        status_code: int,
+        duration_seconds: float,
+    ) -> None:
+        return None
+
+
+_UUID_RE = re.compile(
+    r"/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}"
+)
+_NUMBER_RE = re.compile(r"/\d+")
+_HEX_RE = re.compile(r"/[0-9a-fA-F]{16,}")
+
+
+def collapse_dynamic_segments(path: str) -> str:
+    """Replace dynamic path segments with ``/:id`` to control label cardinality."""
+    normalized = _UUID_RE.sub("/:id", path)
+    normalized = _HEX_RE.sub("/:id", normalized)
+    return _NUMBER_RE.sub("/:id", normalized)
+
+
+_BACKEND_FACTORIES: dict[str, MetricsBackendFactory] = {}
+
+
+def register_metrics_backend(name: str, factory: MetricsBackendFactory) -> None:
+    normalized_name = name.strip().lower()
+    if not normalized_name:
+        raise ValueError("Metrics backend name cannot be empty")
+    _BACKEND_FACTORIES[normalized_name] = factory
+
+
+def unregister_metrics_backend(name: str) -> None:
+    _BACKEND_FACTORIES.pop(name.strip().lower(), None)
+
+
+def get_registered_metrics_backends() -> dict[str, MetricsBackendFactory]:
+    return dict(_BACKEND_FACTORIES)
+
+
+def build_metrics_backend(
+    enabled: bool,
+    *,
+    service: str = "api",
+    environment: str = "development",
+    exemplars_enabled: bool = False,
+    backend: str = "prometheus",
+) -> MetricsBackend:
+    """Factory for selecting the appropriate metrics backend."""
+    if not enabled:
+        return NoopMetricsBackend()
+    factory = _BACKEND_FACTORIES.get(backend.strip().lower())
+    if factory is None:
+        available_csv = ", ".join(sorted(_BACKEND_FACTORIES)) or "(none)"
+        raise ValueError(
+            f"Unknown metrics backend: {backend!r}. Available backends: {available_csv}"
+        )
+    return factory(
+        service=service,
+        environment=environment,
+        exemplars_enabled=exemplars_enabled,
+    )
+
+
+def mount_backend_metrics_endpoint(
+    app: FastAPI,
+    backend: MetricsBackend,
+    *,
+    path: str = "/metrics",
+    metrics_format: MetricsFormat = "negotiate",
+) -> bool:
+    mount_endpoint = getattr(backend, "mount_endpoint", None)
+    if not callable(mount_endpoint):
+        return False
+    mount_endpoint(app, path=path, metrics_format=metrics_format)
+    return True
+
+
+register_metrics_backend("prometheus", _build_prometheus_metrics_backend)
+
+__all__ = [
+    "MetricsBackend",
+    "MountableMetricsBackend",
+    "MetricsBackendFactory",
+    "MetricsFormat",
+    "NoopMetricsBackend",
+    "collapse_dynamic_segments",
+    "register_metrics_backend",
+    "unregister_metrics_backend",
+    "get_registered_metrics_backends",
+    "build_metrics_backend",
+    "mount_backend_metrics_endpoint",
+    "PrometheusMetricsBackend",
+    "mark_prometheus_process_dead",
+    "mount_metrics_endpoint",
+]

fastapi_observer-1.7.0/src/fastapiobserver/metrics/prometheus.py

@@ -0,0 +1,325 @@
+"""Prometheus backend, ``/metrics`` endpoint and multiprocess helpers.
+
+``prometheus_client`` is an optional dependency, so it is imported lazily.
+"""
+
+from __future__ import annotations
+
+import gzip
+import logging
+import os
+import threading
+from typing import Any, Callable, Iterator
+
+from fastapi import FastAPI
+from starlette.requests import Request
+from starlette.responses import Response
+from starlette.routing import Route
+
+from ..config import MetricsFormat
+from ..utils import normalize_path
+
+_LOGGER = logging.getLogger("fastapiobserver.metrics")
+_HTTP_LABELS = ("service", "environment", "method", "path", "status_code")
+# Accept header pinned for the non-negotiating formats; prometheus_client picks the encoder.
+_FORCED_ACCEPT = {
+    "openmetrics": "application/openmetrics-text",
+    "prometheus": "text/plain",
+}
+_SINK_COUNTERS = {
+    "failures_total": "Total sink handler failures observed by circuit breakers.",
+    "skipped_total": "Total records skipped while sink circuit breaker was open.",
+    "opens_total": "Total transitions into open state for sink circuit breakers.",
+    "half_open_total": "Total transitions into half-open state for sink circuit breakers.",
+    "closes_total": "Total transitions back to closed state for sink circuit breakers.",
+}
+
+
+def _import_prometheus_client() -> Any:
+    try:
+        import prometheus_client
+    except ModuleNotFoundError as exc:
+        raise RuntimeError(
+            "Prometheus support requires `pip install fastapi-observer[prometheus]`"
+        ) from exc
+    return prometheus_client
+
+
+def _multiprocess_dir() -> str:
+    return os.getenv("PROMETHEUS_MULTIPROC_DIR", "").strip()
+
+
+def _validate_multiprocess_dir() -> None:
+    path = _multiprocess_dir()
+    if path and not (os.path.isdir(path) and os.access(path, os.W_OK)):
+        raise RuntimeError(
+            f"PROMETHEUS_MULTIPROC_DIR={path!r} must be an existing, writable directory. "
+            "Create it before starting workers."
+        )
+
+
+def mark_prometheus_process_dead(pid: int) -> None:
+    """Clean up a dead worker's files in multiprocess mode (gunicorn ``child_exit``)."""
+    if not _multiprocess_dir():
+        return
+    _import_prometheus_client()
+    from prometheus_client import multiprocess
+
+    multiprocess.mark_process_dead(pid)
+
+
+def _get_trace_exemplar() -> dict[str, str] | None:
+    """Current OTel trace ID as a Prometheus exemplar, or ``None`` without a valid span."""
+    try:
+        from opentelemetry import trace as otel_trace
+
+        ctx = otel_trace.get_current_span().get_span_context()
+        if ctx and ctx.is_valid:
+            return {"TraceID": f"{ctx.trace_id:032x}"}
+    except Exception:
+        pass
+    return None
+
+
+class _LogQueueMetricsCollector:
+    """Exposes log-queue, Logtail DLQ and sink circuit-breaker stats at scrape time."""
+
+    def collect(self) -> Iterator[Any]:
+        from prometheus_client.core import CounterMetricFamily, GaugeMetricFamily
+
+        from ..logging import get_log_queue_stats, get_sink_circuit_breaker_stats
+        from ..sinks import get_logtail_dlq_stats
+
+        queue = get_log_queue_stats()
+        yield GaugeMetricFamily(
+            "fastapiobserver_log_queue_size",
+            "Current number of log records waiting in the core queue.",
+            value=float(queue["queue_size"]),
+        )
+        yield GaugeMetricFamily(
+            "fastapiobserver_log_queue_capacity",
+            "Configured capacity of the core logging queue.",
+            value=float(queue["queue_capacity"]),
+        )
+        policy = GaugeMetricFamily(
+            "fastapiobserver_log_queue_overflow_policy_info",
+            "Current overflow policy for the core logging queue.",
+            labels=["policy"],
+        )
+        policy.add_metric([str(queue["overflow_policy"])], 1.0)
+        yield policy
+        yield CounterMetricFamily(
+            "fastapiobserver_log_queue_enqueued_total",
+            "Total log records accepted into the core queue.",
+            value=float(queue["enqueued_total"]),
+        )
+        dropped = CounterMetricFamily(
+            "fastapiobserver_log_queue_dropped_total",
+            "Total log records dropped due to queue pressure.",
+            labels=["reason"],
+        )
+        dropped.add_metric(["drop_oldest"], float(queue["dropped_oldest_total"]))
+        dropped.add_metric(["drop_newest"], float(queue["dropped_newest_total"]))
+        yield dropped
+        yield CounterMetricFamily(
+            "fastapiobserver_log_queue_blocked_total",
+            "Total times producers entered blocking mode while queue was full.",
+            value=float(queue["blocked_total"]),
+        )
+        yield CounterMetricFamily(
+            "fastapiobserver_log_queue_block_timeouts_total",
+            "Total blocking enqueue attempts that timed out and dropped the newest record.",
+            value=float(queue["block_timeout_total"]),
+        )
+
+        dlq = get_logtail_dlq_stats()
+        written = CounterMetricFamily(
+            "fastapiobserver_dlq_written_total",
+            "Total payloads written to local DLQ.",
+            labels=["reason"],
+        )
+        written.add_metric(["queue_overflow"], float(dlq["written_queue_overflow"]))
+        written.add_metric(["send_failed"], float(dlq["written_send_failed"]))
+        yield written
+        yield CounterMetricFamily(
+            "fastapiobserver_dlq_write_failures_total",
+            "Total failures when attempting to write payloads to the DLQ disk.",
+            value=float(dlq["failures"]),
+        )
+        yield CounterMetricFamily(
+            "fastapiobserver_dlq_bytes_total",
+            "Total bytes written to the DLQ disk.",
+            value=float(dlq["bytes"]),
+        )
+
+        sinks = sorted(get_sink_circuit_breaker_stats().items())
+        if not sinks:
+            return
+        state = GaugeMetricFamily(
+            "fastapiobserver_sink_circuit_breaker_state_info",
+            "Current sink circuit-breaker state.",
+            labels=["sink", "state"],
+        )
+        for sink_name, sink in sinks:
+            state.add_metric([sink_name, str(sink["state"])], 1.0)
+        yield state
+        for key, documentation in _SINK_COUNTERS.items():
+            counter = CounterMetricFamily(
+                f"fastapiobserver_sink_circuit_breaker_{key}", documentation, labels=["sink"]
+            )
+            for sink_name, sink in sinks:
+                counter.add_metric([sink_name], float(sink[key]))
+            yield counter
+
+
+def _register_log_queue_metrics_collector() -> None:
+    # Per-worker queue stats would be meaningless once aggregated across processes.
+    if _multiprocess_dir():
+        return
+    try:
+        _import_prometheus_client().REGISTRY.register(_LogQueueMetricsCollector())
+    except ValueError:
+        pass  # Already registered by an earlier backend build in this process.
+
+
+class PrometheusMetricsBackend:
+    """Prometheus request counter and latency histogram.
+
+    With *exemplars_enabled*, observations carry the current OTel trace ID as an
+    exemplar (visible in OpenMetrics output), enabling the metrics -> traces jump
+    in Grafana. Exemplars are not supported by the multiprocess collector
+    (``PROMETHEUS_MULTIPROC_DIR``), so they are disabled there with a warning.
+    """
+
+    _LOCK = threading.Lock()
+    _REQUEST_COUNT: Any = None
+    _REQUEST_LATENCY: Any = None
+
+    def __init__(
+        self,
+        *,
+        service: str,
+        environment: str,
+        exemplars_enabled: bool = False,
+    ) -> None:
+        self.service = service
+        self.environment = environment
+        self._exemplars_enabled = exemplars_enabled
+
+        if self._exemplars_enabled and _multiprocess_dir():
+            _LOGGER.warning(
+                "metrics.exemplars.disabled_in_multiprocess",
+                extra={
+                    "event": {
+                        "message": (
+                            "Prometheus exemplars are not compatible with "
+                            "multiprocess mode. Exemplars have been disabled."
+                        ),
+                    },
+                    "_skip_enrichers": True,
+                },
+            )
+            self._exemplars_enabled = False
+
+        prometheus_client = _import_prometheus_client()
+        cls = PrometheusMetricsBackend
+        with cls._LOCK:
+            if cls._REQUEST_COUNT is None:
+                cls._REQUEST_COUNT = prometheus_client.Counter(
+                    "http_requests_total",
+                    "Total count of HTTP requests",
+                    _HTTP_LABELS,
+                )
+                cls._REQUEST_LATENCY = prometheus_client.Histogram(
+                    "http_request_duration_seconds",
+                    "HTTP request latency",
+                    _HTTP_LABELS,
+                    buckets=(0.005, 0.01, 0.025, 0.05, 0.1, 0.3, 0.5, 1, 3, 5, 10),
+                )
+
+    def observe(
+        self,
+        method: str,
+        path: str,
+        status_code: int,
+        duration_seconds: float,
+    ) -> None:
+        exemplar = _get_trace_exemplar() if self._exemplars_enabled else None
+        labels = (self.service, self.environment, method, path, str(status_code))
+        self._REQUEST_COUNT.labels(*labels).inc(exemplar=exemplar)
+        self._REQUEST_LATENCY.labels(*labels).observe(duration_seconds, exemplar=exemplar)
+
+    def mount_endpoint(
+        self,
+        app: FastAPI,
+        *,
+        path: str = "/metrics",
+        metrics_format: MetricsFormat = "negotiate",
+    ) -> None:
+        mount_metrics_endpoint(app, path=path, metrics_format=metrics_format)
+
+
+def _build_prometheus_metrics_backend(
+    *,
+    service: str,
+    environment: str,
+    exemplars_enabled: bool,
+) -> PrometheusMetricsBackend:
+    _validate_multiprocess_dir()
+    backend = PrometheusMetricsBackend(
+        service=service,
+        environment=environment,
+        exemplars_enabled=exemplars_enabled,
+    )
+    _register_log_queue_metrics_collector()
+    return backend
+
+
+def _metrics_endpoint(registry: Any, accept: str | None) -> Callable[[Request], Response]:
+    """Serve *registry* the way ``prometheus_client``'s own apps do.
+
+    A plain function, so Starlette runs it in its thread pool: rendering takes
+    tens to hundreds of milliseconds on large apps and must not block the event
+    loop, which ``make_asgi_app`` does. A pinned *accept* overrides negotiation.
+    """
+    _import_prometheus_client()
+    from prometheus_client.exposition import choose_encoder, gzip_accepted
+
+    def metrics(request: Request) -> Response:
+        encoder, content_type = choose_encoder(accept or request.headers.get("accept", ""))
+        names = request.query_params.getlist("name[]")
+        body = encoder(registry.restricted_registry(names) if names else registry)
+        headers = {"Content-Type": content_type}
+        if gzip_accepted(request.headers.get("accept-encoding", "")):
+            body = gzip.compress(body)
+            headers["Content-Encoding"] = "gzip"
+        return Response(body, headers=headers)
+
+    return metrics
+
+
+def mount_metrics_endpoint(
+    app: FastAPI,
+    path: str = "/metrics",
+    *,
+    metrics_format: MetricsFormat = "negotiate",
+) -> None:
+    """Serve Prometheus metrics at *path* (GET/HEAD, gzip when accepted).
+
+    * ``"negotiate"``   — ``prometheus_client`` picks OpenMetrics or classic text
+      from the ``Accept`` header.
+    * ``"openmetrics"`` — always OpenMetrics (exemplars visible).
+    * ``"prometheus"``  — always classic Prometheus text format.
+    """
+    path = normalize_path(path, default="/metrics")
+    if any(getattr(route, "path", None) == path for route in app.routes):
+        return
+    prometheus_client = _import_prometheus_client()
+    registry = prometheus_client.REGISTRY
+    if _multiprocess_dir():
+        from prometheus_client import multiprocess
+
+        registry = prometheus_client.CollectorRegistry(auto_describe=True)
+        multiprocess.MultiProcessCollector(registry)
+    endpoint = _metrics_endpoint(registry, _FORCED_ACCEPT.get(metrics_format))
+    app.routes.insert(0, Route(path, endpoint=endpoint, methods=["GET"]))

{fastapi_observer-1.6.0 → fastapi_observer-1.7.0}/src/fastapiobserver/middleware/__init__.py

@@ -7,7 +7,6 @@ from .headers import _get_header, _upsert_header
 from .ip import _IpResolver, _extract_scope_client_ip
 from .metrics import _MetricsRecorder
 from .request_logging import RequestLoggingMiddleware
-from .span_errors import _SpanErrorRecorder
 
 __all__ = [
     "RequestLoggingMiddleware",
@@ -16,7 +15,6 @@ __all__ = [
     "_MetricsRecorder",
     "_RequestContextManager",
     "_RequestEventBuilder",
-    "_SpanErrorRecorder",
     "_classify_error",
     "_extract_route_template",
     "_extract_scope_client_ip",