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

ccproxy/{pricing → plugins/pricing}/updater.py

@@ -1,18 +1,21 @@
 """Pricing updater for managing periodic refresh of pricing data."""
 
-from decimal import Decimal
+import json
+import time
 from typing import Any
 
-from structlog import get_logger
+import httpx
+from pydantic import ValidationError
 
-from ccproxy.config.pricing import PricingSettings
+from ccproxy.core.logging import get_plugin_logger
 
 from .cache import PricingCache
+from .config import PricingConfig
 from .loader import PricingLoader
 from .models import PricingData
 
 
-logger = get_logger(__name__)
+logger = get_plugin_logger(__name__)
 
 
 class PricingUpdater:
@@ -21,7 +24,7 @@ class PricingUpdater:
     def __init__(
         self,
         cache: PricingCache,
-        settings: PricingSettings,
+        settings: PricingConfig,
     ) -> None:
         """Initialize pricing updater.
 
@@ -47,8 +50,6 @@ class PricingUpdater:
         Returns:
             Current pricing data as PricingData model
         """
-        import time
-
         current_time = time.time()
 
         # Return cached pricing if recent and not forced
@@ -76,7 +77,7 @@ class PricingUpdater:
         )
 
         if should_refresh:
-            logger.info("pricing_refresh_start")
+            logger.debug("pricing_refresh_start")
             await self._refresh_pricing()
 
         # Load pricing data
@@ -115,7 +116,7 @@ class PricingUpdater:
             True if refresh was successful
         """
         try:
-            logger.info("pricing_refresh_start")
+            logger.debug("pricing_refresh_start")
 
             # Download fresh data
             raw_data = await self.cache.download_pricing_data()
@@ -128,11 +129,26 @@ class PricingUpdater:
                 logger.error("cache_save_failed")
                 return False
 
-            logger.info("pricing_refresh_completed")
+            logger.debug("pricing_refresh_completed")
             return True
 
+        except httpx.TimeoutException as e:
+            logger.error("pricing_refresh_timeout", error=str(e), exc_info=e)
+            return False
+        except httpx.HTTPError as e:
+            logger.error("pricing_refresh_http_error", error=str(e), exc_info=e)
+            return False
+        except json.JSONDecodeError as e:
+            logger.error("pricing_refresh_json_error", error=str(e), exc_info=e)
+            return False
+        except ValidationError as e:
+            logger.error("pricing_refresh_validation_error", error=str(e), exc_info=e)
+            return False
+        except OSError as e:
+            logger.error("pricing_refresh_io_error", error=str(e), exc_info=e)
+            return False
         except Exception as e:
-            logger.error("pricing_refresh_failed", error=str(e))
+            logger.error("pricing_refresh_failed", error=str(e), exc_info=e)
             return False
 
     async def _load_pricing_data(self) -> PricingData | None:
@@ -146,7 +162,13 @@ class PricingUpdater:
 
         if raw_data is not None:
             # Load and validate pricing data using Pydantic
-            pricing_data = PricingLoader.load_pricing_from_data(raw_data, verbose=False)
+            # Use the configured provider setting (defaults to "all")
+            pricing_data = PricingLoader.load_pricing_from_data(
+                raw_data,
+                provider=self.settings.pricing_provider,
+                map_to_claude=False,  # Don't map OpenAI models to Claude
+                verbose=False,
+            )
 
             if pricing_data:
                 # Get cache info to display age
@@ -154,69 +176,21 @@ class PricingUpdater:
                 age_hours = cache_info.get("age_hours")
 
                 if age_hours is not None:
-                    logger.info(
+                    logger.debug(
                         "pricing_loaded_from_external",
                         model_count=len(pricing_data),
                         cache_age_hours=round(age_hours, 2),
                     )
                 else:
-                    logger.info(
+                    logger.debug(
                         "pricing_loaded_from_external", model_count=len(pricing_data)
                     )
                 return pricing_data
             else:
                 logger.warning("external_pricing_validation_failed")
 
-        # Fallback to embedded pricing
-        if self.settings.fallback_to_embedded:
-            logger.info("using_embedded_pricing_fallback")
-            return self._get_embedded_pricing()
-        else:
-            logger.error("pricing_unavailable_no_fallback")
-            return None
-
-    def _get_embedded_pricing(self) -> PricingData:
-        """Get embedded (hardcoded) pricing as fallback.
-
-        Returns:
-            Embedded pricing data as PricingData model
-        """
-        # This is the current hardcoded pricing from CostCalculator
-        embedded_data = {
-            "claude-3-5-sonnet-20241022": {
-                "input": Decimal("3.00"),
-                "output": Decimal("15.00"),
-                "cache_read": Decimal("0.30"),
-                "cache_write": Decimal("3.75"),
-            },
-            "claude-3-5-haiku-20241022": {
-                "input": Decimal("0.25"),
-                "output": Decimal("1.25"),
-                "cache_read": Decimal("0.03"),
-                "cache_write": Decimal("0.30"),
-            },
-            "claude-3-opus-20240229": {
-                "input": Decimal("15.00"),
-                "output": Decimal("75.00"),
-                "cache_read": Decimal("1.50"),
-                "cache_write": Decimal("18.75"),
-            },
-            "claude-3-sonnet-20240229": {
-                "input": Decimal("3.00"),
-                "output": Decimal("15.00"),
-                "cache_read": Decimal("0.30"),
-                "cache_write": Decimal("3.75"),
-            },
-            "claude-3-haiku-20240307": {
-                "input": Decimal("0.25"),
-                "output": Decimal("1.25"),
-                "cache_read": Decimal("0.03"),
-                "cache_write": Decimal("0.30"),
-            },
-        }
-
-        # Create PricingData from embedded data
-        return PricingData.from_dict(embedded_data)
+        logger.error("pricing_unavailable_no_fallback")
+        return None
 
     async def force_refresh(self) -> bool:
         """Force a refresh of pricing data.
