ccproxy-api 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

ccproxy/api/middleware/request_content_logging.py

@@ -0,0 +1,297 @@
+"""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/request_id.py

@@ -1,6 +1,7 @@
 """Request ID middleware for generating and tracking request IDs."""
 
 import uuid
+from datetime import UTC, datetime
 from typing import Any
 
 import structlog
@@ -38,6 +39,9 @@ class RequestIDMiddleware(BaseHTTPMiddleware):
         # Generate or extract request ID
         request_id = request.headers.get("x-request-id") or str(uuid.uuid4())
 
+        # Generate datetime for consistent logging across all layers
+        log_timestamp = datetime.now(UTC)
+
         # Get DuckDB storage from app state if available
         storage = getattr(request.app.state, "duckdb_storage", None)
 
@@ -45,6 +49,7 @@ class RequestIDMiddleware(BaseHTTPMiddleware):
         async with request_context(
             request_id=request_id,
             storage=storage,
+            log_timestamp=log_timestamp,
             method=request.method,
             path=str(request.url.path),
             client_ip=request.client.host if request.client else "unknown",

ccproxy/api/middleware/server_header.py

@@ -1,9 +1,5 @@
 """Server header middleware to set a default server header for non-proxy routes."""
 
-from typing import Any
-
-from fastapi import Request, Response
-from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.types import ASGIApp, Message, Receive, Scope, Send
 
 

ccproxy/api/routes/__init__.py

@@ -3,7 +3,13 @@
 # from ccproxy.api.routes.auth import router as auth_router  # Module doesn't exist
 from ccproxy.api.routes.claude import router as claude_router
 from ccproxy.api.routes.health import router as health_router
-from ccproxy.api.routes.metrics import router as metrics_router
+from ccproxy.api.routes.metrics import (
+    dashboard_router,
+    logs_router,
+)
+from ccproxy.api.routes.metrics import (
+    prometheus_router as metrics_router,
+)
 from ccproxy.api.routes.proxy import router as proxy_router
 
 
@@ -12,5 +18,7 @@ __all__ = [
     "claude_router",
     "health_router",
     "metrics_router",
+    "logs_router",
+    "dashboard_router",
     "proxy_router",
 ]

ccproxy/api/routes/claude.py

@@ -2,10 +2,9 @@
 
 import json
 from collections.abc import AsyncIterator
-from typing import Any
 
 import structlog
-from fastapi import APIRouter, Depends, HTTPException, Request
+from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import StreamingResponse
 
 from ccproxy.adapters.openai.adapter import (
@@ -13,9 +12,8 @@ from ccproxy.adapters.openai.adapter import (
     OpenAIChatCompletionRequest,
     OpenAIChatCompletionResponse,
 )
-from ccproxy.api.dependencies import get_claude_service
+from ccproxy.api.dependencies import ClaudeServiceDep
 from ccproxy.models.messages import MessageCreateParams, MessageResponse
-from ccproxy.services.claude_sdk_service import ClaudeSDKService
 
 
 # Create the router for Claude SDK endpoints
@@ -28,7 +26,7 @@ logger = structlog.get_logger(__name__)
 async def create_openai_chat_completion(
     request: Request,
     openai_request: OpenAIChatCompletionRequest,
-    claude_service: ClaudeSDKService = Depends(get_claude_service),
+    claude_service: ClaudeServiceDep,
 ) -> StreamingResponse | OpenAIChatCompletionResponse:
     """Create a chat completion using Claude SDK with OpenAI-compatible format.
 
@@ -80,7 +78,13 @@ async def create_openai_chat_completion(
             )
         else:
             # Convert non-streaming response to OpenAI format using adapter
-            openai_response = adapter.adapt_response(response)  # type: ignore[arg-type]
+            # Convert MessageResponse model to dict for adapter
+            # In non-streaming mode, response should always be MessageResponse
+            assert isinstance(response, MessageResponse), (
+                "Non-streaming response must be MessageResponse"
+            )
+            response_dict = response.model_dump()
+            openai_response = adapter.adapt_response(response_dict)
             return OpenAIChatCompletionResponse.model_validate(openai_response)
 
     except Exception as e:
