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

ccproxy/observability/context.py

@@ -21,7 +21,8 @@ import uuid
 from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
-from typing import Any, Optional
+from datetime import UTC, datetime
+from typing import Any
 
 import structlog
 
@@ -43,6 +44,7 @@ class RequestContext:
     logger: structlog.BoundLogger
     metadata: dict[str, Any] = field(default_factory=dict)
     storage: Any | None = None  # Optional DuckDB storage instance
+    log_timestamp: datetime | None = None  # Datetime for consistent logging filenames
 
     @property
     def duration_ms(self) -> float:
@@ -66,12 +68,25 @@ class RequestContext:
             event, request_id=self.request_id, duration_ms=self.duration_ms, **kwargs
         )
 
+    def get_log_timestamp_prefix(self) -> str:
+        """Get timestamp prefix for consistent log filenames.
+
+        Returns:
+            Timestamp string in YYYYMMDDhhmmss format (UTC)
+        """
+        if self.log_timestamp:
+            return self.log_timestamp.strftime("%Y%m%d%H%M%S")
+        else:
+            # Fallback to current time if not set
+            return datetime.now(UTC).strftime("%Y%m%d%H%M%S")
+
 
 @asynccontextmanager
 async def request_context(
     request_id: str | None = None,
     storage: Any | None = None,
     metrics: Any | None = None,
+    log_timestamp: datetime | None = None,
     **initial_context: Any,
 ) -> AsyncGenerator[RequestContext, None]:
     """
@@ -124,6 +139,7 @@ async def request_context(
         logger=request_logger,
         metadata=dict(initial_context),
         storage=storage,
+        log_timestamp=log_timestamp,
     )
 
     try:

ccproxy/observability/metrics.py

@@ -15,9 +15,7 @@ Key features:
 
 from __future__ import annotations
 
-import asyncio
-import logging
-from typing import Any, Optional, Union
+from typing import Any
 
 
 try:

ccproxy/observability/pushgateway.py

@@ -2,8 +2,6 @@
 
 from __future__ import annotations
 
-import asyncio
-import random
 import time
 from typing import Any
 

ccproxy/observability/stats_printer.py

@@ -9,10 +9,9 @@ from __future__ import annotations
 
 import json
 import time
-from collections.abc import Callable
 from dataclasses import dataclass
-from datetime import datetime, timedelta
-from typing import Any, Optional
+from datetime import datetime
+from typing import Any
 
 import structlog
 
@@ -524,7 +523,6 @@ class StatsCollector:
             from rich import box
             from rich.console import Console
             from rich.table import Table
-            from rich.text import Text
 
             output_buffer = StringIO()
             console = Console(file=output_buffer, width=80, force_terminal=True)

ccproxy/observability/storage/duckdb_simple.py

@@ -10,7 +10,7 @@ import time
 from collections.abc import Sequence
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 import structlog
 from sqlalchemy import text

ccproxy/observability/storage/models.py

@@ -6,7 +6,6 @@ using SQLModel to ensure type safety and eliminate column name repetition.
 """
 
 from datetime import datetime
-from typing import Optional
 
 from sqlmodel import Field, SQLModel
 

ccproxy/pricing/cache.py

@@ -2,7 +2,6 @@
 
 import json
 import time
-from pathlib import Path
 from typing import Any
 
 import httpx

ccproxy/pricing/loader.py

@@ -6,6 +6,8 @@ from typing import Any
 from pydantic import ValidationError
 from structlog import get_logger
 
+from ccproxy.utils.model_mapping import get_claude_aliases_mapping, map_model_to_claude
+
 from .models import PricingData
 
 
@@ -15,22 +17,6 @@ logger = get_logger(__name__)
 class PricingLoader:
     """Loads and converts pricing data from LiteLLM format to internal format."""
 