@@ -268,7 +242,6 @@ class PricingUpdater:
             "models_loaded": len(pricing_data) if pricing_data else 0,
             "model_names": pricing_data.model_names() if pricing_data else [],
             "auto_update": self.settings.auto_update,
-            "fallback_to_embedded": self.settings.fallback_to_embedded,
             "has_cached_pricing": self._cached_pricing is not None,
         }
 
@@ -286,14 +259,30 @@ class PricingUpdater:
             if raw_data is None:
                 return False
 
-            # Try to parse Claude models
-            claude_models = PricingLoader.extract_claude_models(raw_data)
-            if not claude_models:
-                logger.warning("claude_models_not_found_in_external")
-                return False
+            # Try to extract models based on configured provider
+            if self.settings.pricing_provider == "claude":
+                models = PricingLoader.extract_claude_models(raw_data)
+                if not models:
+                    logger.warning("claude_models_not_found_in_external")
+                    return False
+            else:
+                models = PricingLoader.extract_models_by_provider(
+                    raw_data, provider=self.settings.pricing_provider
+                )
+                if not models:
+                    logger.warning(
+                        "models_not_found_in_external",
+                        provider=self.settings.pricing_provider,
+                    )
+                    return False
 
             # Try to load and validate using Pydantic
-            pricing_data = PricingLoader.load_pricing_from_data(raw_data, verbose=False)
+            pricing_data = PricingLoader.load_pricing_from_data(
+                raw_data,
+                provider=self.settings.pricing_provider,
+                map_to_claude=False,
+                verbose=False,
+            )
             if not pricing_data:
                 logger.warning("external_pricing_load_failed")
                 return False
@@ -303,6 +292,31 @@ class PricingUpdater:
             )
             return True
 
+        except httpx.TimeoutException as e:
+            logger.error(
+                "external_pricing_validation_timeout", error=str(e), exc_info=e
+            )
+            return False
+        except httpx.HTTPError as e:
+            logger.error(
+                "external_pricing_validation_http_error", error=str(e), exc_info=e
+            )
+            return False
+        except json.JSONDecodeError as e:
+            logger.error(
+                "external_pricing_validation_json_error", error=str(e), exc_info=e
+            )
+            return False
+        except ValidationError as e:
+            logger.error(
+                "external_pricing_validation_validation_error", error=str(e), exc_info=e
+            )
+            return False
+        except OSError as e:
+            logger.error(
+                "external_pricing_validation_io_error", error=str(e), exc_info=e
+            )
+            return False
         except Exception as e:
-            logger.error("external_pricing_validation_failed", error=str(e))
+            logger.error("external_pricing_validation_failed", error=str(e), exc_info=e)
             return False

ccproxy/plugins/pricing/utils.py

