codexLB-up 1.25.0b10__py3-none-any.whl

app/core/metrics/prometheus.py

@@ -0,0 +1,604 @@
+from __future__ import annotations
+
+import os
+from importlib import import_module
+from typing import Protocol
+
+
+class CollectorRegistryLike(Protocol):
+    pass
+
+
+class CounterLike(Protocol):
+    def inc(self, amount: float = 1) -> None: ...
+    def labels(self, *args: str, **kwargs: str) -> "CounterLike": ...
+
+
+class GaugeLike(Protocol):
+    def inc(self, amount: float = 1) -> None: ...
+    def dec(self, amount: float = 1) -> None: ...
+    def set(self, value: float) -> None: ...
+    def labels(self, *args: str, **kwargs: str) -> "GaugeLike": ...
+
+
+class HistogramLike(Protocol):
+    def observe(self, amount: float) -> None: ...
+    def labels(self, *args: str, **kwargs: str) -> "HistogramLike": ...
+
+
+try:
+    prometheus_client = import_module("prometheus_client")
+except ImportError:
+    prometheus_client = None
+
+
+PROMETHEUS_AVAILABLE = prometheus_client is not None
+MULTIPROCESS_MODE = bool(os.environ.get("PROMETHEUS_MULTIPROC_DIR"))
+
+
+if PROMETHEUS_AVAILABLE:
+    CollectorRegistry = getattr(prometheus_client, "CollectorRegistry")
+    Counter = getattr(prometheus_client, "Counter")
+    Gauge = getattr(prometheus_client, "Gauge")
+    Histogram = getattr(prometheus_client, "Histogram")
+
+    REGISTRY = CollectorRegistry(auto_describe=True)
+
+    requests_total = Counter(
+        "codex_lb_requests_total",
+        "Total HTTP requests",
+        ["method", "path", "status"],
+        registry=REGISTRY,
+    )
+    request_duration_seconds = Histogram(
+        "codex_lb_request_duration_seconds",
+        "HTTP request duration",
+        ["method", "path"],
+        registry=REGISTRY,
+    )
+    upstream_requests_total = Counter(
+        "codex_lb_upstream_requests_total",
+        "Total upstream requests",
+        ["account_id", "status"],
+        registry=REGISTRY,
+    )
+    upstream_transport_decisions_total = Counter(
+        "codex_lb_upstream_transport_decisions_total",
+        "Total upstream transport decisions for streaming Responses requests",
+        ["downstream_transport", "upstream_transport", "policy", "sticky", "status"],
+        registry=REGISTRY,
+    )
+    http_bridge_routing_total = Counter(
+        "codex_lb_http_bridge_routing_total",
+        "HTTP bridge routing evaluations by stage and reason (not connection successes)",
+        ["stage", "reason"],
+        registry=REGISTRY,
+    )
+    http_bridge_connections_total = Counter(
+        "codex_lb_http_bridge_connections_total",
+        "HTTP bridge connection lifecycle events",
+        ["event"],
+        registry=REGISTRY,
+    )
+    upstream_request_duration_seconds = Histogram(
+        "codex_lb_upstream_request_duration_seconds",
+        "Upstream request duration",
+        registry=REGISTRY,
+    )
+    upstream_reasoning_replay_400_total = Counter(
+        "codex_lb_upstream_reasoning_replay_400_total",
+        "Total upstream HTTP 400 rejections whose message references reasoning items",
+        registry=REGISTRY,
+    )
+    image_requests_total = Counter(
+        "codex_lb_image_requests_total",
+        "Total OpenAI-compatible image route requests",
+        ["route", "model", "stream", "status", "outcome"],
+        registry=REGISTRY,
+    )
+    image_request_duration_seconds = Histogram(
+        "codex_lb_image_request_duration_seconds",
+        "OpenAI-compatible image route request duration",
+        ["route", "model", "stream", "status", "outcome"],
+        registry=REGISTRY,
+    )
+
+    _gauge_kwargs: dict[str, str] = {}
+    if MULTIPROCESS_MODE:
+        _gauge_kwargs["multiprocess_mode"] = "livesum"
+
+    active_connections = Gauge(
+        "codex_lb_active_connections",
+        "Active HTTP connections",
+        registry=REGISTRY,
+        **_gauge_kwargs,
+    )
+    rate_limit_hits_total = Counter(
+        "codex_lb_rate_limit_hits_total",
+        "Rate limit hits",
+        ["type"],
+        registry=REGISTRY,
+    )
+    circuit_breaker_state = Gauge(
+        "codex_lb_circuit_breaker_state",
+        "Circuit breaker state (0=closed, 1=open, 2=half-open)",
+        ["service"],
+        registry=REGISTRY,
+        **({"multiprocess_mode": "liveall"} if MULTIPROCESS_MODE else {}),
+    )
+    accounts_total = Gauge(
+        "codex_lb_accounts_total",
+        "Total accounts by status",
+        ["status"],
+        registry=REGISTRY,
+        **({"multiprocess_mode": "liveall"} if MULTIPROCESS_MODE else {}),
+    )
+    bridge_instance_mismatch_total = Counter(
+        "codex_lb_bridge_instance_mismatch_total",
+        "Total bridge instance mismatches handled via graceful fallback",
+        ["outcome"],
+        registry=REGISTRY,
+    )
+    prompt_cache_key_derivation_total = Counter(
+        "codex_lb_prompt_cache_key_derivation_total",
+        "Total prompt-cache key resolutions by derivation outcome",
+        ["outcome"],
+        registry=REGISTRY,
+    )
+    bridge_prompt_cache_locality_miss_total = Counter(
+        "codex_lb_bridge_prompt_cache_locality_miss_total",
+        "Total prompt-cache bridge locality misses tolerated via gateway-safe handling",
+        registry=REGISTRY,
+    )
+    bridge_soft_local_rebind_total = Counter(
+        "codex_lb_bridge_soft_local_rebind_total",
+        "Total soft-affinity bridge sessions rebound locally on a non-owner instance",
+        registry=REGISTRY,
+    )
+    bridge_owner_forward_total = Counter(
+        "codex_lb_bridge_owner_forward_total",
+        "Total bridge owner forwards by outcome",
+        ["outcome"],
+        registry=REGISTRY,
+    )
+    bridge_durable_recover_total = Counter(
+        "codex_lb_bridge_durable_recover_total",
+        "Total durable bridge recoveries by path",
+        ["path"],
+        registry=REGISTRY,
+    )
+    bridge_same_account_takeover_total = Counter(
+        "codex_lb_bridge_same_account_takeover_total",
+        "Total same-account takeover outcomes",
+        ["outcome"],
+        registry=REGISTRY,
+    )
+    bridge_reattach_total = Counter(
+        "codex_lb_bridge_reattach_total",
+        "Total bridge reattach outcomes by path",
+        ["path", "outcome"],
+        registry=REGISTRY,
+    )
+    bridge_first_turn_timeout_total = Counter(
+        "codex_lb_bridge_first_turn_timeout_total",
+        "Total first-turn bridge timeouts during upstream connect",
+        registry=REGISTRY,
+    )
+    bridge_drain_recovery_allowed_total = Counter(
+        "codex_lb_bridge_drain_recovery_allowed_total",
+        "Total continuity recoveries allowed while bridge drain is active",
+        registry=REGISTRY,
+    )
+    bridge_owner_mismatch_total = Counter(
+        "codex_lb_bridge_owner_mismatch_total",
+        "Total bridge owner mismatches by key strength",
+        ["strength"],
+        registry=REGISTRY,
+    )
+    bridge_handoff_compatibility_rejection_total = Counter(
+        "codex_lb_bridge_handoff_compatibility_rejection_total",
+        "Total closed HTTP bridge admission handoffs rejected for incompatible request context",
+        ["continuity_anchor", "preferred_account", "service_tier", "api_key_scope"],
+        registry=REGISTRY,
+    )
+    bridge_unanchored_handoff_recovery_total = Counter(
+        "codex_lb_bridge_unanchored_handoff_recovery_total",
+        "Total stale closed HTTP bridge admission handoffs recovered without a continuity anchor",
+        ["reason"],
+        registry=REGISTRY,
+    )
+    bridge_local_rebind_total = Counter(
+        "codex_lb_bridge_local_rebind_total",
+        "Total bridge local rebinds by reason",
+        ["reason"],
+        registry=REGISTRY,
+    )
+    bridge_forward_latency_seconds = Histogram(
+        "codex_lb_bridge_forward_latency_seconds",
+        "Bridge owner forward latency",
+        registry=REGISTRY,
+    )
+    bridge_public_contract_error_total = Counter(
+        "codex_lb_bridge_public_contract_error_total",
+        "Total public /responses contract violations by kind",
+        ["kind"],
+        registry=REGISTRY,
+    )
+    continuity_owner_resolution_total = Counter(
+        "codex_lb_continuity_owner_resolution_total",
+        "Total continuity owner resolution outcomes by surface and source",
+        ["surface", "source", "outcome"],
+        registry=REGISTRY,
+    )
+    continuity_replay_rejected_total = Counter(
+        "codex_lb_continuity_replay_rejected_total",
+        "Total cross-account continuity replays refused by surface and refusing proof",
+        ["surface", "reason"],
+        registry=REGISTRY,
+    )
+    continuity_fail_closed_total = Counter(
+        "codex_lb_continuity_fail_closed_total",
+        "Total continuity fail-closed or masked retryable outcomes by surface and reason",
+        ["surface", "reason"],
+        registry=REGISTRY,
+    )
+    account_lease_acquired_total = Counter(
+        "codex_lb_account_lease_acquired_total",
+        "Total account pressure leases acquired by kind",
+        ["kind"],
+        registry=REGISTRY,
+    )
+    account_lease_released_total = Counter(
+        "codex_lb_account_lease_released_total",
+        "Total account pressure leases released by kind and reason",
+        ["kind", "reason"],
+        registry=REGISTRY,
+    )
+    account_lease_stale_reclaimed_total = Counter(
+        "codex_lb_account_lease_stale_reclaimed_total",
+        "Total stale account pressure leases reclaimed by kind",
+        ["kind"],
+        registry=REGISTRY,
+    )
+    account_inflight_leases = Gauge(
+        "codex_lb_account_inflight_leases",
+        "Current in-process account pressure leases by account and kind",
+        ["account_id", "kind"],
+        registry=REGISTRY,
+        **_gauge_kwargs,
+    )
+    account_cap_rejections_total = Counter(
+        "codex_lb_account_cap_rejections_total",
+        "Total account-local cap rejections by kind",
+        ["kind"],
+        registry=REGISTRY,
+    )
+    api_key_fair_share_rejections_total = Counter(
+        "codex_lb_api_key_fair_share_rejections_total",
+        "Total stream selections denied by the per-API-key fair-share gate",
+        registry=REGISTRY,
+    )
+    stream_pool_inflight = Gauge(
+        "codex_lb_stream_pool_inflight",
+        "In-flight stream leases over the fair-share gate's last candidate pool",
+        registry=REGISTRY,
+        **_gauge_kwargs,
+    )
+    _replica_gauge_kwargs: dict[str, str] = {}
+    if MULTIPROCESS_MODE:
+        # Sibling workers share one instance identity and compute the same
+        # replica count, so a max across workers (not livesum) reports the
+        # real value. Use "livemax" rather than "max": mark_process_dead()
+        # only removes live* gauge files, so plain "max" would retain a dead
+        # worker's stale higher count forever after a scale-down.
+        _replica_gauge_kwargs["multiprocess_mode"] = "livemax"
+    cap_partition_replicas = Gauge(
+        "codex_lb_cap_partition_replicas",
+        "Live replica count currently used for account cap partitioning",
+        registry=REGISTRY,
+        **_replica_gauge_kwargs,
+    )
+    # Sibling workers enforce independent lease counters, so each worker can
+    # admit its own pool capacity. Sum capacity across live workers (like the
+    # inflight gauge) so the exported utilization ratio stays comparable.
+    stream_pool_capacity = Gauge(
+        "codex_lb_stream_pool_capacity",
+        "Stream capacity of the fair-share gate's last candidate pool",
+        registry=REGISTRY,
+        **_gauge_kwargs,
+    )
+    proxy_phase_latency_seconds = Histogram(
+        "codex_lb_proxy_phase_latency_seconds",
+        "Proxy phase latency by low-cardinality phase and transport labels",
+        ["phase", "transport", "upstream_transport", "model_class"],
+        registry=REGISTRY,
+    )
+    http_bridge_prewarm_total = Counter(
+        "codex_lb_http_bridge_prewarm_total",
+        "Total HTTP bridge Codex prewarm outcomes",
+        ["outcome"],
+        registry=REGISTRY,
+    )
+    http_bridge_stuck_retire_total = Counter(
+        "codex_lb_http_bridge_stuck_retire_total",
+        "Total HTTP bridge stuck-session retirements",
+        ["reason", "affinity_kind", "model_class"],
+        registry=REGISTRY,
+    )
+    http_bridge_retry_circuit_total = Counter(
+        "codex_lb_http_bridge_retry_circuit_total",
+        "Total HTTP bridge automatic retry circuit outcomes",
+        ["outcome"],
+        registry=REGISTRY,
+    )
+    http_bridge_spool_cleanup_runs_total = Counter(
+        "codex_lb_http_bridge_spool_cleanup_runs_total",
+        "Total durable HTTP bridge transcript cleanup passes by outcome",
+        ["outcome"],
+        registry=REGISTRY,
+    )
+    http_bridge_spool_cleanup_deleted_operations_total = Counter(
+        "codex_lb_http_bridge_spool_cleanup_deleted_operations_total",
+        "Total durable HTTP bridge operations deleted by transcript retention",
+        registry=REGISTRY,
+    )
+    http_bridge_spool_cleanup_duration_seconds = Histogram(
+        "codex_lb_http_bridge_spool_cleanup_duration_seconds",
+        "Durable HTTP bridge transcript cleanup pass duration",
+        registry=REGISTRY,
+    )
+    http_bridge_spool_cleanup_backlog_likely = Gauge(
+        "codex_lb_http_bridge_spool_cleanup_backlog_likely",
+        "Whether the latest durable transcript cleanup pass stopped with likely backlog",
+        registry=REGISTRY,
+        **({"multiprocess_mode": "livemostrecent"} if MULTIPROCESS_MODE else {}),
+    )
+    http_bridge_operation_abandonment_total = Counter(
+        "codex_lb_http_bridge_operation_abandonment_total",
+        "Total ambiguous HTTP bridge operations fenced as abandoned",
+        ["source_state"],
+        registry=REGISTRY,
+    )
+    event_loop_lag_seconds = Gauge(
+        "codex_lb_event_loop_lag_seconds",
+        "Sampled event-loop scheduling lag (asyncio.sleep drift) in seconds",
+        registry=REGISTRY,
+        **({"multiprocess_mode": "livemax"} if MULTIPROCESS_MODE else {}),
+    )
+    event_loop_lag_warnings_total = Counter(
+        "codex_lb_event_loop_lag_warnings_total",
+        "Total event-loop lag samples at or above the warning threshold",
+        registry=REGISTRY,
+    )
+    stream_keepalive_sent_total = Counter(
+        "codex_lb_stream_keepalive_sent_total",
+        "Total downstream SSE keepalive frames emitted by surface",
+        ["surface"],
+        registry=REGISTRY,
+    )
+    stream_idle_timeout_total = Counter(
+        "codex_lb_stream_idle_timeout_total",
+        "Total streams terminated after exceeding the configured idle window",
+        ["surface"],
+        registry=REGISTRY,
+    )
+    stream_terminal_delivery_total = Counter(
+        "codex_lb_stream_terminal_delivery_total",
+        "Downstream SSE terminal-frame delivery outcomes by surface",
+        ["surface", "outcome"],
+        registry=REGISTRY,
+    )
+    cache_invalidation_bump_failures_total = Counter(
+        "codex_lb_cache_invalidation_bump_failures_total",
+        "Total cache invalidation version bumps that failed after retries",
+        ["namespace"],
+        registry=REGISTRY,
+    )
+    cache_invalidation_poll_failures_total = Counter(
+        "codex_lb_cache_invalidation_poll_failures_total",
+        "Total cache invalidation poll cycles that failed",
+        registry=REGISTRY,
+    )
+    # Model-source dispatch (#2123 WP-C1). ``kind`` is an opaque dispatch kind
+    # supplied by the caller (``direct`` for direct source routing); every label
+    # set is closed or bounded by the number of configured sources.
+    model_source_dispatch_total = Counter(
+        "codex_lb_model_source_dispatch_total",
+        "Total owned model-source dispatch attempts by dispatch kind and terminal status",
+        ["kind", "status"],
+        registry=REGISTRY,
+    )
+    model_source_dispatch_abandoned_total = Counter(
+        "codex_lb_model_source_dispatch_abandoned_total",
+        "Total model-source dispatches abandoned by a departing client, by stage",
+        ["stage"],
+        registry=REGISTRY,
+    )
+    model_source_timeout_total = Counter(
+        "codex_lb_model_source_timeout_total",
+        "Total model-source transport deadlines that expired, by phase",
+        ["phase"],
+        registry=REGISTRY,
+    )
+    model_source_bulkhead_rejections_total = Counter(
+        "codex_lb_model_source_bulkhead_rejections_total",
+        "Total model-source dispatches rejected by the per-source concurrency bulkhead",
+        ["source_id"],
+        registry=REGISTRY,
+    )
+    model_source_bulkhead_in_flight = Gauge(
+        "codex_lb_model_source_bulkhead_in_flight",
+        "In-flight model-source dispatches held by the per-source concurrency bulkhead",
+        ["source_id"],
+        registry=REGISTRY,
+        **_gauge_kwargs,
+    )
+    model_source_usage_estimated_total = Counter(
+        "codex_lb_model_source_usage_estimated_total",
+        "Total limited-key model-source reservations settled at an estimate, by cause",
+        ["source_id", "cause"],
+        registry=REGISTRY,
+    )
+
+    def make_scrape_registry() -> CollectorRegistryLike:
+        if MULTIPROCESS_MODE:
+            _multiprocess = import_module("prometheus_client.multiprocess")
+            registry = CollectorRegistry()
+            _multiprocess.MultiProcessCollector(registry)
+            return registry
+        return REGISTRY
+
+    def mark_process_dead() -> None:
+        if MULTIPROCESS_MODE:
+            try:
+                _multiprocess = import_module("prometheus_client.multiprocess")
+                _multiprocess.mark_process_dead(os.getpid())
+            except (ImportError, AttributeError):
+                pass
+
+else:
+    REGISTRY: CollectorRegistryLike | None = None
+    requests_total: CounterLike | None = None
+    request_duration_seconds: HistogramLike | None = None
+    upstream_requests_total: CounterLike | None = None
+    upstream_transport_decisions_total: CounterLike | None = None
+    http_bridge_routing_total: CounterLike | None = None
+    http_bridge_connections_total: CounterLike | None = None
+    upstream_request_duration_seconds: HistogramLike | None = None
+    upstream_reasoning_replay_400_total: CounterLike | None = None
+    image_requests_total: CounterLike | None = None
+    image_request_duration_seconds: HistogramLike | None = None
+    active_connections: GaugeLike | None = None
+    rate_limit_hits_total: CounterLike | None = None
+    circuit_breaker_state: GaugeLike | None = None
+    accounts_total: GaugeLike | None = None
+    bridge_instance_mismatch_total: CounterLike | None = None
+    prompt_cache_key_derivation_total: CounterLike | None = None
+    bridge_prompt_cache_locality_miss_total: CounterLike | None = None
+    bridge_soft_local_rebind_total: CounterLike | None = None
+    bridge_owner_forward_total: CounterLike | None = None
+    bridge_durable_recover_total: CounterLike | None = None
+    bridge_same_account_takeover_total: CounterLike | None = None
+    bridge_reattach_total: CounterLike | None = None
+    bridge_first_turn_timeout_total: CounterLike | None = None
+    bridge_drain_recovery_allowed_total: CounterLike | None = None
+    bridge_owner_mismatch_total: CounterLike | None = None
+    bridge_handoff_compatibility_rejection_total: CounterLike | None = None
+    bridge_unanchored_handoff_recovery_total: CounterLike | None = None
+    bridge_local_rebind_total: CounterLike | None = None
+    bridge_forward_latency_seconds: HistogramLike | None = None
+    bridge_public_contract_error_total: CounterLike | None = None
+    continuity_owner_resolution_total: CounterLike | None = None
+    continuity_replay_rejected_total: CounterLike | None = None
+    continuity_fail_closed_total: CounterLike | None = None
+    account_lease_acquired_total: CounterLike | None = None
+    account_lease_released_total: CounterLike | None = None
+    account_lease_stale_reclaimed_total: CounterLike | None = None
+    account_inflight_leases: GaugeLike | None = None
+    account_cap_rejections_total: CounterLike | None = None
+    api_key_fair_share_rejections_total: CounterLike | None = None
+    stream_pool_capacity: GaugeLike | None = None
+    stream_pool_inflight: GaugeLike | None = None
+    cap_partition_replicas: GaugeLike | None = None
+    proxy_phase_latency_seconds: HistogramLike | None = None
+    http_bridge_prewarm_total: CounterLike | None = None
+    http_bridge_stuck_retire_total: CounterLike | None = None
+    http_bridge_retry_circuit_total: CounterLike | None = None
+    http_bridge_spool_cleanup_runs_total: CounterLike | None = None
+    http_bridge_spool_cleanup_deleted_operations_total: CounterLike | None = None
+    http_bridge_spool_cleanup_duration_seconds: HistogramLike | None = None
+    http_bridge_spool_cleanup_backlog_likely: GaugeLike | None = None
+    http_bridge_operation_abandonment_total: CounterLike | None = None
+    event_loop_lag_seconds: GaugeLike | None = None
+    event_loop_lag_warnings_total: CounterLike | None = None
+    stream_keepalive_sent_total: CounterLike | None = None
+    stream_idle_timeout_total: CounterLike | None = None
+    stream_terminal_delivery_total: CounterLike | None = None
+    cache_invalidation_bump_failures_total: CounterLike | None = None
+    cache_invalidation_poll_failures_total: CounterLike | None = None
+    model_source_dispatch_total: CounterLike | None = None
+    model_source_dispatch_abandoned_total: CounterLike | None = None
+    model_source_timeout_total: CounterLike | None = None
+    model_source_bulkhead_rejections_total: CounterLike | None = None
+    model_source_bulkhead_in_flight: GaugeLike | None = None
+    model_source_usage_estimated_total: CounterLike | None = None
+
+    def make_scrape_registry() -> None:
+        return None
+
+    def mark_process_dead() -> None:
+        pass
+
+
+__all__ = [
+    "MULTIPROCESS_MODE",
+    "PROMETHEUS_AVAILABLE",
+    "REGISTRY",
+    "active_connections",
+    "account_cap_rejections_total",
+    "account_inflight_leases",
+    "account_lease_acquired_total",
+    "account_lease_released_total",
+    "account_lease_stale_reclaimed_total",
+    "accounts_total",
+    "api_key_fair_share_rejections_total",
+    "bridge_instance_mismatch_total",
+    "bridge_forward_latency_seconds",
+    "bridge_durable_recover_total",
+    "bridge_drain_recovery_allowed_total",
+    "bridge_first_turn_timeout_total",
+    "bridge_handoff_compatibility_rejection_total",
+    "bridge_local_rebind_total",
+    "bridge_owner_forward_total",
+    "bridge_owner_mismatch_total",
+    "bridge_public_contract_error_total",
+    "bridge_prompt_cache_locality_miss_total",
+    "bridge_reattach_total",
+    "bridge_same_account_takeover_total",
+    "bridge_soft_local_rebind_total",
+    "bridge_unanchored_handoff_recovery_total",
+    "cache_invalidation_bump_failures_total",
+    "cache_invalidation_poll_failures_total",
+    "cap_partition_replicas",
+    "circuit_breaker_state",
+    "continuity_fail_closed_total",
+    "event_loop_lag_seconds",
+    "event_loop_lag_warnings_total",
+    "continuity_owner_resolution_total",
+    "continuity_replay_rejected_total",
+    "http_bridge_prewarm_total",
+    "http_bridge_retry_circuit_total",
+    "http_bridge_spool_cleanup_backlog_likely",
+    "http_bridge_spool_cleanup_deleted_operations_total",
+    "http_bridge_spool_cleanup_duration_seconds",
+    "http_bridge_spool_cleanup_runs_total",
+    "http_bridge_operation_abandonment_total",
+    "http_bridge_stuck_retire_total",
+    "stream_keepalive_sent_total",
+    "stream_idle_timeout_total",
+    "stream_terminal_delivery_total",
+    "image_request_duration_seconds",
+    "image_requests_total",
+    "make_scrape_registry",
+    "mark_process_dead",
+    "model_source_bulkhead_in_flight",
+    "model_source_bulkhead_rejections_total",
+    "model_source_dispatch_abandoned_total",
+    "model_source_dispatch_total",
+    "model_source_timeout_total",
+    "model_source_usage_estimated_total",
+    "prometheus_client",
+    "prompt_cache_key_derivation_total",
+    "proxy_phase_latency_seconds",
+    "rate_limit_hits_total",
+    "request_duration_seconds",
+    "requests_total",
+    "stream_pool_capacity",
+    "stream_pool_inflight",
+    "upstream_reasoning_replay_400_total",
+    "upstream_request_duration_seconds",
+    "upstream_requests_total",
+    "upstream_transport_decisions_total",
+    "http_bridge_routing_total",
+    "http_bridge_connections_total",
+]

