ccproxy-api 0.1.7__py3-none-any.whl → 0.2.0a4__py3-none-any.whl

ccproxy/api/middleware/logging.py

@@ -1,180 +0,0 @@
-"""Access logging middleware for structured HTTP request/response logging."""
-
-import time
-from typing import Any
-
-import structlog
-from fastapi import Request, Response
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.types import ASGIApp
-
-from ccproxy.api.dependencies import get_cached_settings
-
-
-logger = structlog.get_logger(__name__)
-
-
-class AccessLogMiddleware(BaseHTTPMiddleware):
-    """Middleware for structured access logging with request/response details."""
-
-    def __init__(self, app: ASGIApp):
-        """Initialize the access log middleware.
-
-        Args:
-            app: The ASGI application
-        """
-        super().__init__(app)
-
-    async def dispatch(self, request: Request, call_next: Any) -> Response:
-        """Process the request and log access details.
-
-        Args:
-            request: The incoming HTTP request
-            call_next: The next middleware/handler in the chain
-
-        Returns:
-            The HTTP response
-        """
-        # Record start time
-        start_time = time.perf_counter()
-
-        # Store log storage in request state if collection is enabled
-
-        settings = get_cached_settings(request)
-
-        if settings.observability.logs_collection_enabled and hasattr(
-            request.app.state, "log_storage"
-        ):
-            request.state.log_storage = request.app.state.log_storage
-
-        # Extract client info
-        client_ip = "unknown"
-        if request.client:
-            client_ip = request.client.host
-
-        # Extract request info
-        method = request.method
-        path = str(request.url.path)
-        query = str(request.url.query) if request.url.query else None
-        user_agent = request.headers.get("user-agent", "unknown")
-
-        # Get request ID from context if available
-        request_id: str | None = None
-        try:
-            if hasattr(request.state, "request_id"):
-                request_id = request.state.request_id
-            elif hasattr(request.state, "context"):
-                # Try to check if it's a RequestContext without importing
-                context = request.state.context
-                if hasattr(context, "request_id") and hasattr(context, "metadata"):
-                    request_id = context.request_id
-        except Exception:
-            # Ignore any errors getting request_id
-            pass
-
-        # Process the request
-        response: Response | None = None
-        error_message: str | None = None
-
-        try:
-            response = await call_next(request)
-        except Exception as e:
-            # Capture error for logging
-            error_message = str(e)
-            # Re-raise to let error handlers process it
-            raise
-        finally:
-            try:
-                # Calculate duration
-                duration_seconds = time.perf_counter() - start_time
-                duration_ms = duration_seconds * 1000
-
-                # Extract response info
-                if response:
-                    status_code = response.status_code
-
-                    # Extract rate limit headers if present
-                    rate_limit_info = {}
-                    anthropic_request_id = None
-                    for header_name, header_value in response.headers.items():
-                        header_lower = header_name.lower()
-                        # Capture x-ratelimit-* headers
-                        if header_lower.startswith(
-                            "x-ratelimit-"
-                        ) or header_lower.startswith("anthropic-ratelimit-"):
-                            rate_limit_info[header_lower] = header_value
-                        # Capture request-id from Anthropic's response
-                        elif header_lower == "request-id":
-                            anthropic_request_id = header_value
-
-                    # Add anthropic request ID if present
-                    if anthropic_request_id:
-                        rate_limit_info["anthropic_request_id"] = anthropic_request_id
-
-                    headers = request.state.context.metadata.get("headers", {})
-                    headers.update(rate_limit_info)
-                    request.state.context.metadata["headers"] = headers
-                    request.state.context.metadata["status_code"] = status_code
-                    # Extract metadata from context if available
-                    context_metadata = {}
-                    try:
-                        if hasattr(request.state, "context"):
-                            context = request.state.context
-                            # Check if it has the expected attributes of RequestContext
-                            if hasattr(context, "metadata") and isinstance(
-                                context.metadata, dict
-                            ):
-                                # Get all metadata from the context
-                                context_metadata = context.metadata.copy()
-                                # Remove fields we're already logging separately
-                                for key in [
-                                    "method",
-                                    "path",
-                                    "client_ip",
-                                    "status_code",
-                                    "request_id",
-                                    "duration_ms",
-                                    "duration_seconds",
-                                    "query",
-                                    "user_agent",
-                                    "error_message",
-                                ]:
-                                    context_metadata.pop(key, None)
-                    except Exception:
-                        # Ignore any errors extracting context metadata
-                        pass
-
-                    # Use start-only logging - let context handle comprehensive access logging
-                    # Only log basic request start info since context will handle complete access log
-                    from ccproxy.observability.access_logger import log_request_start
-
-                    log_request_start(
-                        request_id=request_id or "unknown",
-                        method=method,
-                        path=path,
-                        client_ip=client_ip,
-                        user_agent=user_agent,
-                        query=query,
-                        **rate_limit_info,
-                    )
-                else:
-                    # Log error case
-                    logger.error(
-                        "access_log_error",
-                        request_id=request_id,
-                        method=method,
-                        path=path,
-                        query=query,
-                        client_ip=client_ip,
-                        user_agent=user_agent,
-                        duration_ms=duration_ms,
-                        duration_seconds=duration_seconds,
-                        error_message=error_message or "No response generated",
-                        exc_info=True,
-                    )
-            except Exception as log_error:
-                # If logging fails, don't crash the app
-                # Use print as a last resort to indicate the issue
-                print(f"Failed to write access log: {log_error}")
-
-        return response