@@ -0,0 +1,99 @@
+"""Cost calculation utilities for token-based pricing (plugin-owned).
+
+These helpers live inside the pricing plugin to avoid coupling core to
+pricing logic. They accept an optional PricingService instance for callers
+that already have one; otherwise they create a default service on demand.
+"""
+
+from __future__ import annotations
+
+from .config import PricingConfig
+from .service import PricingService
+
+
+async def calculate_token_cost(
+    tokens_input: int | None,
+    tokens_output: int | None,
+    model: str | None,
+    cache_read_tokens: int | None = None,
+    cache_write_tokens: int | None = None,
+    pricing_service: PricingService | None = None,
+) -> float | None:
+    """Calculate total cost in USD for the given token usage.
+
+    If no pricing_service is provided, a default PricingService is created
+    using PricingConfig(). Returns None if model or tokens are missing or if
+    pricing information is unavailable.
+    """
+    if not model or (
+        not tokens_input
+        and not tokens_output
+        and not cache_read_tokens
+        and not cache_write_tokens
+    ):
+        return None
+
+    service = pricing_service or PricingService(PricingConfig())
+
+    try:
+        cost_decimal = await service.calculate_cost(
+            model_name=model,
+            input_tokens=tokens_input or 0,
+            output_tokens=tokens_output or 0,
+            cache_read_tokens=cache_read_tokens or 0,
+            cache_write_tokens=cache_write_tokens or 0,
+        )
+        return float(cost_decimal) if cost_decimal is not None else None
+    except Exception:
+        return None
+
+
+async def calculate_cost_breakdown(
+    tokens_input: int | None,
+    tokens_output: int | None,
+    model: str | None,
+    cache_read_tokens: int | None = None,
+    cache_write_tokens: int | None = None,
+    pricing_service: PricingService | None = None,
+) -> dict[str, float | str] | None:
+    """Return a detailed cost breakdown using current pricing data.
+
+    If no pricing_service is provided, a default PricingService is created.
+    Returns None if inputs are insufficient or model pricing is unavailable.
+    """
+    if not model or (
+        not tokens_input
+        and not tokens_output
+        and not cache_read_tokens
+        and not cache_write_tokens
+    ):
+        return None
+
+    service = pricing_service or PricingService(PricingConfig())
+
+    try:
+        model_pricing = await service.get_model_pricing(model)
+        if not model_pricing:
+            return None
+
+        input_cost = ((tokens_input or 0) / 1_000_000) * float(model_pricing.input)
+        output_cost = ((tokens_output or 0) / 1_000_000) * float(model_pricing.output)
+        cache_read_cost = ((cache_read_tokens or 0) / 1_000_000) * float(
+            model_pricing.cache_read
+        )
+        cache_write_cost = ((cache_write_tokens or 0) / 1_000_000) * float(
+            model_pricing.cache_write
+        )
+
+        total_cost = input_cost + output_cost + cache_read_cost + cache_write_cost
+
+        return {
+            "input_cost": input_cost,
+            "output_cost": output_cost,
+            "cache_read_cost": cache_read_cost,
+            "cache_write_cost": cache_write_cost,
+            "total_cost": total_cost,
+            "model": model,
+        }
+    except Exception:
+        return None

ccproxy/plugins/request_tracer/README.md

@@ -0,0 +1,40 @@
+# Request Tracer Plugin
+
+Captures detailed request and response traces for troubleshooting.
+
+## Highlights
+- Registers both the core HTTP tracer and contextual request hook handlers
+- Writes JSON or raw HTTP logs with size and path filtering controls
+- Validates configuration and reports issues through structured logs
+
+## Configuration
+- `RequestTracerConfig` toggles enablement, formats, filters, and log targets
+- Hook registration occurs only when a hook registry is available
+- Generate defaults with `python3 scripts/generate_config_from_model.py \
+  --format toml --plugin request_tracer --config-class RequestTracerConfig`
+
+```toml
+[plugins.request_tracer]
+# enabled = true
+# verbose_api = true
+# json_logs_enabled = true
+# raw_http_enabled = true
+# trace_oauth = true
+# log_dir = "/tmp/ccproxy/traces"
+# exclude_paths = ["/health", "/metrics", "/readyz", "/livez"]
+# include_paths = []
+# exclude_headers = ["authorization", "x-api-key", "cookie", "x-auth-token"]
+# redact_sensitive = true
+# max_body_size = 10485760
+# truncate_body_preview = 1024
+# log_client_request = true
+# log_client_response = true
+# log_provider_request = true
+# log_provider_response = true
+# log_streaming_chunks = false
+```
+
+## Related Components
+- `hook.py`: handles request lifecycle events and formatting
+- `plugin.py`: runtime validation and hook wiring
+- `config.py`: settings model for log output options

