fastapi-observer 1.13.0__tar.gz → 1.15.0__tar.gz

{fastapi_observer-1.13.0/src/fastapi_observer.egg-info → fastapi_observer-1.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-observer
-Version: 1.13.0
+Version: 1.15.0
 Summary: Zero-glue FastAPI observability with security presets and runtime controls
 Author-email: Vitaee <opensource@vitaee.dev>
 License-Expression: MIT
@@ -149,7 +149,7 @@ Explicit variables and Python arguments always win over profile defaults. Every
 - **One JSON line per request** with method, path, status, duration and client IP, and your service's name, environment and version on every line, including your own `logging` calls.
 - **Request IDs** taken from `X-Request-ID` when the caller is a trusted proxy, generated otherwise, returned in the response and passed on to the services you call, so one ID finds a request's logs in every service.
 - **Redaction on by default.** Passwords, tokens, API keys, `Authorization` and cookies are masked before anything is written. Presets cover stricter needs (`strict`, `pci`, `gdpr`).
-- **Prometheus metrics** labelled by route template (`/orders/{order_id}`), and 404s for paths no route matches share one `<unmatched>` label, so neither IDs nor scanners explode cardinality.
+- **Prometheus metrics** labelled by route template (`/orders/{order_id}`). Requests no route matches, such as scanners, CORS preflights and requests an auth middleware rejects, share one `<unmatched>` label, and made-up methods share `_OTHER`, so neither IDs nor anonymous clients explode cardinality.
 - **OpenTelemetry traces**, from FastAPI's own support on 0.142 and later, with `trace_id` and `span_id` in every log line, and optional log export over OTLP, redacted like everything else.
 - **Non-blocking log writes.** Lines are written from a background thread, so a slow stdout never stalls the event loop.
 - **Help finding what slows a request down.** Opt-in: a warning with the stack of any sync call that blocks the event loop, and `DEBUG` lines written only for requests that fail. Always on: a warning when the thread pool or a database connection pool is full, the usual cause when latency climbs while CPU stays low. With tracing on, each request line counts its queries and outbound HTTP calls, and a query run once per item (N+1) gets a warning. With metrics on, `/metrics` shows how many bytes of logs each route writes, and `LOG_SAMPLE_RATE` keeps a share of successful requests, chosen by trace ID, while failed and slow requests are always written in full.

{fastapi_observer-1.13.0 → fastapi_observer-1.15.0}/README.md

@@ -73,7 +73,7 @@ Explicit variables and Python arguments always win over profile defaults. Every
 - **One JSON line per request** with method, path, status, duration and client IP, and your service's name, environment and version on every line, including your own `logging` calls.
 - **Request IDs** taken from `X-Request-ID` when the caller is a trusted proxy, generated otherwise, returned in the response and passed on to the services you call, so one ID finds a request's logs in every service.
 - **Redaction on by default.** Passwords, tokens, API keys, `Authorization` and cookies are masked before anything is written. Presets cover stricter needs (`strict`, `pci`, `gdpr`).
-- **Prometheus metrics** labelled by route template (`/orders/{order_id}`), and 404s for paths no route matches share one `<unmatched>` label, so neither IDs nor scanners explode cardinality.
+- **Prometheus metrics** labelled by route template (`/orders/{order_id}`). Requests no route matches, such as scanners, CORS preflights and requests an auth middleware rejects, share one `<unmatched>` label, and made-up methods share `_OTHER`, so neither IDs nor anonymous clients explode cardinality.
 - **OpenTelemetry traces**, from FastAPI's own support on 0.142 and later, with `trace_id` and `span_id` in every log line, and optional log export over OTLP, redacted like everything else.
 - **Non-blocking log writes.** Lines are written from a background thread, so a slow stdout never stalls the event loop.
 - **Help finding what slows a request down.** Opt-in: a warning with the stack of any sync call that blocks the event loop, and `DEBUG` lines written only for requests that fail. Always on: a warning when the thread pool or a database connection pool is full, the usual cause when latency climbs while CPU stays low. With tracing on, each request line counts its queries and outbound HTTP calls, and a query run once per item (N+1) gets a warning. With metrics on, `/metrics` shows how many bytes of logs each route writes, and `LOG_SAMPLE_RATE` keeps a share of successful requests, chosen by trace ID, while failed and slow requests are always written in full.

{fastapi_observer-1.13.0 → fastapi_observer-1.15.0/src/fastapi_observer.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-observer
-Version: 1.13.0
+Version: 1.15.0
 Summary: Zero-glue FastAPI observability with security presets and runtime controls
 Author-email: Vitaee <opensource@vitaee.dev>
 License-Expression: MIT
@@ -149,7 +149,7 @@ Explicit variables and Python arguments always win over profile defaults. Every
 - **One JSON line per request** with method, path, status, duration and client IP, and your service's name, environment and version on every line, including your own `logging` calls.
 - **Request IDs** taken from `X-Request-ID` when the caller is a trusted proxy, generated otherwise, returned in the response and passed on to the services you call, so one ID finds a request's logs in every service.
 - **Redaction on by default.** Passwords, tokens, API keys, `Authorization` and cookies are masked before anything is written. Presets cover stricter needs (`strict`, `pci`, `gdpr`).
-- **Prometheus metrics** labelled by route template (`/orders/{order_id}`), and 404s for paths no route matches share one `<unmatched>` label, so neither IDs nor scanners explode cardinality.
+- **Prometheus metrics** labelled by route template (`/orders/{order_id}`). Requests no route matches, such as scanners, CORS preflights and requests an auth middleware rejects, share one `<unmatched>` label, and made-up methods share `_OTHER`, so neither IDs nor anonymous clients explode cardinality.
 - **OpenTelemetry traces**, from FastAPI's own support on 0.142 and later, with `trace_id` and `span_id` in every log line, and optional log export over OTLP, redacted like everything else.
 - **Non-blocking log writes.** Lines are written from a background thread, so a slow stdout never stalls the event loop.
 - **Help finding what slows a request down.** Opt-in: a warning with the stack of any sync call that blocks the event loop, and `DEBUG` lines written only for requests that fail. Always on: a warning when the thread pool or a database connection pool is full, the usual cause when latency climbs while CPU stays low. With tracing on, each request line counts its queries and outbound HTTP calls, and a query run once per item (N+1) gets a warning. With metrics on, `/metrics` shows how many bytes of logs each route writes, and `LOG_SAMPLE_RATE` keeps a share of successful requests, chosen by trace ID, while failed and slow requests are always written in full.

fastapi_observer-1.15.0/src/fastapiobserver/_version.py

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

{fastapi_observer-1.13.0 → fastapi_observer-1.15.0}/src/fastapiobserver/fastapi.py

@@ -15,10 +15,9 @@ from fastapi import FastAPI
 
 from .config import ObservabilitySettings
 from .control_plane import RuntimeControlSettings, mount_control_plane
-from .logging import setup_logging, shutdown_logging
+from .logging import flush_logging, setup_logging
 from .loop_watchdog import EventLoopWatchdog
 from .profiles import apply_profile_context
-from .db_tracing import uninstrument_sqlalchemy
 from .metrics import (
     MetricsBackend,
     build_metrics_backend,
@@ -47,7 +46,6 @@ _ROUTE_PARAM_PATTERN = re.compile(r"\{[^{}]+\}")
 @dataclass
 class ObservabilityRuntimeState:
     settings: ObservabilitySettings
-    teardown_done: bool = False
     excluded_urls: frozenset[str] = frozenset()
 
 
@@ -86,11 +84,7 @@ def install_observability(
         otel_metrics_settings = otel_metrics_settings or OTelMetricsSettings.from_env()
         runtime_control_settings = runtime_control_settings or RuntimeControlSettings.from_env()
 
-    # Legacy fallback guard
-    app.state._observability_teardown_done = False
-
-    # Mark a fresh install cycle so shutdown executes once per lifecycle.
-    # Ensure settings are stored on state for lifespan to access
+    # Settings for the lifespan to read.
     app.state._observability_state = ObservabilityRuntimeState(settings=settings)
 
     # --- 1 & 2. Structured logging + OTLP Logs ---
@@ -148,6 +142,21 @@ def install_observability(
     if runtime_control_settings and runtime_control_settings.enabled:
         mount_control_plane(app, runtime_control_settings, trusted_proxy_policy)
 
+    if security_policy.redaction_mode == "hash" and security_policy.hash_key is None:
+        _LOGGER.warning(
+            "observability.redaction.hash_key_missing",
+            extra={
+                "event": {
+                    "message": (
+                        "Hashed values use a random key picked at startup, so they differ "
+                        "between processes and after a restart. Set OBS_REDACTION_HASH_KEY "
+                        "to keep them stable."
+                    ),
+                },
+                "_skip_enrichers": True,
+            },
+        )
+
     # --- 9. One line with the settings that took effect ---
     _LOGGER.info(
         "observability.configured",
@@ -394,7 +403,7 @@ def _build_exclude_path_variants(path: str) -> set[str]:
 
 @asynccontextmanager
 async def observability_lifespan(app: FastAPI) -> typing.AsyncGenerator[typing.Any, None]:
-    """A native FastAPI lifespan context manager for graceful observability teardown.
+    """A FastAPI lifespan context manager that writes out queued logs when the app stops.
     
     Developers can yield from this manager directly in their app's lifespan:
     
@@ -432,9 +441,8 @@ def _register_logging_shutdown_hook(app: FastAPI) -> None:
     ) -> typing.AsyncGenerator[typing.Any, None]:
         async with observability_lifespan(app_inst):
             if original_lifespan:
-                # If the user is explicitly using observability_lifespan inside their
-                # original_lifespan, this will safely no-op during cleanup because
-                # _teardown_observability is idempotent.
+                # If the user also enters observability_lifespan in their own
+                # lifespan, the queue is just flushed twice.
                 async with original_lifespan(app_inst) as state:
                     yield state
             else:
@@ -445,19 +453,9 @@ def _register_logging_shutdown_hook(app: FastAPI) -> None:
 
 
 def _teardown_observability(app: FastAPI) -> None:
-    state = _get_runtime_state(app)
-    if state:
-        if state.teardown_done:
-            return
-    elif getattr(app.state, "_observability_teardown_done", False):
-        return
-    
-    shutdown_logging()
-    uninstrument_sqlalchemy()
-    
-    if state:
-        state.teardown_done = True
-    else:
-        app.state._observability_teardown_done = True
+    # Logging and SQLAlchemy instrumentation are shared by every app in the
+    # process, and this app may start again, as a reused TestClient does. So
+    # write out what's queued and leave them running; atexit stops logging.
+    flush_logging()
 
 __all__ = ["install_observability", "observability_lifespan"]

{fastapi_observer-1.13.0 → fastapi_observer-1.15.0}/src/fastapiobserver/logging/__init__.py

@@ -15,6 +15,7 @@ from .queueing import (
     get_log_queue_stats,
 )
 from .setup import (
+    flush_logging,
     get_log_level,
     get_managed_output_handlers,
     set_log_level,
@@ -35,6 +36,7 @@ __all__ = [
     "SinkCircuitBreakerSnapshot",
     "StructuredJsonFormatter",
     "TraceContextFilter",
+    "flush_logging",
     "get_log_bytes_by_route",
     "get_log_level",
     "get_log_queue_stats",

{fastapi_observer-1.13.0 → fastapi_observer-1.15.0}/src/fastapiobserver/logging/filters.py

@@ -43,6 +43,8 @@ class TraceContextFilter(logging.Filter):
                 if span_context and span_context.is_valid:
                     trace_id = f"{span_context.trace_id:032x}"
                     span_id = f"{span_context.span_id:016x}"
+                    # For OTLP export, which runs on another thread.
+                    record._otel_span_context = span_context
             except Exception:
                 _LOGGER.debug(
                     "trace_context_filter.otel_lookup_failed",

{fastapi_observer-1.13.0 → fastapi_observer-1.15.0}/src/fastapiobserver/logging/formatter.py

@@ -3,8 +3,9 @@ from __future__ import annotations
 import hashlib
 import json
 import logging
-import re
+import traceback
 from datetime import datetime, timezone
+from types import TracebackType
 from typing import Any, Callable, Mapping
 
 from .._version import __version__
@@ -144,11 +145,11 @@ def _build_structured_error(
             "stacktrace": "",
         }
 
-    exc_type, exc_value, _exc_tb = exc_info
+    exc_type, exc_value, exc_tb = exc_info
     error_type = exc_type.__name__ if exc_type is not None else "Exception"
     error_message = str(exc_value) if exc_value is not None else ""
     stacktrace = formatter.formatException(exc_info)
-    fingerprint = _generate_error_fingerprint(error_type, stacktrace)
+    fingerprint = _generate_error_fingerprint(error_type, exc_tb)
 
     return {
         "type": error_type,
@@ -158,16 +159,13 @@ def _build_structured_error(
     }
 
 
-def _generate_error_fingerprint(error_type: str, stacktrace: str) -> str:
-    """Hash stack trace after stripping out environment-specific noise."""
-    if not stacktrace:
-        return hashlib.sha256(error_type.encode("utf-8")).hexdigest()[:32]
+def _generate_error_fingerprint(error_type: str, exc_tb: TracebackType | None) -> str:
+    """Hash the exception type and the file, function and source of each frame.
 
-    # Strip hexadecimal memory addresses
-    sanitized = re.sub(r"0x[0-9a-fA-F]+", "0x<ptr>", stacktrace)
-    # Strip exact line numbers to survive minor file refactoring
-    sanitized = re.sub(r"line \d+", "line <N>", sanitized)
-    
-    # Combine error type and sanitized trace to ensure distinct groupings
-    payload = f"{error_type}:{sanitized}"
-    return hashlib.sha256(payload.encode("utf-8")).hexdigest()[:32]
+    The message is left out, since it often holds IDs that differ each time the
+    same bug is hit, and so are line numbers, which shift with unrelated edits.
+    """
+    frames = "".join(
+        f"{frame.filename}:{frame.name}:{frame.line}\n" for frame in traceback.extract_tb(exc_tb)
+    )
+    return hashlib.sha256(f"{error_type}\n{frames}".encode("utf-8")).hexdigest()[:32]

{fastapi_observer-1.13.0 → fastapi_observer-1.15.0}/src/fastapiobserver/logging/queueing.py

@@ -168,6 +168,7 @@ class OverflowPolicyQueueHandler(logging.handlers.QueueHandler):
         log_queue = cast(queue.Queue[logging.LogRecord], self.queue)
         try:
             log_queue.get_nowait()
+            log_queue.task_done()  # dropped counts as done, or flush_logging() waits for it
             self.telemetry.record_drop_oldest()
         except queue.Empty:
             pass

{fastapi_observer-1.13.0 → fastapi_observer-1.15.0}/src/fastapiobserver/logging/setup.py

@@ -4,6 +4,8 @@ import atexit
 import logging
 import logging.handlers
 import queue
+import threading
+import time
 from typing import Literal, cast
 
 from ..config import ObservabilitySettings
@@ -43,6 +45,33 @@ def shutdown_logging() -> None:
         )
 
 
+def flush_logging(timeout_seconds: float = 5.0) -> None:
+    """Wait until queued records are written, then flush the outputs.
+
+    Logging keeps running, for other apps in the process and for this one if it
+    starts again. ``atexit`` stops it when the process exits.
+    """
+    import fastapiobserver.logging.state as state
+
+    listener = state._QUEUE_LISTENER
+    if listener is None:
+        return
+    log_queue = cast(queue.Queue[logging.LogRecord], listener.queue)
+    deadline = time.monotonic() + timeout_seconds
+    # The listener marks each record done once its handlers have run.
+    while log_queue.unfinished_tasks and time.monotonic() < deadline:
+        time.sleep(0.005)
+    for handler in list(state._MANAGED_OUTPUT_HANDLERS):
+        try:
+            handler.flush()
+        except Exception:
+            _LOGGER.debug(
+                "logging.output_handler.flush_failed",
+                exc_info=True,
+                extra={"_skip_enrichers": True},
+            )
+
+
 def _teardown_handlers_locked(suppress_errors: bool = True) -> None:
     """Safely stop listeners, unregister managed handlers, and close outputs."""
     import fastapiobserver.logging.state as state
@@ -289,22 +318,16 @@ def _restart_queue_listener_in_child() -> None:
 
     listener = state._QUEUE_LISTENER
     if listener is not None:
-        # The inherited queue's Condition lock might be held by the parent
-        # or left in an inconsistent state across the fork. To reliably resume
-        # processing, we must create a fresh queue. We explicitly drain and 
-        # DROP inherited records because the parent process's listener thread 
-        # is already processing those same records in the parent process. 
-        # Re-queuing them here causes deterministic duplicate logs.
+        # Another thread of the parent may have held any lock at the moment of
+        # the fork, and no thread in the child will release it. So don't touch
+        # the inherited queue, not even to drain it: its records are the
+        # parent's to write. Give the child fresh locks and a fresh queue.
+        _LOG_QUEUE_TELEMETRY._lock = threading.Lock()
+        for breaker in state._SINK_CIRCUIT_BREAKERS:
+            breaker._lock = threading.Lock()
         old_queue = cast(queue.Queue[logging.LogRecord], listener.queue)
         new_queue: queue.Queue[logging.LogRecord] = queue.Queue(maxsize=old_queue.maxsize)
 
-        while not old_queue.empty():
-            try:
-                # Discard the record to prevent pre-fork replay duplication
-                _ = old_queue.get_nowait()
-            except queue.Empty:
-                break
-
         # Re-attach the new queue to the OverflowPolicyQueueHandler if present
         for handler in state._MANAGED_HANDLERS:
             from .queueing import OverflowPolicyQueueHandler

{fastapi_observer-1.13.0 → fastapi_observer-1.15.0}/src/fastapiobserver/middleware/events.py

@@ -4,10 +4,12 @@ import re
 from collections.abc import Mapping
 from typing import Any
 from starlette.exceptions import HTTPException as StarletteHTTPException
+from starlette.routing import Match
 from starlette.types import Scope
 
 from ..request_context import UNMATCHED_ROUTE, route_template
 from ..security import SecurityPolicy, sanitize_event
+from ..security.redaction import redact_body
 
 _CREDENTIAL_RE = re.compile(r"://[^:]+:[^@]+@")
 
@@ -46,10 +48,11 @@ class _RequestEventBuilder:
             "url.path": path,
             "http.response.status_code": status_code,
         }
+        # Redaction below matches keys, and a body is one string value.
         if request_body is not None:
-            event["request_body"] = request_body
+            event["request_body"] = redact_body(request_body, self.policy)
         if response_body is not None:
-            event["response_body"] = response_body
+            event["response_body"] = redact_body(response_body, self.policy)
         if exception is not None:
             event["exception_class"] = exception.__class__.__name__
             event["exception_message"] = _sanitize_exception_message(str(exception))
@@ -73,20 +76,24 @@ def _classify_error(status_code: int, error: Exception | None) -> str:
     return "ok"
 
 
-def _extract_route_template(scope: Scope, raw_path: str, status_code: int) -> str:
+def _extract_route_template(scope: Scope) -> str:
     """Return the metrics ``path`` label: the matched route template if known.
 
-    After routing, ``scope["route"]`` holds the matched route, whose ``.path``
-    is the template (e.g. ``/users/{user_id}``). Without one, a 404 means no
-    route matched, mostly scanners, so those share ``UNMATCHED_ROUTE`` instead
-    of adding a time series per URL. Other requests without a template keep
-    *raw_path*: FastAPI doesn't record plain Starlette routes, such as ones
-    added with ``app.add_route()``, in the scope.
+    After routing, the scope holds the matched route's template (e.g.
+    ``/users/{user_id}``). FastAPI doesn't record plain Starlette routes, such
+    as ones added with ``app.add_route()``, so those are matched here. Anything
+    else reached no route, such as scanners, CORS preflights or requests an auth
+    middleware rejected, and shares ``UNMATCHED_ROUTE`` instead of adding a time
+    series per URL.
     """
     template = route_template(scope)
     if template:
         return template
-    return UNMATCHED_ROUTE if status_code == 404 else raw_path
+    for route in getattr(scope.get("app"), "routes", ()):
+        path = getattr(route, "path", None)
+        if path and route.matches(scope)[0] is not Match.NONE:
+            return str(path)
+    return UNMATCHED_ROUTE
 
 __all__ = [
     "UNMATCHED_ROUTE",

{fastapi_observer-1.13.0 → fastapi_observer-1.15.0}/src/fastapiobserver/middleware/request_logging.py

@@ -4,6 +4,7 @@ import logging
 import re
 import time
 
+from anyio import get_cancelled_exc_class
 from starlette.types import ASGIApp, Message, Receive, Scope, Send
 
 from ..config import ObservabilitySettings
@@ -31,6 +32,11 @@ _MAX_STATEMENT_LENGTH = 1000
 # Quoted strings and numbers, so values written into SQL text never reach a log line.
 # ponytail: misses dollar-quoted and E'' strings; parse SQL if those ever show up.
 _SQL_LITERALS = re.compile(r"'(?:[^']|'')*'|\b\d+(?:\.\d+)?\b")
+# Metric labels take the method only from this set, as OpenTelemetry does, so a
+# client can't add a time series per made-up method.
+_HTTP_METHODS = frozenset(
+    {"GET", "HEAD", "POST", "PUT", "DELETE", "CONNECT", "OPTIONS", "TRACE", "PATCH"}
+)
 
 
 class RequestLoggingMiddleware:
@@ -86,6 +92,8 @@ class RequestLoggingMiddleware:
             max_length=self.security_policy.max_body_length,
         )
         had_error = False
+        cancelled = False
+        response_started = False
 
         async def receive_wrapper() -> Message:
             message = await receive()
@@ -93,8 +101,9 @@ class RequestLoggingMiddleware:
             return message
 
         async def send_wrapper(message: Message) -> None:
-            nonlocal status_code
+            nonlocal status_code, response_started
             if message["type"] == "http.response.start":
+                response_started = True
                 status_code = int(message.get("status", 500))
                 resp_headers = message.get("headers", [])
                 if self.security_policy.log_response_body:
@@ -124,6 +133,13 @@ class RequestLoggingMiddleware:
             captured_error = exc
             status_code = 500
             raise
+        except get_cancelled_exc_class():
+            # The client left, the server is shutting down or a timeout fired.
+            # Not a server error: without a response, use nginx's 499.
+            cancelled = True
+            if not response_started:
+                status_code = 499
+            raise
         finally:
             self._finalize_request(
                 scope=scope,
@@ -136,6 +152,7 @@ class RequestLoggingMiddleware:
                 response_body_capture=response_body_capture,
                 captured_error=captured_error,
                 had_error=had_error,
+                cancelled=cancelled,
             )
 
     def _finalize_request(
@@ -150,10 +167,13 @@ class RequestLoggingMiddleware:
         response_body_capture: _BodyCapture,
         captured_error: Exception | None,
         had_error: bool,
+        cancelled: bool,
     ) -> None:
         duration_seconds = max(0.0, time.perf_counter() - start)
         if had_error:
             level, message = logging.ERROR, "request.failed"
+        elif cancelled:
+            level, message = logging.WARNING, "request.cancelled"
         elif status_code >= 500:
             level, message = logging.ERROR, "request.server_error"
         elif status_code >= 400:
@@ -187,13 +207,15 @@ class RequestLoggingMiddleware:
                 extra={"event": safe_event},
             )
 
-        # Prefer route template for bounded cardinality
-        route_template = _extract_route_template(scope, path, status_code)
+        route_template = _extract_route_template(scope)
+        metric_method = method if method in _HTTP_METHODS else "_OTHER"
         if request_state is not None and request_state.statements:
-            self._report_repeated_statement(method, route_template, request_state.statements)
+            self._report_repeated_statement(
+                metric_method, route_template, request_state.statements
+            )
 
         self.metrics_recorder.observe(
-            method=method,
+            method=metric_method,
             path=route_template,
             status_code=status_code,
             duration_seconds=duration_seconds,

{fastapi_observer-1.13.0 → fastapi_observer-1.15.0}/src/fastapiobserver/otel/lifecycle.py

@@ -1,7 +1,9 @@
 """Flush OTel providers when the FastAPI app shuts down.
 
-Process exit needs nothing from us: SDK providers register their own
-``atexit`` shutdown (``shutdown_on_exit=True``).
+Shutting them down is left to process exit: SDK providers register their own
+``atexit`` shutdown (``shutdown_on_exit=True``). A provider is global, so one
+app's lifespan ending mustn't stop it for other apps, or for this one if it
+starts again.
 """
 
 from __future__ import annotations
@@ -18,10 +20,8 @@ _LOGGER = logging.getLogger("fastapiobserver.otel")
 _HOOKED: weakref.WeakKeyDictionary[FastAPI, set[int]] = weakref.WeakKeyDictionary()
 
 
-def close_on_app_shutdown(app: FastAPI | None, provider: Any, *, shutdown: bool) -> None:
-    """Once ``app``'s lifespan ends, shut ``provider`` down (``shutdown=True``,
-    for providers we created) or just flush it (providers owned by someone else).
-    """
+def flush_on_app_shutdown(app: FastAPI | None, provider: Any) -> None:
+    """Each time ``app``'s lifespan ends, export what ``provider`` holds."""
     if app is None:
         return
     hooked = _HOOKED.setdefault(app, set())
@@ -31,27 +31,20 @@ def close_on_app_shutdown(app: FastAPI | None, provider: Any, *, shutdown: bool)
 
     # Wrap the lifespan: Starlette 1.0 removed add_event_handler/on_shutdown.
     original_lifespan = app.router.lifespan_context
-    done = False
 
     @asynccontextmanager
     async def lifespan(app_inst: FastAPI) -> AsyncGenerator[Any, None]:
-        nonlocal done
         try:
             async with original_lifespan(app_inst) as state:
                 yield state
         finally:
-            if not done:
-                done = True
-                try:
-                    if shutdown:  # SDK shutdown() exports pending data first
-                        provider.shutdown()
-                    else:
-                        provider.force_flush()
-                except Exception:
-                    _LOGGER.debug(
-                        "otel.provider.lifecycle.failed",
-                        exc_info=True,
-                        extra={"_skip_enrichers": True},
-                    )
+            try:
+                provider.force_flush()
+            except Exception:
+                _LOGGER.debug(
+                    "otel.provider.lifecycle.failed",
+                    exc_info=True,
+                    extra={"_skip_enrichers": True},
+                )
 
     app.router.lifespan_context = lifespan

{fastapi_observer-1.13.0 → fastapi_observer-1.15.0}/src/fastapiobserver/otel/logs.py

@@ -9,7 +9,7 @@ from fastapi import FastAPI
 
 from ..config import ObservabilitySettings
 from ..security import SecurityPolicy, sanitize_event
-from .lifecycle import close_on_app_shutdown
+from .lifecycle import flush_on_app_shutdown
 from .resource import (
     build_otlp_exporter,
     create_otel_resource,
@@ -39,6 +39,8 @@ class _SanitizingOTLPLogHandler(logging.Handler):
         super().__init__(level=delegate.level)
         self._delegate = delegate
         self._security_policy = security_policy
+        self._otel_context = import_otel_module("opentelemetry.context")
+        self._otel_trace = import_otel_module("opentelemetry.trace")
 
     def emit(self, record: logging.LogRecord) -> None:
         try:
@@ -47,7 +49,19 @@ class _SanitizingOTLPLogHandler(logging.Handler):
                 sanitized_record,
                 self._security_policy,
             )
-            self._delegate.emit(sanitized_record)
+            # Records are exported on the queue's listener thread, where no span
+            # is current, so OpenTelemetry would give them no trace. Make the
+            # span the record was created in current while it's exported.
+            span_context = sanitized_record.__dict__.pop("_otel_span_context", None)
+            if span_context is None:
+                self._delegate.emit(sanitized_record)
+                return
+            span = self._otel_trace.NonRecordingSpan(span_context)
+            token = self._otel_context.attach(self._otel_trace.set_span_in_context(span))
+            try:
+                self._delegate.emit(sanitized_record)
+            finally:
+                self._otel_context.detach(token)
         except Exception:
             self.handleError(record)
 
@@ -158,7 +172,7 @@ def install_otel_logs(
         raw_handler,
         security_policy=policy,
     )
-    close_on_app_shutdown(app, logger_provider, shutdown=provider_owned)
+    flush_on_app_shutdown(app, logger_provider)
     _LOGGER.info(
         "otel.logs.installed",
         extra={

{fastapi_observer-1.13.0 → fastapi_observer-1.15.0}/src/fastapiobserver/otel/metrics.py

@@ -8,7 +8,7 @@ from typing import Any
 from fastapi import FastAPI
 
 from ..config import ObservabilitySettings
-from .lifecycle import close_on_app_shutdown
+from .lifecycle import flush_on_app_shutdown
 from .resource import (
     build_otlp_exporter,
     create_otel_resource,
@@ -75,7 +75,7 @@ def install_otel_metrics(
             },
         )
 
-    close_on_app_shutdown(app, meter_provider, shutdown=provider_owned)
+    flush_on_app_shutdown(app, meter_provider)
     _LOGGER.info(
         "otel.metrics.installed",
         extra={

{fastapi_observer-1.13.0 → fastapi_observer-1.15.0}/src/fastapiobserver/otel/settings.py

@@ -38,9 +38,11 @@ class _BaseOTelSettings(EnvLoadable, BaseModel):
 class OTelSettings(_BaseOTelSettings):
 
     enabled: bool = False
-    service_name: str = "api"
-    service_version: str = "0.0.0"
-    environment: str = "development"
+    # None: ObservabilitySettings' service, version and environment, so traces
+    # and metrics name the service the same way.
+    service_name: str | None = None
+    service_version: str | None = None
+    environment: str | None = None
     trace_sampling_ratio: float = Field(default=1.0, ge=0.0, le=1.0)
     extra_resource_attributes: dict[str, str] = Field(default_factory=dict)
 

{fastapi_observer-1.13.0 → fastapi_observer-1.15.0}/src/fastapiobserver/otel/tracing.py

@@ -10,7 +10,7 @@ from fastapi import FastAPI
 
 from ..config import ObservabilitySettings
 from ..request_context import get_request_state
-from .lifecycle import close_on_app_shutdown
+from .lifecycle import flush_on_app_shutdown
 from .native import trace_natively
 from .resource import (
     build_excluded_urls_csv,
@@ -109,8 +109,7 @@ def install_otel(
             "opentelemetry.instrumentation.fastapi"
         ).FastAPIInstrumentor.instrument_app(app, **instrument_kwargs)
 
-    if provider_owned:
-        close_on_app_shutdown(app, tracer_provider, shutdown=True)
+    flush_on_app_shutdown(app, tracer_provider)
 
     _OTEL_INSTALLED_APPS.add(app)