ccproxy/api/middleware/request_content_logging.py

@@ -1,297 +0,0 @@
-"""Request content logging middleware for capturing full HTTP request/response data."""
-
-import json
-from collections.abc import AsyncGenerator
-from typing import Any
-
-import structlog
-from fastapi import Request, Response
-from fastapi.responses import StreamingResponse
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.types import ASGIApp
-
-from ccproxy.utils.simple_request_logger import (
-    append_streaming_log,
-    write_request_log,
-)
-
-
-logger = structlog.get_logger(__name__)
-
-
-class RequestContentLoggingMiddleware(BaseHTTPMiddleware):
-    """Middleware for logging full HTTP request and response content."""
-
-    def __init__(self, app: ASGIApp):
-        """Initialize the request content logging middleware.
-
-        Args:
-            app: The ASGI application
-        """
-        super().__init__(app)
-
-    async def dispatch(self, request: Request, call_next: Any) -> Any:
-        """Process the request and log content.
-
-        Args:
-            request: The incoming HTTP request
-            call_next: The next middleware/handler in the chain
-
-        Returns:
-            The HTTP response
-        """
-        # Get request ID and timestamp from context if available
-        request_id = self._get_request_id(request)
-        timestamp = self._get_timestamp_prefix(request)
-
-        # Log incoming request
-        await self._log_request(request, request_id, timestamp)
-
-        # Process the request
-        response = await call_next(request)
-
-        # Log outgoing response
-        await self._log_response(response, request_id, timestamp)
-
-        return response
-
-    def _get_request_id(self, request: Request) -> str:
-        """Extract request ID from request state or context.
-
-        Args:
-            request: The HTTP request
-
-        Returns:
-            Request ID string or 'unknown' if not found
-        """
-        try:
-            # Try to get from request state
-            if hasattr(request.state, "request_id"):
-                return str(request.state.request_id)
-
-            # Try to get from request context
-            if hasattr(request.state, "context"):
-                context = request.state.context
-                if hasattr(context, "request_id"):
-                    return str(context.request_id)
-
-            # Fallback to UUID if available in headers
-            if "x-request-id" in request.headers:
-                return request.headers["x-request-id"]
-
-        except Exception:
-            pass  # Ignore errors and use fallback
-
-        return "unknown"
-
-    def _get_timestamp_prefix(self, request: Request) -> str | None:
-        """Extract timestamp prefix from request context.
-
-        Args:
-            request: The HTTP request
-
-        Returns:
-            Timestamp prefix string or None if not found
-        """
-        try:
-            # Try to get from request context
-            if hasattr(request.state, "context"):
-                context = request.state.context
-                if hasattr(context, "get_log_timestamp_prefix"):
-                    result = context.get_log_timestamp_prefix()
-                    return str(result) if result is not None else None
-        except Exception:
-            pass  # Ignore errors and use fallback
-
-        return None
-
-    async def _log_request(
-        self, request: Request, request_id: str, timestamp: str | None
-    ) -> None:
-        """Log incoming HTTP request content.
-
-        Args:
-            request: The HTTP request
-            request_id: Request identifier
-            timestamp: Timestamp prefix for the log file
-        """
-        try:
-            # Read request body
-            body = await request.body()
-
-            # Create request log data
-            request_data = {
-                "method": request.method,
-                "url": str(request.url),
-                "headers": dict(request.headers),
-                "query_params": dict(request.query_params),
-                "path_params": dict(request.path_params)
-                if hasattr(request, "path_params")
-                else {},
-                "body_size": len(body) if body else 0,
-                "body": None,
-            }
-
-            # Try to parse body as JSON, fallback to string
-            if body:
-                try:
-                    request_data["body"] = json.loads(body.decode("utf-8"))
-                except (json.JSONDecodeError, UnicodeDecodeError):
-                    try:
-                        request_data["body"] = body.decode("utf-8", errors="replace")
-                    except Exception:
-                        request_data["body"] = f"<binary data of length {len(body)}>"
-
-            await write_request_log(
-                request_id=request_id,
-                log_type="middleware_request",
-                data=request_data,
-                timestamp=timestamp,
-            )
-
-        except Exception as e:
-            logger.error(
-                "failed_to_log_request_content",
-                request_id=request_id,
-                error=str(e),
-            )
-
-    async def _log_response(
-        self, response: Response, request_id: str, timestamp: str | None
-    ) -> None:
-        """Log outgoing HTTP response content.
-
-        Args:
-            response: The HTTP response
-            request_id: Request identifier
-            timestamp: Timestamp prefix for the log file
-        """
-        try:
-            if isinstance(response, StreamingResponse):
-                # Handle streaming response
-                await self._log_streaming_response(response, request_id, timestamp)
-            else:
-                # Handle regular response
-                await self._log_regular_response(response, request_id, timestamp)
-
-        except Exception as e:
-            logger.error(
-                "failed_to_log_response_content",
-                request_id=request_id,
-                error=str(e),
-            )
-
-    async def _log_regular_response(
-        self, response: Response, request_id: str, timestamp: str | None
-    ) -> None:
-        """Log regular (non-streaming) HTTP response.
-
-        Args:
-            response: The HTTP response
-            request_id: Request identifier
-            timestamp: Timestamp prefix for the log file
-        """
-        # Create response log data
-        response_data = {
-            "status_code": response.status_code,
-            "headers": dict(response.headers),
-            "body": None,
-        }
-
-        # Try to get response body
-        if hasattr(response, "body") and response.body:
-            body = response.body
-            response_data["body_size"] = len(body)
-
-            try:
-                # Convert to bytes if needed
-                body_bytes = bytes(body) if isinstance(body, memoryview) else body
-                # Try to parse as JSON
-                response_data["body"] = json.loads(body_bytes.decode("utf-8"))
-            except (json.JSONDecodeError, UnicodeDecodeError):
-                try:
-                    # Fallback to string
-                    body_bytes = bytes(body) if isinstance(body, memoryview) else body
-                    response_data["body"] = body_bytes.decode("utf-8", errors="replace")
-                except Exception:
-                    response_data["body"] = f"<binary data of length {len(body)}>"
-        else:
-            response_data["body_size"] = 0
-
-        await write_request_log(
-            request_id=request_id,
-            log_type="middleware_response",
-            data=response_data,
-            timestamp=timestamp,
-        )
-
-    async def _log_streaming_response(
-        self, response: StreamingResponse, request_id: str, timestamp: str | None
-    ) -> None:
-        """Log streaming HTTP response by wrapping the stream.
-
-        Args:
-            response: The streaming HTTP response
-            request_id: Request identifier
-            timestamp: Timestamp prefix for the log file
-        """
-        # Log response metadata first
-        response_data = {
-            "status_code": response.status_code,
-            "headers": dict(response.headers),
-            "body_type": "streaming",
-            "media_type": response.media_type,
-        }
-
-        await write_request_log(
-            request_id=request_id,
-            log_type="middleware_response",
-            data=response_data,
-            timestamp=timestamp,
-        )
-
-        # Wrap the streaming response to capture content
-        original_body_iterator = response.body_iterator
-
-        def create_logged_body_iterator() -> AsyncGenerator[
-            str | bytes | memoryview[int], None
-        ]:
-            """Create wrapper around the original body iterator to log streaming content."""
-
-            async def logged_body_iterator() -> AsyncGenerator[
-                str | bytes | memoryview[int], None
-            ]:
-                try:
-                    async for chunk in original_body_iterator:
-                        # Log chunk as raw data
-                        if isinstance(chunk, bytes | bytearray):
-                            await append_streaming_log(
-                                request_id=request_id,
-                                log_type="middleware_streaming",
-                                data=bytes(chunk),
-                                timestamp=timestamp,
-                            )
-                        elif isinstance(chunk, str):
-                            await append_streaming_log(
-                                request_id=request_id,
-                                log_type="middleware_streaming",
-                                data=chunk.encode("utf-8"),
-                                timestamp=timestamp,
-                            )
-
-                        yield chunk
-
-                except Exception as e:
-                    logger.error(
-                        "error_in_streaming_response_logging",
-                        request_id=request_id,
-                        error=str(e),
-                    )
-                    # Continue with original iterator if logging fails
-                    async for chunk in original_body_iterator:
-                        yield chunk
-
-            return logged_body_iterator()
-
-        # Replace the body iterator with our logged version
-        response.body_iterator = create_logged_body_iterator()