-    # Claude model name mappings for different versions
-    CLAUDE_MODEL_MAPPINGS = {
-        # Map versioned models to their canonical names
-        "claude-3-5-sonnet-latest": "claude-3-5-sonnet-20241022",
-        "claude-3-5-sonnet-20240620": "claude-3-5-sonnet-20240620",
-        "claude-3-5-sonnet-20241022": "claude-3-5-sonnet-20241022",
-        "claude-3-5-haiku-latest": "claude-3-5-haiku-20241022",
-        "claude-3-5-haiku-20241022": "claude-3-5-haiku-20241022",
-        "claude-3-opus": "claude-3-opus-20240229",
-        "claude-3-opus-20240229": "claude-3-opus-20240229",
-        "claude-3-sonnet": "claude-3-sonnet-20240229",
-        "claude-3-sonnet-20240229": "claude-3-sonnet-20240229",
-        "claude-3-haiku": "claude-3-haiku-20240307",
-        "claude-3-haiku-20240307": "claude-3-haiku-20240307",
-    }
-
     @staticmethod
     def extract_claude_models(
         litellm_data: dict[str, Any], verbose: bool = True
@@ -112,9 +98,7 @@ class PricingLoader:
                     pricing["cache_read"] = Decimal(str(cache_read_cost * 1_000_000))
 
                 # Map to canonical model name if needed
-                canonical_name = PricingLoader.CLAUDE_MODEL_MAPPINGS.get(
-                    model_name, model_name
-                )
+                canonical_name = map_model_to_claude(model_name)
                 internal_format[canonical_name] = pricing
 
                 if verbose:
@@ -252,7 +236,7 @@ class PricingLoader:
         Returns:
             Dictionary mapping aliases to canonical model names
         """
-        return PricingLoader.CLAUDE_MODEL_MAPPINGS.copy()
+        return get_claude_aliases_mapping()
 
     @staticmethod
     def get_canonical_model_name(model_name: str) -> str:
@@ -264,4 +248,4 @@ class PricingLoader:
         Returns:
             Canonical model name
         """
-        return PricingLoader.CLAUDE_MODEL_MAPPINGS.get(model_name, model_name)
+        return map_model_to_claude(model_name)

ccproxy/pricing/updater.py

@@ -1,6 +1,5 @@
 """Pricing updater for managing periodic refresh of pricing data."""
 
-import asyncio
 from decimal import Decimal
 from typing import Any
 

ccproxy/scheduler/__init__.py

@@ -32,6 +32,7 @@ from .tasks import (
 __all__ = [
     "Scheduler",
     "TaskRegistry",
+    "register_task",
     "BaseScheduledTask",
     "PushgatewayTask",
     "StatsPrintingTask",

ccproxy/scheduler/core.py

@@ -5,7 +5,7 @@ from typing import Any
 
 import structlog
 
-from .exceptions import (
+from .errors import (
     SchedulerError,
     SchedulerShutdownError,
     TaskNotFoundError,
@@ -60,7 +60,7 @@ class Scheduler:
         self._running = True
         self._semaphore = asyncio.Semaphore(self.max_concurrent_tasks)
 
-        logger.info(
+        logger.debug(
             "scheduler_starting",
             max_concurrent_tasks=self.max_concurrent_tasks,
             registered_tasks=self.task_registry.list_tasks(),
@@ -68,7 +68,7 @@ class Scheduler:
 
         try:
             # No automatic task creation - tasks must be explicitly added
-            logger.info(
+            logger.debug(
                 "scheduler_started",
                 active_tasks=len(self._tasks),
                 running_tasks=[
@@ -129,7 +129,7 @@ class Scheduler:
                 ) from e
 
         self._tasks.clear()
-        logger.info("scheduler_stopped")
+        logger.debug("scheduler_stopped")
 
     async def add_task(
         self,
@@ -166,13 +166,13 @@ class Scheduler:
             # Start the task if scheduler is running and task is enabled
             if self._running and task_instance.enabled:
                 await task_instance.start()
-                logger.info(
+                logger.debug(
                     "task_added_and_started",
                     task_name=task_name,
                     task_type=task_type,
                 )
             else:
-                logger.info(
+                logger.debug(
                     "task_added_not_started",
                     task_name=task_name,
                     task_type=task_type,

ccproxy/scheduler/manager.py

@@ -1,15 +1,17 @@
 """Scheduler management for FastAPI integration."""
 
-import asyncio
-from typing import Any
-
 import structlog
 
 from ccproxy.config.settings import Settings
 
-from .core import Scheduler, get_scheduler
+from .core import Scheduler
 from .registry import register_task
-from .tasks import PricingCacheUpdateTask, PushgatewayTask, StatsPrintingTask
+from .tasks import (
+    PricingCacheUpdateTask,
+    PushgatewayTask,
+    StatsPrintingTask,
+    VersionUpdateCheckTask,
+)
 
 
 logger = structlog.get_logger(__name__)
@@ -83,7 +85,7 @@ async def setup_scheduler_tasks(scheduler: Scheduler, settings: Settings) -> Non
                 enabled=True,
                 force_refresh_on_startup=scheduler_config.pricing_force_refresh_on_startup,
             )
-            logger.info(
+            logger.debug(
                 "pricing_update_task_added",
                 interval_hours=scheduler_config.pricing_update_interval_hours,
                 force_refresh_on_startup=scheduler_config.pricing_force_refresh_on_startup,
@@ -95,6 +97,31 @@ async def setup_scheduler_tasks(scheduler: Scheduler, settings: Settings) -> Non
                 error_type=type(e).__name__,
             )
 
+    # Add version update check task if enabled
+    if scheduler_config.version_check_enabled:
+        try:
+            # Convert hours to seconds
+            interval_seconds = scheduler_config.version_check_interval_hours * 3600
+
+            await scheduler.add_task(
+                task_name="version_update_check",
+                task_type="version_update_check",
+                interval_seconds=interval_seconds,
+                enabled=True,
+                startup_max_age_hours=scheduler_config.version_check_startup_max_age_hours,
+            )
+            logger.debug(
+                "version_check_task_added",
+                interval_hours=scheduler_config.version_check_interval_hours,
+                startup_max_age_hours=scheduler_config.version_check_startup_max_age_hours,
+            )
+        except Exception as e:
+            logger.error(
+                "version_check_task_add_failed",
+                error=str(e),
+                error_type=type(e).__name__,
+            )
+
 
 def _register_default_tasks() -> None:
     """Register default task types in the global registry."""
@@ -109,6 +136,8 @@ def _register_default_tasks() -> None:
         register_task("stats_printing", StatsPrintingTask)
     if not registry.is_registered("pricing_cache_update"):
         register_task("pricing_cache_update", PricingCacheUpdateTask)
+    if not registry.is_registered("version_update_check"):
+        register_task("version_update_check", VersionUpdateCheckTask)
 
 
 async def start_scheduler(settings: Settings) -> Scheduler | None:
@@ -177,7 +206,6 @@ async def stop_scheduler(scheduler: Scheduler | None) -> None:
 
     try:
         await scheduler.stop()
-        logger.info("scheduler_stopped")
     except Exception as e:
         logger.error(
             "scheduler_stop_failed",

ccproxy/scheduler/registry.py

@@ -4,7 +4,7 @@ from typing import Any
 
 import structlog
 
-from .exceptions import TaskRegistrationError
+from .errors import TaskRegistrationError
 from .tasks import BaseScheduledTask
 
 

ccproxy/scheduler/tasks.py

@@ -5,12 +5,11 @@ import contextlib
 import random
 import time
 from abc import ABC, abstractmethod
+from datetime import UTC
 from typing import Any
 
 import structlog
 
-from .exceptions import TaskExecutionError
-
 
 logger = structlog.get_logger(__name__)
 
@@ -482,3 +481,129 @@ class PricingCacheUpdateTask(BaseScheduledTask):
                 error_type=type(e).__name__,
             )
             return False
+
+
+class VersionUpdateCheckTask(BaseScheduledTask):
+    """Task for checking version updates periodically."""
+
+    def __init__(
+        self,
+        name: str,
+        interval_seconds: float,
+        enabled: bool = True,
+        startup_max_age_hours: float = 1.0,
+    ):
+        """
+        Initialize version update check task.
+
+        Args:
+            name: Task name
+            interval_seconds: Interval between version checks
+            enabled: Whether task is enabled
+            startup_max_age_hours: Maximum age in hours before running startup check
+        """
+        super().__init__(
+            name=name,
+            interval_seconds=interval_seconds,
+            enabled=enabled,
+        )
+        self.startup_max_age_hours = startup_max_age_hours
+        self._first_run = True
+
+    async def run(self) -> bool:
+        """Execute version update check."""
+        try:
+            from datetime import datetime
+
+            from ccproxy.utils.version_checker import (
+                VersionCheckState,
+                compare_versions,
+                fetch_latest_github_version,
+                get_current_version,
+                get_version_check_state_path,
+                load_check_state,
+                save_check_state,
+            )
+
+            state_path = get_version_check_state_path()
+            current_time = datetime.now(UTC)
+
+            # Check if we should run based on startup logic
+            if self._first_run:
+                self._first_run = False
+                should_run_startup_check = False
+
+                # Load existing state if available
+                existing_state = await load_check_state(state_path)
+                if existing_state:
+                    # Check age of last check
+                    time_diff = current_time - existing_state.last_check_at
+                    age_hours = time_diff.total_seconds() / 3600
+
+                    if age_hours > self.startup_max_age_hours:
+                        should_run_startup_check = True
+                        logger.debug(
+                            "version_check_startup_needed",
+                            task_name=self.name,
+                            age_hours=age_hours,
+                            max_age_hours=self.startup_max_age_hours,
+                        )
+                    else:
+                        logger.debug(
+                            "version_check_startup_skipped",
+                            task_name=self.name,
+                            age_hours=age_hours,
+                            max_age_hours=self.startup_max_age_hours,
+                        )
+                        return True  # Skip this run
+                else:
+                    # No previous state, run check
+                    should_run_startup_check = True
+                    logger.debug("version_check_startup_no_state", task_name=self.name)
+
+                if not should_run_startup_check:
+                    return True
+
+            # Fetch latest version from GitHub
+            latest_version = await fetch_latest_github_version()
+            if latest_version is None:
+                logger.warning("version_check_fetch_failed", task_name=self.name)
+                return False
+
+            # Get current version
+            current_version = get_current_version()
+
+            # Save state
+            new_state = VersionCheckState(
+                last_check_at=current_time,
+                latest_version_found=latest_version,
+            )
+            await save_check_state(state_path, new_state)
+
+            # Compare versions
+            if compare_versions(current_version, latest_version):
+                logger.info(
+                    "version_update_available",
+                    task_name=self.name,
+                    current_version=current_version,
+                    latest_version=latest_version,
+                    message=f"New version {latest_version} available! You are running {current_version}",
+                )
+            else:
+                logger.debug(
+                    "version_check_complete_no_update",
+                    task_name=self.name,
+                    current_version=current_version,
+                    latest_version=latest_version,
+                )
+
+            return True
+
+        except Exception as e:
+            logger.error(
+                "version_check_task_error",
+                task_name=self.name,
+                error=str(e),
+                error_type=type(e).__name__,
+            )
+            return False