ccproxy-api 0.1.6__py3-none-any.whl → 0.2.0__py3-none-any.whl

ccproxy/utils/simple_request_logger.py

@@ -1,284 +0,0 @@
-"""Simple request logging utility for content logging across all service layers."""
-
-import asyncio
-import json
-import os
-from datetime import UTC, datetime
-from pathlib import Path
-from typing import Any
-
-import structlog
-
-
-logger = structlog.get_logger(__name__)
-
-# Global batching settings for streaming logs
-_STREAMING_BATCH_SIZE = 8192  # Batch chunks until we have 8KB
-_STREAMING_BATCH_TIMEOUT = 0.1  # Or flush after 100ms
-_streaming_batches: dict[str, dict[str, Any]] = {}  # request_id -> batch info
-
-
-def should_log_requests() -> bool:
-    """Check if request logging is enabled via environment variable.
-
-    Returns:
-        True if CCPROXY_LOG_REQUESTS is set to 'true' (case-insensitive)
-    """
-    return os.environ.get("CCPROXY_LOG_REQUESTS", "false").lower() == "true"
-
-
-def get_request_log_dir() -> Path | None:
-    """Get the request log directory from environment variable.
-
-    Returns:
-        Path object if CCPROXY_REQUEST_LOG_DIR is set and valid, None otherwise
-    """
-    log_dir = os.environ.get("CCPROXY_REQUEST_LOG_DIR")
-    if not log_dir:
-        return None
-
-    path = Path(log_dir)
-    try:
-        path.mkdir(parents=True, exist_ok=True)
-        return path
-    except Exception as e:
-        logger.error(
-            "failed_to_create_request_log_dir",
-            log_dir=log_dir,
-            error=str(e),
-        )
-        return None
-
-
-def get_timestamp_prefix() -> str:
-    """Generate timestamp prefix in YYYYMMDDhhmmss format.
-
-    Returns:
-        Timestamp string in YYYYMMDDhhmmss format (UTC)
-    """
-    return datetime.now(UTC).strftime("%Y%m%d%H%M%S")
-
-
-async def write_request_log(
-    request_id: str,
-    log_type: str,
-    data: dict[str, Any],
-    timestamp: str | None = None,
-) -> None:
-    """Write request/response data to JSON file.
-
-    Args:
-        request_id: Unique request identifier
-        log_type: Type of log (e.g., 'middleware_request', 'upstream_response')
-        data: Data to log as JSON
-        timestamp: Optional timestamp prefix (defaults to current time)
-    """
-    if not should_log_requests():
-        return
-
-    log_dir = get_request_log_dir()
-    if not log_dir:
-        return
-
-    timestamp = timestamp or get_timestamp_prefix()
-    filename = f"{timestamp}_{request_id}_{log_type}.json"
-    file_path = log_dir / filename
-
-    try:
-        # Write JSON data to file asynchronously
-        def write_file() -> None:
-            with file_path.open("w", encoding="utf-8") as f:
-                json.dump(data, f, indent=2, default=str, ensure_ascii=False)
-
-        # Run in thread pool to avoid blocking
-        await asyncio.get_event_loop().run_in_executor(None, write_file)
-
-        logger.debug(
-            "request_log_written",
-            request_id=request_id,
-            log_type=log_type,
-            file_path=str(file_path),
-        )
-
-    except Exception as e:
-        logger.error(
-            "failed_to_write_request_log",
-            request_id=request_id,
-            log_type=log_type,
-            file_path=str(file_path),
-            error=str(e),
-        )
-
-
-async def write_streaming_log(
-    request_id: str,
-    log_type: str,
-    data: bytes,
-    timestamp: str | None = None,
-) -> None:
-    """Write streaming data to raw file.
-
-    Args:
-        request_id: Unique request identifier
-        log_type: Type of log (e.g., 'middleware_streaming', 'upstream_streaming')
-        data: Raw bytes to log
-        timestamp: Optional timestamp prefix (defaults to current time)
-    """
-    if not should_log_requests():
-        return
-
-    log_dir = get_request_log_dir()
-    if not log_dir:
-        return
-
-    timestamp = timestamp or get_timestamp_prefix()
-    filename = f"{timestamp}_{request_id}_{log_type}.raw"
-    file_path = log_dir / filename
-
-    try:
-        # Write raw data to file asynchronously
-        def write_file() -> None:
-            with file_path.open("wb") as f:
-                f.write(data)
-
-        # Run in thread pool to avoid blocking
-        await asyncio.get_event_loop().run_in_executor(None, write_file)
-
-        logger.debug(
-            "streaming_log_written",
-            request_id=request_id,
-            log_type=log_type,
-            file_path=str(file_path),
-            data_size=len(data),
-        )
-
-    except Exception as e:
-        logger.error(
-            "failed_to_write_streaming_log",
-            request_id=request_id,
-            log_type=log_type,
-            file_path=str(file_path),
-            error=str(e),
-        )
-
-
-async def append_streaming_log(
-    request_id: str,
-    log_type: str,
-    data: bytes,
-    timestamp: str | None = None,
-) -> None:
-    """Append streaming data using batching for performance.
-
-    Args:
-        request_id: Unique request identifier
-        log_type: Type of log (e.g., 'middleware_streaming', 'upstream_streaming')
-        data: Raw bytes to append
-        timestamp: Optional timestamp prefix (defaults to current time)
-    """
-    if not should_log_requests():
-        return
-
-    log_dir = get_request_log_dir()
-    if not log_dir:
-        return
-
-    timestamp = timestamp or get_timestamp_prefix()
-    batch_key = f"{request_id}_{log_type}"
-
-    # Get or create batch for this request/log_type combination
-    if batch_key not in _streaming_batches:
-        _streaming_batches[batch_key] = {
-            "request_id": request_id,
-            "log_type": log_type,
-            "timestamp": timestamp,
-            "data": bytearray(),
-            "chunk_count": 0,
-            "first_chunk_time": asyncio.get_event_loop().time(),
-            "last_flush_task": None,
-        }
-
-    batch = _streaming_batches[batch_key]
-    batch["data"].extend(data)
-    batch["chunk_count"] += 1
-
-    # Cancel previous flush task if it exists
-    if batch["last_flush_task"] and not batch["last_flush_task"].done():
-        batch["last_flush_task"].cancel()
-
-    # Check if we should flush now
-    should_flush = (
-        len(batch["data"]) >= _STREAMING_BATCH_SIZE
-        or batch["chunk_count"] >= 50  # Max 50 chunks per batch
-    )
-
-    if should_flush:
-        await _flush_streaming_batch(batch_key)
-    else:
-        # Schedule a delayed flush
-        batch["last_flush_task"] = asyncio.create_task(
-            _delayed_flush_streaming_batch(batch_key, _STREAMING_BATCH_TIMEOUT)
-        )
-
-
-async def _delayed_flush_streaming_batch(batch_key: str, delay: float) -> None:
-    """Flush a streaming batch after a delay."""
-    try:
-        await asyncio.sleep(delay)
-        if batch_key in _streaming_batches:
-            await _flush_streaming_batch(batch_key)
-    except asyncio.CancelledError:
-        # Task was cancelled, don't flush
-        pass
-
-
-async def _flush_streaming_batch(batch_key: str) -> None:
-    """Flush a streaming batch to disk."""
-    if batch_key not in _streaming_batches:
-        return
-
-    batch = _streaming_batches.pop(batch_key)
-
-    if not batch["data"]:
-        return  # Nothing to flush
-
-    log_dir = get_request_log_dir()
-    if not log_dir:
-        return
-
-    filename = f"{batch['timestamp']}_{batch['request_id']}_{batch['log_type']}.raw"
-    file_path = log_dir / filename
-
-    try:
-        # Append batched data to file asynchronously
-        def append_file() -> None:
-            with file_path.open("ab") as f:
-                f.write(batch["data"])
-
-        # Run in thread pool to avoid blocking
-        await asyncio.get_event_loop().run_in_executor(None, append_file)
-
-        logger.debug(
-            "streaming_batch_flushed",
-            request_id=batch["request_id"],
-            log_type=batch["log_type"],
-            file_path=str(file_path),
-            batch_size=len(batch["data"]),
-            chunk_count=batch["chunk_count"],
-        )
-
-    except Exception as e:
-        logger.error(
-            "failed_to_flush_streaming_batch",
-            request_id=batch["request_id"],
-            log_type=batch["log_type"],
-            file_path=str(file_path),
-            error=str(e),
-        )
-
-
-async def flush_all_streaming_batches() -> None:
-    """Flush all pending streaming batches. Call this on shutdown."""
-    batch_keys = list(_streaming_batches.keys())
-    for batch_key in batch_keys:
-        await _flush_streaming_batch(batch_key)