ccproxy/plugins/request_tracer/__init__.py

@@ -0,0 +1,7 @@
+"""Request Tracer plugin for request tracing."""
+
+from .config import RequestTracerConfig
+from .hook import RequestTracerHook
+
+
+__all__ = ["RequestTracerConfig", "RequestTracerHook"]

ccproxy/plugins/request_tracer/config.py

@@ -0,0 +1,120 @@
+"""Configuration for the RequestTracer plugin."""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class RequestTracerConfig(BaseModel):
+    """Unified configuration for request tracing.
+
+    Combines structured JSON tracing (from core_tracer) and raw HTTP logging
+    (from raw_http_logger) into a single configuration.
+    """
+
+    # Enable/disable entire plugin
+    enabled: bool = Field(
+        default=True, description="Enable or disable the request tracer plugin"
+    )
+
+    # Structured tracing (from core_tracer)
+    verbose_api: bool = Field(
+        default=True,
+        description="Enable verbose API logging with structured JSON output",
+    )
+    json_logs_enabled: bool = Field(
+        default=True, description="Enable structured JSON logging to files"
+    )
+
+    # Raw HTTP logging (from raw_http_logger)
+    raw_http_enabled: bool = Field(
+        default=True, description="Enable raw HTTP protocol logging"
+    )
+
+    # OAuth tracing
+    trace_oauth: bool = Field(
+        default=True,
+        description="Enable OAuth request/response tracing for CLI operations",
+    )
+
+    # Directory configuration
+    log_dir: str = Field(
+        default="/tmp/ccproxy/traces", description="Base directory for all trace logs"
+    )
+    request_log_dir: str | None = Field(
+        default=None,
+        description="Override directory for structured JSON logs (defaults to log_dir)",
+    )
+    raw_log_dir: str | None = Field(
+        default=None,
+        description="Override directory for raw HTTP logs (defaults to log_dir/raw)",
+    )
+
+    # Request filtering
+    exclude_paths: list[str] = Field(
+        default_factory=lambda: ["/health", "/metrics", "/readyz", "/livez"],
+        description="Request paths to exclude from tracing",
+    )
+    include_paths: list[str] = Field(
+        default_factory=list, description="If specified, only trace these paths"
+    )
+
+    # Privacy & security
+    exclude_headers: list[str] = Field(
+        default_factory=lambda: [
+            "authorization",
+            "x-api-key",
+            "cookie",
+            "x-auth-token",
+        ],
+        description="Headers to redact in raw logs",
+    )
+    redact_sensitive: bool = Field(
+        default=True, description="Redact sensitive data in structured logs"
+    )
+
+    # Performance settings
+    max_body_size: int = Field(
+        default=10485760,  # 10MB
+        description="Maximum body size to log (bytes)",
+    )
+    truncate_body_preview: int = Field(
+        default=1024,
+        description="Maximum body preview size for structured logs (chars)",
+    )
+
+    # Granular control
+    log_client_request: bool = Field(default=True, description="Log client requests")
+    log_client_response: bool = Field(default=True, description="Log client responses")
+    log_provider_request: bool = Field(
+        default=True, description="Log provider requests"
+    )
+    log_provider_response: bool = Field(
+        default=True, description="Log provider responses"
+    )
+
+    # Streaming configuration
+    log_streaming_chunks: bool = Field(
+        default=False, description="Log individual streaming chunks (verbose)"
+    )
+
+    model_config = ConfigDict()
+
+    def get_json_log_dir(self) -> str:
+        """Get directory for structured JSON logs."""
+        return self.request_log_dir or self.log_dir
+
+    def get_raw_log_dir(self) -> str:
+        """Get directory for raw HTTP logs."""
+        return self.raw_log_dir or self.log_dir
+
+    def should_trace_path(self, path: str) -> bool:
+        """Check if a path should be traced based on include/exclude rules."""
+        # First check exclude_paths (takes precedence)
+        if any(path.startswith(exclude) for exclude in self.exclude_paths):
+            return False
+
+        # Then check include_paths (if specified, only log included paths)
+        if self.include_paths:
+            return any(path.startswith(include) for include in self.include_paths)
+
+        # Default: trace all paths not explicitly excluded
+        return True