@@ -97,7 +101,7 @@ async def create_openai_chat_completion(
 @router.post("/v1/messages", response_model=None)
 async def create_anthropic_message(
     request: MessageCreateParams,
-    claude_service: ClaudeSDKService = Depends(get_claude_service),
+    claude_service: ClaudeServiceDep,
 ) -> StreamingResponse | MessageResponse:
     """Create a message using Claude SDK with Anthropic format.
 
@@ -127,9 +131,17 @@ async def create_anthropic_message(
             async def anthropic_stream_generator() -> AsyncIterator[bytes]:
                 async for chunk in response:  # type: ignore[union-attr]
                     if chunk:
-                        yield f"data: {json.dumps(chunk)}\n\n".encode()
-                # Send final chunk
-                yield b"data: [DONE]\n\n"
+                        # All chunks from Claude SDK streaming should be dict format
+                        # and need proper SSE event formatting
+                        if isinstance(chunk, dict):
+                            # Determine event type from chunk type
+                            event_type = chunk.get("type", "message_delta")
+                            yield f"event: {event_type}\n".encode()
+                            yield f"data: {json.dumps(chunk)}\n\n".encode()
+                        else:
+                            # Fallback for unexpected format
+                            yield f"data: {json.dumps(chunk)}\n\n".encode()
+                # No final [DONE] chunk for Anthropic format
 
             return StreamingResponse(
                 anthropic_stream_generator(),
@@ -148,28 +160,7 @@ async def create_anthropic_message(
         from ccproxy.core.errors import ClaudeProxyError
 
         if isinstance(e, ClaudeProxyError):
-            raise
-        raise HTTPException(
-            status_code=500, detail=f"Internal server error: {str(e)}"
-        ) from e
-
-
-@router.get("/v1/models", response_model=None)
-async def list_models(
-    claude_service: ClaudeSDKService = Depends(get_claude_service),
-) -> dict[str, Any]:
-    """List available models using Claude SDK service.
-
-    Returns a combined list of Anthropic models and recent OpenAI models.
-    """
-    try:
-        return await claude_service.list_models()
-    except Exception as e:
-        # Re-raise specific proxy errors to be handled by the error handler
-        from ccproxy.core.errors import ClaudeProxyError
-
-        if isinstance(e, ClaudeProxyError):
-            raise
+            raise e
         raise HTTPException(
             status_code=500, detail=f"Internal server error: {str(e)}"
         ) from e

ccproxy/api/routes/health.py

@@ -13,10 +13,12 @@ import asyncio
 import functools
 import shutil
 import time
-from datetime import UTC, datetime, timezone
+from datetime import UTC, datetime
+from enum import Enum
 from typing import Any
 
 from fastapi import APIRouter, Response, status
+from pydantic import BaseModel
 from structlog import get_logger
 
 from ccproxy import __version__
@@ -28,6 +30,28 @@ from ccproxy.services.credentials import CredentialsManager
 router = APIRouter()
 logger = get_logger(__name__)
 
+
+class ClaudeCliStatus(str, Enum):
+    """Claude CLI status enumeration."""
+
+    AVAILABLE = "available"
+    NOT_INSTALLED = "not_installed"
+    BINARY_FOUND_BUT_ERRORS = "binary_found_but_errors"
+    TIMEOUT = "timeout"
+    ERROR = "error"
+
+
+class ClaudeCliInfo(BaseModel):
+    """Claude CLI information with structured data."""
+
+    status: ClaudeCliStatus
+    version: str | None = None
+    binary_path: str | None = None
+    version_output: str | None = None
+    error: str | None = None
+    return_code: str | None = None
+
+
 # Cache for Claude CLI check results
 _claude_cli_cache: tuple[float, tuple[str, dict[str, Any]]] | None = None
 _cache_ttl_seconds = 300  # Cache for 5 minutes
@@ -129,7 +153,7 @@ def _get_claude_cli_path() -> str | None:
     return shutil.which("claude")
 
 
-async def _check_claude_code() -> tuple[str, dict[str, Any]]:
+async def check_claude_code() -> tuple[str, dict[str, Any]]:
     """Check Claude Code CLI installation and version by running 'claude --version'.
 
     Results are cached for 5 minutes to avoid repeated subprocess calls.
@@ -259,6 +283,36 @@ async def _check_claude_code() -> tuple[str, dict[str, Any]]:
         return result
 
 
+async def get_claude_cli_info() -> ClaudeCliInfo:
+    """Get Claude CLI information as a structured Pydantic model.
+
+    Returns:
+        ClaudeCliInfo: Structured information about Claude CLI installation and status
+    """
+    cli_status, cli_details = await check_claude_code()
+
+    # Map the status to our enum values
+    if cli_status == "pass":
+        status_value = ClaudeCliStatus.AVAILABLE
+    elif cli_details.get("cli_status") == "not_installed":
+        status_value = ClaudeCliStatus.NOT_INSTALLED
+    elif cli_details.get("cli_status") == "binary_found_but_errors":
+        status_value = ClaudeCliStatus.BINARY_FOUND_BUT_ERRORS
+    elif cli_details.get("cli_status") == "timeout":
+        status_value = ClaudeCliStatus.TIMEOUT
+    else:
+        status_value = ClaudeCliStatus.ERROR
+
+    return ClaudeCliInfo(
+        status=status_value,
+        version=cli_details.get("version"),
+        binary_path=cli_details.get("binary_path"),
+        version_output=cli_details.get("version_output"),
+        error=cli_details.get("error"),
+        return_code=cli_details.get("return_code"),
+    )
+
+
 async def _check_claude_sdk() -> tuple[str, dict[str, Any]]:
     """Check Claude SDK installation and version.
 
@@ -337,7 +391,7 @@ async def readiness_probe(response: Response) -> dict[str, Any]:
 
     # Check OAuth credentials, CLI, and SDK separately
     oauth_status, oauth_details = await _check_oauth2_credentials()
-    cli_status, cli_details = await _check_claude_code()
+    cli_status, cli_details = await check_claude_code()
     sdk_status, sdk_details = await _check_claude_sdk()
 
     # Service is ready if no check returns "fail"
@@ -424,7 +478,7 @@ async def detailed_health_check(response: Response) -> dict[str, Any]:
 
     # Perform all health checks
     oauth_status, oauth_details = await _check_oauth2_credentials()
-    cli_status, cli_details = await _check_claude_code()
+    cli_status, cli_details = await check_claude_code()
     sdk_status, sdk_details = await _check_claude_sdk()
 
     # Determine overall status - prioritize failures, then warnings