ccproxy/utils/streaming_metrics.py

@@ -1,199 +0,0 @@
-"""Streaming metrics extraction utilities.
-
-This module provides utilities for extracting token usage and calculating costs
-from Anthropic streaming responses in a testable, modular way.
-"""
-
-import json
-from typing import Any
-
-import structlog
-
-from ccproxy.models.types import StreamingTokenMetrics, UsageData
-from ccproxy.utils.cost_calculator import calculate_token_cost
-
-
-logger = structlog.get_logger(__name__)
-
-
-def extract_usage_from_streaming_chunk(chunk_data: Any) -> UsageData | None:
-    """Extract usage information from Anthropic streaming response chunk.
-
-    This function looks for usage information in both message_start and message_delta events
-    from Anthropic's streaming API responses. message_start contains initial input tokens,
-    message_delta contains final output tokens.
-
-    Args:
-        chunk_data: Streaming response chunk dictionary
-
-    Returns:
-        UsageData with token counts or None if no usage found
-    """
-    if not isinstance(chunk_data, dict):
-        return None
-
-    chunk_type = chunk_data.get("type")
-
-    # Look for message_start events with initial usage (input tokens)
-    if chunk_type == "message_start" and "message" in chunk_data:
-        message = chunk_data["message"]
-        if "usage" in message:
-            usage = message["usage"]
-            return UsageData(
-                input_tokens=usage.get("input_tokens"),
-                output_tokens=usage.get(
-                    "output_tokens"
-                ),  # Initial output tokens (usually small)
-                cache_read_input_tokens=usage.get("cache_read_input_tokens"),
-                cache_creation_input_tokens=usage.get("cache_creation_input_tokens"),
-                event_type="message_start",
-            )
-
-    # Look for message_delta events with final usage (output tokens)
-    elif chunk_type == "message_delta" and "usage" in chunk_data:
-        usage = chunk_data["usage"]
-        return UsageData(
-            input_tokens=usage.get("input_tokens"),  # Usually None in delta
-            output_tokens=usage.get("output_tokens"),  # Final output token count
-            cache_read_input_tokens=usage.get("cache_read_input_tokens"),
-            cache_creation_input_tokens=usage.get("cache_creation_input_tokens"),
-            event_type="message_delta",
-        )
-
-    return None
-
-
-class StreamingMetricsCollector:
-    """Collects and manages token metrics during streaming responses."""
-
-    def __init__(self, request_id: str | None = None) -> None:
-        """Initialize the metrics collector.
-
-        Args:
-            request_id: Optional request ID for logging context
-        """
-        self.request_id = request_id
-        self.metrics = StreamingTokenMetrics(
-            tokens_input=None,
-            tokens_output=None,
-            cache_read_tokens=None,
-            cache_write_tokens=None,
-            cost_usd=None,
-        )
-
-    def process_chunk(self, chunk_str: str) -> bool:
-        """Process a streaming chunk to extract token metrics.
-
-        Args:
-            chunk_str: Raw chunk string from streaming response
-
-        Returns:
-            True if this was the final chunk with complete metrics, False otherwise
-        """
-        # Check if this chunk contains usage information
-        # Look for usage data in any chunk - the event type will be determined from the JSON
-        if "usage" not in chunk_str:
-            return False
-
-        logger.debug(
-            "Processing chunk with usage",
-            chunk_preview=chunk_str[:300],
-            request_id=self.request_id,
-        )
-
-        try:
-            # Parse SSE data lines to find usage information
-            for line in chunk_str.split("\n"):
-                if line.startswith("data: "):
-                    data_str = line[6:].strip()
-                    if data_str and data_str != "[DONE]":
-                        event_data = json.loads(data_str)
-                        usage_data = extract_usage_from_streaming_chunk(event_data)
-
-                        if usage_data:
-                            event_type = usage_data.get("event_type")
-
-                            # Handle message_start: get input tokens and initial cache tokens
-                            if event_type == "message_start":
-                                self.metrics["tokens_input"] = usage_data.get(
-                                    "input_tokens"
-                                )
-                                self.metrics["cache_read_tokens"] = (
-                                    usage_data.get("cache_read_input_tokens")
-                                    or self.metrics["cache_read_tokens"]
-                                )
-                                self.metrics["cache_write_tokens"] = (
-                                    usage_data.get("cache_creation_input_tokens")
-                                    or self.metrics["cache_write_tokens"]
-                                )
-                                logger.debug(
-                                    "Extracted input tokens from message_start",
-                                    tokens_input=self.metrics["tokens_input"],
-                                    cache_read_tokens=self.metrics["cache_read_tokens"],
-                                    cache_write_tokens=self.metrics[
-                                        "cache_write_tokens"
-                                    ],
-                                    request_id=self.request_id,
-                                )
-                                return False  # Not final yet
-
-                            # Handle message_delta: get final output tokens
-                            elif event_type == "message_delta":
-                                self.metrics["tokens_output"] = usage_data.get(
-                                    "output_tokens"
-                                )
-                                logger.debug(
-                                    "Extracted output tokens from message_delta",
-                                    tokens_output=self.metrics["tokens_output"],
-                                    request_id=self.request_id,
-                                )
-                                return True  # This is the final event
-
-                        break  # Only process first valid data line
-
-        except (json.JSONDecodeError, KeyError) as e:
-            logger.debug(
-                "Failed to parse streaming token metrics",
-                error=str(e),
-                request_id=self.request_id,
-            )
-
-        return False
-
-    def calculate_final_cost(self, model: str | None) -> float | None:
-        """Calculate the final cost based on collected metrics.
-
-        Args:
-            model: Model name for pricing lookup
-
-        Returns:
-            Final cost in USD or None if calculation fails
-        """
-        cost_usd = calculate_token_cost(
-            self.metrics["tokens_input"],
-            self.metrics["tokens_output"],
-            model,
-            self.metrics["cache_read_tokens"],
-            self.metrics["cache_write_tokens"],
-        )
-        self.metrics["cost_usd"] = cost_usd
-
-        logger.debug(
-            "Final streaming token metrics",
-            tokens_input=self.metrics["tokens_input"],
-            tokens_output=self.metrics["tokens_output"],
-            cache_read_tokens=self.metrics["cache_read_tokens"],
-            cache_write_tokens=self.metrics["cache_write_tokens"],
-            cost_usd=cost_usd,
-            request_id=self.request_id,
-        )
-
-        return cost_usd
-
-    def get_metrics(self) -> StreamingTokenMetrics:
-        """Get the current collected metrics.
-
-        Returns:
-            Current token metrics
-        """
-        return self.metrics.copy()