ccproxy/api/middleware/server_header.py

@@ -1,58 +0,0 @@
-"""Server header middleware to set a default server header for non-proxy routes."""
-
-from starlette.types import ASGIApp, Message, Receive, Scope, Send
-
-
-class ServerHeaderMiddleware:
-    """Middleware to set a default server header for responses.
-
-    This middleware adds a server header to responses that don't already have one.
-    Proxy responses using ProxyResponse will preserve their upstream server header,
-    while other routes will get the default header.
-    """
-
-    def __init__(self, app: ASGIApp, server_name: str = "Claude Code Proxy"):
-        """Initialize the server header middleware.
-
-        Args:
-            app: The ASGI application
-            server_name: The default server name to use
-        """
-        self.app = app
-        self.server_name = server_name
-
-    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        """ASGI application entrypoint."""
-        if scope["type"] != "http":
-            await self.app(scope, receive, send)
-            return
-
-        async def send_wrapper(message: Message) -> None:
-            if message["type"] == "http.response.start":
-                headers = list(message.get("headers", []))
-
-                # Check if server header already exists
-                has_server = any(header[0].lower() == b"server" for header in headers)
-
-                # Only add server header for non-proxy routes
-                # Proxy routes will have their server header preserved from upstream
-                if not has_server:
-                    # Check if this looks like a proxy response by looking for specific headers
-                    is_proxy_response = any(
-                        header[0].lower()
-                        in [
-                            b"cf-ray",
-                            b"cf-cache-status",
-                            b"anthropic-ratelimit-unified-status",
-                        ]
-                        for header in headers
-                    )
-
-                    # Only add our server header if this is NOT a proxy response
-                    if not is_proxy_response:
-                        headers.append((b"server", self.server_name.encode()))
-                        message["headers"] = headers
-
-            await send(message)
-
-        await self.app(scope, receive, send_wrapper)

