claude-proxy / src /free_claude_code /api /request_outcomes.py
dheraingoud's picture
sync: upstream 8dfff832 (v6.18.5) + custom addons (KeyRotator, 401/403 rotation, sol/terra/luna, ScannerTrap, health, Py3.12 compat)
2e7b8ca
Raw History Blame Contribute Delete
5.12 kB
from __future__ import annotations
"""Log one final inference outcome after HTTP delivery and owned cleanup."""
import asyncio
import codecs
from time import monotonic
from loguru import logger
from starlette.datastructures import Headers
from starlette.types import ASGIApp, Message, Receive, Scope, Send
from free_claude_code.core.anthropic.stream_contracts import SSEEvent
from free_claude_code.core.anthropic.streaming.decoder import AnthropicSSEDecoder
from free_claude_code.core.request_outcomes import (
RequestOutcome,
current_request_outcome,
record_request_exception,
record_request_failure,
)
from .generation_paths import generation_api
_FAILURE_EVENTS = frozenset({"error", "response.error", "response.failed"})
def _observe_event(event: SSEEvent) -> None:
kind = (
event.event
or event.data.get("type")
or ("error" if "error" in event.data else None)
)
if not isinstance(kind, str) or kind not in _FAILURE_EVENTS:
return
response = event.data.get("response")
payload = response if isinstance(response, dict) else event.data
error = payload.get("error")
error = error if isinstance(error, dict) else payload
reason = error.get("code") or error.get("type")
record_request_failure(reason if isinstance(reason, str) else str(kind))
class RequestOutcomeMiddleware:
"""Observe inference delivery without changing its body or control flow."""
def __init__(self, app: ASGIApp) -> None:
self._app = app
async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
if (
scope["type"] != "http"
or scope.get("method") != "POST"
or generation_api(scope.get("path", "")) is None
):
await self._app(scope, receive, send)
return
started = monotonic()
outcome = RequestOutcome()
status_code: int | None = None
completed = disconnected = cancelled = False
decoder: AnthropicSSEDecoder | None = None
text_decoder = codecs.getincrementaldecoder("utf-8")(errors="replace")
async def receive_observed() -> Message:
nonlocal disconnected
message = await receive()
if message["type"] == "http.disconnect":
disconnected = True
return message
async def send_observed(message: Message) -> None:
nonlocal status_code, completed, decoder, disconnected
try:
await send(message)
except OSError:
disconnected = True
raise
if message["type"] == "http.response.start":
status_code = message["status"]
if (
Headers(raw=message.get("headers", []))
.get("content-type", "")
.startswith("text/event-stream")
):
decoder = AnthropicSSEDecoder(
event_names=None
if generation_api(scope["path"]) == "gemini"
else _FAILURE_EVENTS
)
elif message["type"] == "http.response.body":
completed = not message.get("more_body", False)
if decoder is not None:
text = text_decoder.decode(
message.get("body", b""), final=completed
)
for event in decoder.feed(text):
_observe_event(event)
if completed:
for event in decoder.finish():
_observe_event(event)
token = current_request_outcome.set(outcome)
try:
await self._app(scope, receive_observed, send_observed)
except asyncio.CancelledError:
cancelled = True
raise
except BaseException as error:
if not disconnected:
record_request_exception(error)
if status_code is None:
status_code = 500
raise
finally:
current_request_outcome.reset(token)
reason = outcome.failure_reason
if reason is not None or (status_code is not None and status_code >= 400):
result = "failure"
reason = reason or f"http_{status_code}"
elif (cancelled or disconnected) and not completed:
result = "cancelled"
elif not completed:
result, reason = "failure", "incomplete_response"
else:
result = "success"
logger.bind(
event="request.completed",
wire_api=generation_api(scope["path"]),
provider_id=outcome.provider_id,
model=outcome.model,
status_code=status_code,
outcome=result,
duration_ms=round((monotonic() - started) * 1000, 2),
failure_reason=reason,
).info("Inference request {}", result)