ccproxy-api 0.1.7__py3-none-any.whl → 0.2.0a4__py3-none-any.whl

ccproxy/{observability/context.py → core/request_context.py}

@@ -9,25 +9,34 @@ Key features:
 - Accurate timing measurement using time.perf_counter()
 - Request correlation with unique IDs
 - Structured logging integration
-- Async-safe context management
+- Async-safe context management with contextvars
 - Exception handling and error tracking
 """
 
 from __future__ import annotations
 
 import asyncio
+import json
 import time
 import uuid
 from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
+from contextvars import ContextVar, Token
 from dataclasses import dataclass, field
 from datetime import UTC, datetime
 from typing import Any
 
 import structlog
 
+from ccproxy.core.logging import TraceBoundLogger, get_logger
 
-logger = structlog.get_logger(__name__)
+
+logger = get_logger(__name__)
+
+# Context variable for async-safe request context propagation
+request_context_var: ContextVar[RequestContext | None] = ContextVar(
+    "request_context", default=None
+)
 
 
 @dataclass
@@ -41,10 +50,12 @@ class RequestContext:
 
     request_id: str
     start_time: float
-    logger: structlog.BoundLogger
+    logger: structlog.stdlib.BoundLogger | TraceBoundLogger
     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
+    metrics: dict[str, Any] = field(default_factory=dict)  # Request metrics storage
+    format_chain: list[str] | None = None  # Format conversion chain
 
     @property
     def duration_ms(self) -> float:
@@ -80,6 +91,92 @@ class RequestContext:
             # Fallback to current time if not set
             return datetime.now(UTC).strftime("%Y%m%d%H%M%S")
 
+    def set_current(self) -> Token[RequestContext | None]:
+        """Set this context as the current request context.
+
+        Returns:
+            Token that can be used to restore the previous context
+        """
+        return request_context_var.set(self)
+
+    @staticmethod
+    def get_current() -> RequestContext | None:
+        """Get the current request context from async context.
+
+        Returns:
+            The current RequestContext or None if not set
+        """
+        return request_context_var.get()
+
+    def clear_current(self, token: Token[RequestContext | None]) -> None:
+        """Clear the current context and restore the previous one.
+
+        Args:
+            token: The token returned by set_current()
+        """
+        request_context_var.reset(token)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize the context to a dictionary for JSON logging.
+
+        Returns all context data including:
+        - Request ID and timing information
+        - All metadata (costs, tokens, model, etc.)
+        - All metrics
+        - Computed properties (duration_ms, duration_seconds)
+
+        Excludes non-serializable fields like logger and storage.
+        """
+        # Start with basic fields
+        data = {
+            "request_id": self.request_id,
+            "start_time": self.start_time,
+        }
+
+        # Add computed timing properties
+        try:
+            data["duration_ms"] = self.duration_ms
+            data["duration_seconds"] = self.duration_seconds
+        except Exception:
+            pass
+
+        # Add log timestamp if present
+        if self.log_timestamp:
+            try:
+                data["log_timestamp"] = self.log_timestamp.isoformat()
+            except Exception:
+                data["log_timestamp"] = str(self.log_timestamp)
+
+        # Add all metadata (includes costs, tokens, model info, etc.)
+        if self.metadata:
+            # Try to deep copy metadata to avoid reference issues
+            try:
+                # Ensure metadata is JSON serializable
+                data["metadata"] = json.loads(json.dumps(self.metadata, default=str))
+            except Exception:
+                data["metadata"] = self.metadata
+
+        # Add all metrics
+        if self.metrics:
+            try:
+                # Ensure metrics is JSON serializable
+                data["metrics"] = json.loads(json.dumps(self.metrics, default=str))
+            except Exception:
+                data["metrics"] = self.metrics
+
+        return data
+
+
+async def get_request_event_stream() -> AsyncGenerator[dict[str, Any], None]:
+    """Async generator for request events used by analytics streaming.
+
+    This is a lightweight stub for type-checking and optional runtime use.
+    Integrations can replace or wrap this to provide actual event streams.
+    """
+    # Empty async generator
+    for _ in ():
+        yield {}
+
 
 @asynccontextmanager
 async def request_context(
@@ -125,8 +222,7 @@ async def request_context(
         "request_start", request_id=request_id, timestamp=time.time(), **initial_context
     )
 
-    # Emit SSE event for real-time dashboard updates
-    await _emit_request_start_event(request_id, initial_context)
+    # SSE events removed - functionality moved to plugins
 
     # Increment active requests if metrics provided
     if metrics:
@@ -142,31 +238,31 @@ async def request_context(
         log_timestamp=log_timestamp,
     )
 
+    # Set as current context for async propagation
+    token = ctx.set_current()
+
     try:
         yield ctx
 
         # Log successful completion with comprehensive access log
         duration_ms = ctx.duration_ms
 
-        # Use the new unified access logger for comprehensive logging
-        from ccproxy.observability.access_logger import log_request_access
+        # Also keep the original request_success event for debugging
+        # Merge metadata, avoiding duplicates
+        success_log_data = {
+            "request_id": request_id,
+            "duration_ms": duration_ms,
+            "duration_seconds": ctx.duration_seconds,
+        }
 
-        await log_request_access(
-            context=ctx,
-            # Extract client info from metadata if available
-            client_ip=ctx.metadata.get("client_ip"),
-            user_agent=ctx.metadata.get("user_agent"),
-            query=ctx.metadata.get("query"),
-            storage=ctx.storage,  # Pass storage from context
-        )
+        # Add metadata, avoiding duplicates
+        for key, value in ctx.metadata.items():
+            if key not in ("duration_ms", "duration_seconds", "request_id"):
+                success_log_data[key] = value
 
-        # Also keep the original request_success event for debugging
         request_logger.debug(
             "request_success",
-            request_id=request_id,
-            duration_ms=duration_ms,
-            duration_seconds=ctx.duration_seconds,
-            **ctx.metadata,
+            **success_log_data,
         )
 
     except Exception as e:
@@ -174,22 +270,34 @@ async def request_context(
         duration_ms = ctx.duration_ms
         error_type = type(e).__name__
 
+        # Merge metadata but ensure no duplicate duration fields
+        log_data = {
+            "request_id": request_id,
+            "duration_ms": duration_ms,
+            "duration_seconds": ctx.duration_seconds,
+            "error_type": error_type,
+            "error_message": str(e),
+        }
+
+        # Add metadata, avoiding duplicates
+        for key, value in ctx.metadata.items():
+            if key not in ("duration_ms", "duration_seconds"):
+                log_data[key] = value
+
         request_logger.error(
             "request_error",
-            request_id=request_id,
-            duration_ms=duration_ms,
-            duration_seconds=ctx.duration_seconds,
-            error_type=error_type,
-            error_message=str(e),
-            **ctx.metadata,
+            exc_info=e,
+            **log_data,
         )
 
-        # Emit SSE event for real-time dashboard updates
-        await _emit_request_error_event(request_id, error_type, str(e), ctx.metadata)
+        # SSE events removed - functionality moved to plugins
 
         # Re-raise the exception
         raise
     finally:
+        # Clear the current context
+        ctx.clear_current(token)
+
         # Decrement active requests if metrics provided
         if metrics:
             metrics.dec_active_requests()
@@ -273,6 +381,7 @@ async def timed_operation(
             duration_ms=duration_ms,
             error_type=error_type,
             error_message=str(e),
+            exc_info=e,
             **{
                 k: v for k, v in op_context.items() if k not in ("logger", "start_time")
             },
@@ -395,69 +504,3 @@ async def tracked_request_context(
         finally:
             # Remove from tracker
             await tracker.remove_context(ctx.request_id)
-
-
-async def _emit_request_start_event(
-    request_id: str, initial_context: dict[str, Any]
-) -> None:
-    """Emit SSE event for request start."""
-    try:
-        from ccproxy.observability.sse_events import emit_sse_event
-
-        # Create event data for SSE
-        sse_data = {
-            "request_id": request_id,
-            "method": initial_context.get("method"),
-            "path": initial_context.get("path"),
-            "client_ip": initial_context.get("client_ip"),
-            "user_agent": initial_context.get("user_agent"),
-            "query": initial_context.get("query"),
-        }
-
-        # Remove None values
-        sse_data = {k: v for k, v in sse_data.items() if v is not None}
-
-        await emit_sse_event("request_start", sse_data)
-
-    except Exception as e:
-        # Log error but don't fail the request
-        logger.debug(
-            "sse_emit_failed",
-            event_type="request_start",
-            error=str(e),
-            request_id=request_id,
-        )
-
-
-async def _emit_request_error_event(
-    request_id: str, error_type: str, error_message: str, metadata: dict[str, Any]
-) -> None:
-    """Emit SSE event for request error."""
-    try:
-        from ccproxy.observability.sse_events import emit_sse_event
-
-        # Create event data for SSE
-        sse_data = {
-            "request_id": request_id,
-            "error_type": error_type,
-            "error_message": error_message,
-            "method": metadata.get("method"),
-            "path": metadata.get("path"),
-            "client_ip": metadata.get("client_ip"),
-            "user_agent": metadata.get("user_agent"),
-            "query": metadata.get("query"),
-        }
-
-        # Remove None values
-        sse_data = {k: v for k, v in sse_data.items() if v is not None}
-
-        await emit_sse_event("request_error", sse_data)
-
-    except Exception as e:
-        # Log error but don't fail the request
-        logger.debug(
-            "sse_emit_failed",
-            event_type="request_error",
-            error=str(e),
-            request_id=request_id,
-        )

ccproxy/core/status_report.py

@@ -0,0 +1,211 @@
+"""Helpers for collecting status information used across interfaces."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+from ccproxy.config.settings import Settings
+from ccproxy.core.logging import get_logger
+from ccproxy.core.plugins.discovery import discover_and_load_plugins
+
+
+logger = get_logger(__name__)
+
+
+@dataclass(frozen=True)
+class DirectoryStatus:
+    """Represents availability of a directory."""
+
+    path: Path
+    exists: bool
+
+
+@dataclass(frozen=True)
+class SystemSnapshot:
+    """Summary of system-level settings."""
+
+    host: str
+    port: int
+    log_level: str
+    auth_token_configured: bool
+    plugins_enabled: bool
+    plugin_directories: tuple[DirectoryStatus, ...]
+
+
+@dataclass(frozen=True)
+class ConfigSource:
+    """Represents a potential configuration file location."""
+
+    path: Path
+    exists: bool
+
+
+@dataclass(frozen=True)
+class ConfigSnapshot:
+    """Collected configuration source information."""
+
+    sources: tuple[ConfigSource, ...]
+
+
+@dataclass(frozen=True)
+class PluginInfo:
+    """Represents the status of an individual plugin."""
+
+    name: str
+    state: Literal["enabled", "error"]
+    version: str | None
+    description: str | None
+    error: str | None = None
+
+
+@dataclass(frozen=True)
+class PluginSnapshot:
+    """Collection of plugin discovery results."""
+
+    plugin_system_enabled: bool
+    enabled_plugins: tuple[PluginInfo, ...]
+    disabled_plugins: tuple[str, ...]
+    configuration_notes: tuple[str, ...]
+
+    @property
+    def enabled_count(self) -> int:
+        return len(self.enabled_plugins)
+
+    @property
+    def disabled_count(self) -> int:
+        return len(self.disabled_plugins)
+
+    @property
+    def total_count(self) -> int:
+        return self.enabled_count + self.disabled_count
+
+
+def collect_system_snapshot(settings: Settings) -> SystemSnapshot:
+    """Build a system snapshot from settings."""
+    directories: list[DirectoryStatus] = []
+    for directory in settings.plugin_discovery.directories:
+        dir_path = Path(directory)
+        directories.append(DirectoryStatus(path=dir_path, exists=dir_path.exists()))
+
+    return SystemSnapshot(
+        host=str(settings.server.host),
+        port=int(settings.server.port),
+        log_level=settings.logging.level.upper(),
+        auth_token_configured=bool(settings.security.auth_token),
+        plugins_enabled=bool(settings.enable_plugins),
+        plugin_directories=tuple(directories),
+    )
+
+
+def collect_config_snapshot(*, cwd: Path | None = None) -> ConfigSnapshot:
+    """Inspect common configuration locations relative to the current working directory."""
+    effective_cwd = cwd or Path.cwd()
+    candidates: Iterable[Path] = (
+        effective_cwd / ".ccproxy.toml",
+        effective_cwd / "ccproxy.toml",
+        Path.home() / ".ccproxy" / "config.toml",
+    )
+
+    sources = tuple(
+        ConfigSource(path=path, exists=path.exists()) for path in candidates
+    )
+    return ConfigSnapshot(sources=sources)
+
+
+def collect_plugin_snapshot(settings: Settings) -> PluginSnapshot:
+    """Discover plugins and report basic status information."""
+    if not settings.enable_plugins:
+        notes = _collect_plugin_configuration_notes(settings)
+        return PluginSnapshot(
+            plugin_system_enabled=False,
+            enabled_plugins=(),
+            disabled_plugins=(),
+            configuration_notes=notes,
+        )
+
+    plugin_infos: list[PluginInfo] = []
+    try:
+        plugin_factories = discover_and_load_plugins(settings)
+    except Exception as exc:  # pragma: no cover - defensive guard
+        logger.error("plugin_discovery_failed", error=str(exc), exc_info=exc)
+        return PluginSnapshot(
+            plugin_system_enabled=True,
+            enabled_plugins=(),
+            disabled_plugins=(),
+            configuration_notes=_collect_plugin_configuration_notes(settings),
+        )
+
+    for name, factory in sorted(plugin_factories.items()):
+        try:
+            manifest = factory.get_manifest()
+            plugin_infos.append(
+                PluginInfo(
+                    name=name,
+                    state="enabled",
+                    version=manifest.version,
+                    description=manifest.description,
+                )
+            )
+        except Exception as exc:
+            error_text = str(exc)
+            logger.error(
+                "plugin_manifest_failed", plugin=name, error=error_text, exc_info=exc
+            )
+            plugin_infos.append(
+                PluginInfo(
+                    name=name,
+                    state="error",
+                    version=None,
+                    description=None,
+                    error=error_text,
+                )
+            )
+
+    disabled_plugins = tuple(
+        sorted(_find_disabled_plugins(settings, set(plugin_factories.keys())))
+    )
+
+    return PluginSnapshot(
+        plugin_system_enabled=True,
+        enabled_plugins=tuple(plugin_infos),
+        disabled_plugins=disabled_plugins,
+        configuration_notes=_collect_plugin_configuration_notes(settings),
+    )
+
+
+def _collect_plugin_configuration_notes(settings: Settings) -> tuple[str, ...]:
+    notes: list[str] = []
+    if settings.plugins_disable_local_discovery:
+        notes.append("Local discovery disabled")
+    if settings.disabled_plugins:
+        notes.append(f"Explicitly disabled: {len(settings.disabled_plugins)}")
+    if settings.enabled_plugins:
+        notes.append(f"Allow-list active: {len(settings.enabled_plugins)} allowed")
+    return tuple(notes)
+
+
+def _find_disabled_plugins(settings: Settings, enabled_plugins: set[str]) -> set[str]:
+    """Find plugins that exist but are disabled in the configuration."""
+    disabled: set[str] = set()
+
+    if settings.plugins_disable_local_discovery:
+        return disabled
+
+    for plugin_dir_path in settings.plugin_discovery.directories:
+        plugin_dir = Path(plugin_dir_path)
+        if not plugin_dir.exists():
+            continue
+
+        for item in plugin_dir.iterdir():
+            if not item.is_dir() or item.name.startswith("_"):
+                continue
+            plugin_file = item / "plugin.py"
+            if not plugin_file.exists():
+                continue
+            if item.name not in enabled_plugins:
+                disabled.add(item.name)
+
+    return disabled

ccproxy/core/transformers.py

@@ -1,10 +1,10 @@
 """Core transformer abstractions for request/response transformation."""
 
+import time
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Any, Protocol, TypeVar, runtime_checkable
 
-from structlog import get_logger
-
+from ccproxy.core.logging import get_logger
 from ccproxy.core.types import ProxyRequest, ProxyResponse, TransformContext
 
 
@@ -65,8 +65,8 @@ class BaseTransformer(ABC):
 
         try:
             # Calculate data sizes
-            input_size = self._calculate_data_size(input_data)
-            output_size = self._calculate_data_size(output_data) if output_data else 0
+            # input_size = self._calculate_data_size(input_data)
+            # output_size = self._calculate_data_size(output_data) if output_data else 0
 
             # Create a unique request ID for this transformation
             request_id = (
@@ -80,6 +80,15 @@ class BaseTransformer(ABC):
                 processing_time=duration_ms,
             )
 
+        except (AttributeError, TypeError) as e:
+            # Don't let metrics collection fail the transformation
+            logger = get_logger(__name__)
+            # logger = logging.getLogger(__name__)
+            logger.debug(
+                "transformation_metrics_attribute_error",
+                error=str(e),
+                exc_info=e,
+            )
         except Exception as e:
             # Don't let metrics collection fail the transformation
             logger = get_logger(__name__)
@@ -131,8 +140,6 @@ class RequestTransformer(BaseTransformer):
         Returns:
             The transformed request
         """
-        import time
-
         start_time = time.perf_counter()
         error_msg = None
         result = None
@@ -186,8 +193,6 @@ class ResponseTransformer(BaseTransformer):
         Returns:
             The transformed response
         """
-        import time
-
         start_time = time.perf_counter()
         error_msg = None
         result = None