ccproxy/api/responses.py

@@ -1,89 +0,0 @@
-"""Custom response classes for preserving proxy headers."""
-
-from typing import Any
-
-from fastapi import Response
-from starlette.types import Receive, Scope, Send
-
-
-class ProxyResponse(Response):
-    """Custom response class that preserves all headers from upstream API.
-
-    This response class ensures that headers like 'server' from the upstream
-    API are preserved and not overridden by Uvicorn/Starlette.
-    """
-
-    def __init__(
-        self,
-        content: Any = None,
-        status_code: int = 200,
-        headers: dict[str, str] | None = None,
-        media_type: str | None = None,
-        background: Any = None,
-    ):
-        """Initialize the proxy response with preserved headers.
-
-        Args:
-            content: Response content
-            status_code: HTTP status code
-            headers: Headers to preserve from upstream
-            media_type: Content type
-            background: Background task
-        """
-        super().__init__(
-            content=content,
-            status_code=status_code,
-            headers=headers,
-            media_type=media_type,
-            background=background,
-        )
-        # Store original headers for preservation
-        self._preserve_headers = headers or {}
-
-    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        """Override the ASGI call to ensure headers are preserved.
-
-        This method intercepts the response sending process to ensure
-        that our headers are not overridden by the server.
-        """
-        # Ensure we include all original headers, including 'server'
-        headers_list = []
-        seen_headers = set()
-
-        # Add all headers from the response, but skip content-length
-        # as we'll recalculate it based on actual body
-        for name, value in self._preserve_headers.items():
-            lower_name = name.lower()
-            # Skip content-length and transfer-encoding as we'll set them correctly
-            if (
-                lower_name not in ["content-length", "transfer-encoding"]
-                and lower_name not in seen_headers
-            ):
-                headers_list.append((lower_name.encode(), value.encode()))
-                seen_headers.add(lower_name)
-
-        # Always set correct content-length based on actual body
-        if self.body:
-            headers_list.append((b"content-length", str(len(self.body)).encode()))
-        else:
-            headers_list.append((b"content-length", b"0"))
-
-        # Ensure we have content-type
-        has_content_type = any(h[0] == b"content-type" for h in headers_list)
-        if not has_content_type and self.media_type:
-            headers_list.append((b"content-type", self.media_type.encode()))
-
-        await send(
-            {
-                "type": "http.response.start",
-                "status": self.status_code,
-                "headers": headers_list,
-            }
-        )
-
-        await send(
-            {
-                "type": "http.response.body",
-                "body": self.body,
-            }
-        )