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

ccproxy/services/credentials/manager.py

@@ -22,7 +22,6 @@ from ccproxy.auth.models import (
 from ccproxy.auth.storage import JsonFileTokenStorage as JsonFileStorage
 from ccproxy.auth.storage import TokenStorage as CredentialsStorageBackend
 from ccproxy.config.auth import AuthSettings
-from ccproxy.services.credentials.config import CredentialsConfig
 from ccproxy.services.credentials.oauth_client import OAuthClient
 
 

ccproxy/services/credentials/oauth_client.py

@@ -4,13 +4,12 @@ import asyncio
 import base64
 import hashlib
 import secrets
-import time
 import urllib.parse
 import webbrowser
 from datetime import UTC, datetime
 from http.server import BaseHTTPRequestHandler, HTTPServer
 from threading import Thread
-from typing import Any, Optional
+from typing import Any
 from urllib.parse import parse_qs, urlparse
 
 import httpx

ccproxy/services/proxy_service.py

@@ -2,7 +2,6 @@
 
 import asyncio
 import json
-import logging
 import os
 import random
 import time
@@ -15,7 +14,6 @@ import httpx
 import structlog
 from fastapi import HTTPException, Request
 from fastapi.responses import StreamingResponse
-from pydantic import BaseModel
 from typing_extensions import TypedDict
 
 from ccproxy.config.settings import Settings
@@ -33,6 +31,10 @@ from ccproxy.observability import (
 from ccproxy.observability.access_logger import log_request_access
 from ccproxy.services.credentials.manager import CredentialsManager
 from ccproxy.testing import RealisticMockResponseGenerator
+from ccproxy.utils.simple_request_logger import (
+    append_streaming_log,
+    write_request_log,
+)
 
 
 if TYPE_CHECKING:
@@ -120,14 +122,10 @@ class ProxyService:
         self._verbose_api = (
             os.environ.get("CCPROXY_VERBOSE_API", "false").lower() == "true"
         )
-        self._request_log_dir = os.environ.get("CCPROXY_REQUEST_LOG_DIR")
-
-        # Create request log directory if specified
-        if self._request_log_dir and self._verbose_api:
-            Path(self._request_log_dir).mkdir(parents=True, exist_ok=True)
+        # Note: Request logging is now handled by simple_request_logger utility
+        # which checks CCPROXY_LOG_REQUESTS and CCPROXY_REQUEST_LOG_DIR independently
 
-        # Track current request ID for logging
-        self._current_request_id: str | None = None
+        # Request context is now passed as parameters to methods
 
     def _init_proxy_url(self) -> str | None:
         """Initialize proxy URL from environment variables."""
@@ -195,10 +193,6 @@ class ProxyService:
         model, streaming = self._extract_request_metadata(body)
         endpoint = path.split("/")[-1] if path else "unknown"
 
-        # Handle /v1/models endpoint specially
-        if path == "/v1/models":
-            return await self.handle_models_request(headers, timeout)
-
         # Use existing context from request if available, otherwise create new one
         if request and hasattr(request, "state") and hasattr(request.state, "context"):
             # Use existing context from middleware
@@ -237,9 +231,6 @@ class ProxyService:
             )
 
         async with context_manager as ctx:
-            # Store the current request ID for file logging
-            self._current_request_id = ctx.request_id
-
             try:
                 # 1. Authentication - get access token
                 async with timed_operation("oauth_token", ctx.request_id):
@@ -299,7 +290,7 @@ class ProxyService:
                     logger.debug("non_streaming_response_detected")
 
                 # Log the outgoing request if verbose API logging is enabled
-                self._log_verbose_api_request(transformed_request)
+                await self._log_verbose_api_request(transformed_request, ctx)
 
                 # Handle regular request
                 async with timed_operation("api_call", ctx.request_id) as api_op:
@@ -322,8 +313,8 @@ class ProxyService:
                     api_op["duration_seconds"] = api_duration
 
                 # Log the received response if verbose API logging is enabled
-                self._log_verbose_api_response(
-                    status_code, response_headers, response_body
+                await self._log_verbose_api_response(
+                    status_code, response_headers, response_body, ctx
                 )
 
                 # 4. Response transformation
@@ -439,9 +430,6 @@ class ProxyService:
                 # Re-raise the exception without transformation
                 # Let higher layers handle specific error types
                 raise
-            finally:
-                # Reset current request ID
-                self._current_request_id = None
 
     async def _get_access_token(self) -> str:
         """Get access token for upstream authentication.
@@ -483,7 +471,7 @@ class ProxyService:
                     logger.debug(
                         "credential_check_failed",
                         error=str(e),
-                        exc_info=logger.isEnabledFor(logging.DEBUG),
+                        exc_info=True,
                     )
 
                 raise HTTPException(
@@ -624,7 +612,9 @@ class ProxyService:
             for k, v in headers.items()
         }
 
-    def _log_verbose_api_request(self, request_data: RequestData) -> None:
+    async def _log_verbose_api_request(
+        self, request_data: RequestData, ctx: "RequestContext"
+    ) -> None:
         """Log details of an outgoing API request if verbose logging is enabled."""
         if not self._verbose_api:
             return
@@ -656,21 +646,27 @@ class ProxyService:
             body_preview=body_preview,
         )
 
-        # Write to individual file if directory is specified
-        # Note: We cannot get request ID here since this is called from multiple places
-        # Request ID will be determined within _write_request_to_file method
-        self._write_request_to_file(
-            "request",
-            {
+        # Use new request logging system
+        request_id = ctx.request_id
+        timestamp = ctx.get_log_timestamp_prefix()
+        await write_request_log(
+            request_id=request_id,
+            log_type="upstream_request",
+            data={
                 "method": request_data["method"],
                 "url": request_data["url"],
                 "headers": dict(request_data["headers"]),  # Don't redact in file
                 "body": full_body,
             },
+            timestamp=timestamp,
         )
 
-    def _log_verbose_api_response(
-        self, status_code: int, headers: dict[str, str], body: bytes
+    async def _log_verbose_api_response(
+        self,
+        status_code: int,
+        headers: dict[str, str],
+        body: bytes,
+        ctx: "RequestContext",
     ) -> None:
         """Log details of a received API response if verbose logging is enabled."""
         if not self._verbose_api:
@@ -692,7 +688,7 @@ class ProxyService:
             body_preview=body_preview,
         )
 
-        # Write to individual file if directory is specified
+        # Use new request logging system
         full_body = None
         if body:
             try:
@@ -705,13 +701,18 @@ class ProxyService:
             except Exception:
                 full_body = f"<binary data of length {len(body)}>"
 
-        self._write_request_to_file(
-            "response",
-            {
+        # Use new request logging system
+        request_id = ctx.request_id
+        timestamp = ctx.get_log_timestamp_prefix()
+        await write_request_log(
+            request_id=request_id,
+            log_type="upstream_response",
+            data={
                 "status_code": status_code,
                 "headers": dict(headers),  # Don't redact in file
                 "body": full_body,
             },
+            timestamp=timestamp,
         )
 
     def _should_stream_response(self, headers: dict[str, str]) -> bool:
@@ -774,7 +775,7 @@ class ProxyService:
             StreamingResponse or error response tuple
         """
         # Log the outgoing request if verbose API logging is enabled
-        self._log_verbose_api_request(request_data)
+        await self._log_verbose_api_request(request_data, ctx)
 
         # First, make the request and check for errors before streaming
         proxy_url = self._proxy_url
@@ -799,8 +800,8 @@ class ProxyService:
                 error_content = await response.aread()
 
                 # Log the full error response body
-                self._log_verbose_api_response(
-                    response.status_code, dict(response.headers), error_content
+                await self._log_verbose_api_response(
+                    response.status_code, dict(response.headers), error_content, ctx
                 )
 
                 logger.info(
@@ -899,6 +900,25 @@ class ProxyService:
                     response_status = response.status_code
                     response_headers = dict(response.headers)
 
+                    # Log upstream response headers for streaming
+                    if self._verbose_api:
+                        request_id = ctx.request_id
+                        timestamp = ctx.get_log_timestamp_prefix()
+                        await write_request_log(
+                            request_id=request_id,
+                            log_type="upstream_response_headers",
+                            data={
+                                "status_code": response.status_code,
+                                "headers": dict(response.headers),
+                                "stream_type": "anthropic_sse"
+                                if not self.response_transformer._is_openai_request(
+                                    original_path
+                                )
+                                else "openai_sse",
+                            },
+                            timestamp=timestamp,
+                        )
+
                     # Transform streaming response
                     is_openai = self.response_transformer._is_openai_request(
                         original_path
@@ -911,11 +931,23 @@ class ProxyService:
                         # Transform Anthropic SSE to OpenAI SSE format using adapter
                         logger.debug("sse_transform_start", path=original_path)
 
+                        # Get timestamp once for all streaming chunks
+                        request_id = ctx.request_id
+                        timestamp = ctx.get_log_timestamp_prefix()
+
                         async for (
                             transformed_chunk
                         ) in self._transform_anthropic_to_openai_stream(
                             response, original_path
                         ):
+                            # Log transformed streaming chunk
+                            await append_streaming_log(
+                                request_id=request_id,
+                                log_type="upstream_streaming",
+                                data=transformed_chunk,
+                                timestamp=timestamp,
+                            )
+
                             logger.debug(
                                 "transformed_chunk_yielded",
                                 chunk_size=len(transformed_chunk),
@@ -930,10 +962,22 @@ class ProxyService:
                         # Use cached verbose streaming configuration
                         verbose_streaming = self._verbose_streaming
 
+                        # Get timestamp once for all streaming chunks
+                        request_id = ctx.request_id
+                        timestamp = ctx.get_log_timestamp_prefix()
+
                         async for chunk in response.aiter_bytes():
                             if chunk:
                                 chunk_count += 1
 
+                                # Log raw streaming chunk
+                                await append_streaming_log(
+                                    request_id=request_id,
+                                    log_type="upstream_streaming",
+                                    data=chunk,
+                                    timestamp=timestamp,
+                                )
+
                                 # Compact logging for content_block_delta events
                                 chunk_str = chunk.decode("utf-8", errors="replace")
 
@@ -1048,12 +1092,21 @@ class ProxyService:
 
         # Parse SSE chunks from response into dict stream
         async def sse_to_dict_stream() -> AsyncGenerator[dict[str, object], None]:
+            chunk_count = 0
             async for line in response.aiter_lines():
                 if line.startswith("data: "):
                     data_str = line[6:].strip()
                     if data_str and data_str != "[DONE]":
                         try:
-                            yield json.loads(data_str)
+                            chunk_data = json.loads(data_str)
+                            chunk_count += 1
+                            logger.debug(
+                                "proxy_anthropic_chunk_received",
+                                chunk_count=chunk_count,
+                                chunk_type=chunk_data.get("type"),
+                                chunk=chunk_data,
+                            )
+                            yield chunk_data
                         except json.JSONDecodeError:
                             logger.warning("sse_parse_failed", data=data_str)
                             continue
@@ -1065,43 +1118,6 @@ class ProxyService:
             sse_line = f"data: {json.dumps(openai_chunk)}\n\n"
             yield sse_line.encode("utf-8")
 
-    def _write_request_to_file(self, data_type: str, data: dict[str, Any]) -> None:
-        """Write request or response data to individual file if logging directory is configured.
-
-        Args:
-            data_type: Type of data ("request" or "response")
-            data: The data to write
-        """
-        if not self._request_log_dir or not self._verbose_api:
-            return
-
-        # Use the current request ID stored during request handling
-        request_id = self._current_request_id or "unknown"
-
-        # Create filename with request ID and data type
-        filename = f"{request_id}_{data_type}.json"
-        file_path = Path(self._request_log_dir) / filename
-
-        try:
-            # Write JSON data to file
-            with file_path.open("w", encoding="utf-8") as f:
-                json.dump(data, f, indent=2, default=str)
-
-            logger.debug(
-                "request_data_logged_to_file",
-                request_id=request_id,
-                data_type=data_type,
-                file_path=str(file_path),
-            )
-
-        except Exception as e:
-            logger.error(
-                "failed_to_write_request_log_file",
-                request_id=request_id,
-                data_type=data_type,
-                error=str(e),
-            )
-
     def _extract_message_type_from_body(self, body: bytes | None) -> str:
         """Extract message type from request body for realistic response generation."""
         if not body:
@@ -1382,151 +1398,6 @@ class ProxyService:
 
         return openai_chunks
 
-    async def handle_models_request(
-        self,
-        headers: dict[str, str],
-        timeout: float = 240.0,
-    ) -> tuple[int, dict[str, str], bytes]:
-        """Handle a /v1/models request to list available models.
-
-        Since Anthropic API doesn't support /v1/models endpoint,
-        returns a hardcoded list of Anthropic models and recent OpenAI models.
-
-        Args:
-            headers: Request headers
-            timeout: Request timeout in seconds
-
-        Returns:
-            Tuple of (status_code, headers, body)
-        """
-        # Define hardcoded Anthropic models
-        anthropic_models = [
-            {
-                "type": "model",
-                "id": "claude-opus-4-20250514",
-                "display_name": "Claude Opus 4",
-                "created_at": 1747526400,  # 2025-05-22
-            },
-            {
-                "type": "model",
-                "id": "claude-sonnet-4-20250514",
-                "display_name": "Claude Sonnet 4",
-                "created_at": 1747526400,  # 2025-05-22
-            },
-            {
-                "type": "model",
-                "id": "claude-3-7-sonnet-20250219",
-                "display_name": "Claude Sonnet 3.7",
-                "created_at": 1740268800,  # 2025-02-24
-            },
-            {
-                "type": "model",
-                "id": "claude-3-5-sonnet-20241022",
-                "display_name": "Claude Sonnet 3.5 (New)",
-                "created_at": 1729555200,  # 2024-10-22
-            },
-            {
-                "type": "model",
-                "id": "claude-3-5-haiku-20241022",
-                "display_name": "Claude Haiku 3.5",
-                "created_at": 1729555200,  # 2024-10-22
-            },
-            {
-                "type": "model",
-                "id": "claude-3-5-sonnet-20240620",
-                "display_name": "Claude Sonnet 3.5 (Old)",
-                "created_at": 1718841600,  # 2024-06-20
-            },
-            {
-                "type": "model",
-                "id": "claude-3-haiku-20240307",
-                "display_name": "Claude Haiku 3",
-                "created_at": 1709769600,  # 2024-03-07
-            },
-            {
-                "type": "model",
-                "id": "claude-3-opus-20240229",
-                "display_name": "Claude Opus 3",
-                "created_at": 1709164800,  # 2024-02-29
-            },
-        ]
-
-        # Define recent OpenAI models to include (GPT-4 variants and O1 models)
-        openai_models = [
-            {
-                "id": "gpt-4o",
-                "object": "model",
-                "created": 1715367049,
-                "owned_by": "openai",
-            },
-            {
-                "id": "gpt-4o-mini",
-                "object": "model",
-                "created": 1721172741,
-                "owned_by": "openai",
-            },
-            {
-                "id": "gpt-4-turbo",
-                "object": "model",
-                "created": 1712361441,
-                "owned_by": "openai",
-            },
-            {
-                "id": "gpt-4-turbo-preview",
-                "object": "model",
-                "created": 1706037777,
-                "owned_by": "openai",
-            },
-            {
-                "id": "o1",
-                "object": "model",
-                "created": 1734375816,
-                "owned_by": "openai",
-            },
-            {
-                "id": "o1-mini",
-                "object": "model",
-                "created": 1725649008,
-                "owned_by": "openai",
-            },
-            {
-                "id": "o1-preview",
-                "object": "model",
-                "created": 1725648897,
-                "owned_by": "openai",
-            },
-            {
-                "id": "o3",
-                "object": "model",
-                "created": 1744225308,
-                "owned_by": "openai",
-            },
-            {
-                "id": "o3-mini",
-                "object": "model",
-                "created": 1737146383,
-                "owned_by": "openai",
-            },
-        ]
-
-        # Combine models - mixed format with both Anthropic and OpenAI fields
-        combined_response = {
-            "data": anthropic_models + openai_models,
-            "has_more": False,
-            "object": "list",  # Add OpenAI-style field
-        }
-
-        # Serialize response
-        response_body = json.dumps(combined_response).encode("utf-8")
-
-        # Create response headers
-        response_headers = {
-            "content-type": "application/json",
-            "content-length": str(len(response_body)),
-        }
-
-        return 200, response_headers, response_body
-
     async def close(self) -> None:
         """Close any resources held by the proxy service."""
         if self.proxy_client:

ccproxy/testing/config.py

@@ -1,6 +1,6 @@
 """Configuration models for testing utilities."""
 
-from datetime import UTC, datetime
+from datetime import datetime
 from pathlib import Path
 from typing import Any, Literal
 

ccproxy/testing/mock_responses.py

@@ -1,6 +1,5 @@
 """Mock response generation for realistic testing."""
 
-import json
 import random
 import time
 from typing import Any