app/core/middleware/__init__.py

@@ -0,0 +1,25 @@
+from app.core.middleware.api_firewall import add_api_firewall_middleware
+from app.core.middleware.app_version import add_app_version_middleware
+from app.core.middleware.dashboard_auth_proxy import add_dashboard_auth_proxy_middleware
+from app.core.middleware.dashboard_csrf import add_dashboard_csrf_middleware
+from app.core.middleware.multipart_content_encoding import add_multipart_content_encoding_middleware
+from app.core.middleware.path_rewrite import add_backend_api_codex_v1_alias_middleware
+from app.core.middleware.request_body_limit import add_request_body_limit_middleware
+from app.core.middleware.request_decompression import add_request_decompression_middleware
+from app.core.middleware.request_id import add_request_id_middleware
+from app.core.middleware.required_capability_http import add_required_capability_http_middleware
+from app.core.middleware.trusted_proxy_headers import add_trusted_proxy_headers_middleware
+
+__all__ = [
+    "add_app_version_middleware",
+    "add_api_firewall_middleware",
+    "add_backend_api_codex_v1_alias_middleware",
+    "add_dashboard_auth_proxy_middleware",
+    "add_dashboard_csrf_middleware",
+    "add_multipart_content_encoding_middleware",
+    "add_request_body_limit_middleware",
+    "add_request_decompression_middleware",
+    "add_request_id_middleware",
+    "add_required_capability_http_middleware",
+    "add_trusted_proxy_headers_middleware",
+]