ccproxy-api 0.1.0__py3-none-any.whl

ccproxy/core/logging.py

@@ -0,0 +1,189 @@
+import logging
+import sys
+from collections.abc import MutableMapping
+from typing import Any
+
+import structlog
+from structlog.stdlib import BoundLogger
+from structlog.typing import Processor
+
+
+def configure_structlog(json_logs: bool = False, log_level: str = "INFO") -> None:
+    """Configure structlog with your preferred processors."""
+    # Use different timestamp format based on log level
+    # Dev mode (DEBUG): only hours without microseconds
+    # Info mode: full date without microseconds
+    if log_level.upper() == "DEBUG":
+        timestamper = structlog.processors.TimeStamper(fmt="%H:%M:%S")
+    else:
+        timestamper = structlog.processors.TimeStamper(fmt="%Y-%m-%d %H:%M:%S")
+
+    # Processors that will be used for structlog loggers
+    processors: list[Processor] = [
+        structlog.stdlib.filter_by_level,
+    ]
+
+    # Only add logger name if NOT in INFO mode
+    if log_level.upper() != "INFO":
+        processors.append(structlog.stdlib.add_logger_name)
+
+    processors.extend(
+        [
+            structlog.stdlib.add_log_level,
+            structlog.stdlib.PositionalArgumentsFormatter(),
+            timestamper,
+            structlog.processors.StackInfoRenderer(),
+            structlog.processors.format_exc_info,
+            structlog.processors.UnicodeDecoder(),
+        ]
+    )
+
+    # Only add CallsiteParameterAdder if NOT in INFO mode
+    if log_level.upper() != "INFO":
+        processors.append(
+            structlog.processors.CallsiteParameterAdder(
+                parameters=[
+                    structlog.processors.CallsiteParameter.FILENAME,
+                    structlog.processors.CallsiteParameter.LINENO,
+                ]
+            )
+        )
+
+    # This wrapper passes the event dictionary to the ProcessorFormatter
+    # so we don't double-render
+    processors.append(structlog.stdlib.ProcessorFormatter.wrap_for_formatter)
+
+    structlog.configure(
+        processors=processors,
+        context_class=dict,
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        wrapper_class=structlog.stdlib.BoundLogger,
+        cache_logger_on_first_use=False,  # Don't cache to allow reconfiguration
+    )
+
+
+def setup_logging(
+    json_logs: bool = False, log_level: str = "INFO", log_file: str | None = None
+) -> BoundLogger:
+    """
+    Setup logging for the entire application including uvicorn and fastapi.
+    Returns a structlog logger instance.
+    """
+    # Set the log level for the root logger first so structlog can see it
+    root_logger = logging.getLogger()
+    root_logger.setLevel(getattr(logging, log_level.upper(), logging.INFO))
+
+    # Configure structlog after setting the log level
+    configure_structlog(json_logs=json_logs, log_level=log_level)
+
+    # Create a handler that will format stdlib logs through structlog
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setLevel(getattr(logging, log_level.upper(), logging.INFO))
+
+    # Use the appropriate renderer based on json_logs setting
+    renderer = (
+        structlog.processors.JSONRenderer()
+        if json_logs
+        else structlog.dev.ConsoleRenderer()
+    )
+
+    # Use ProcessorFormatter to handle both structlog and stdlib logs
+    # Use the same timestamp format for foreign logs
+    if log_level.upper() == "DEBUG":
+        foreign_timestamper = structlog.processors.TimeStamper(fmt="%H:%M:%S")
+    else:
+        foreign_timestamper = structlog.processors.TimeStamper(fmt="%Y-%m-%d %H:%M:%S")
+
+    # Build foreign_pre_chain conditionally
+    foreign_pre_chain: list[Processor] = [structlog.stdlib.add_log_level]
+
+    # Only add logger name if NOT in INFO mode
+    if log_level.upper() != "INFO":
+        foreign_pre_chain.append(structlog.stdlib.add_logger_name)
+
+    foreign_pre_chain.append(foreign_timestamper)
+
+    handler.setFormatter(
+        structlog.stdlib.ProcessorFormatter(
+            processor=renderer,
+            foreign_pre_chain=foreign_pre_chain,
+        )
+    )
+
+    # Configure root logger (level already set above)
+    handlers: list[logging.Handler] = [handler]
+
+    # Add file handler if log_file is specified
+    if log_file:
+        from pathlib import Path
+
+        # Ensure parent directory exists
+        log_path = Path(log_file)
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Create a file handler that always outputs JSON
+        file_handler = logging.FileHandler(log_file, encoding="utf-8")
+        file_handler.setLevel(getattr(logging, log_level.upper(), logging.INFO))
+        file_handler.setFormatter(
+            structlog.stdlib.ProcessorFormatter(
+                processor=structlog.processors.JSONRenderer(),
+                foreign_pre_chain=foreign_pre_chain,
+            )
+        )
+        handlers.append(file_handler)
+
+    root_logger.handlers = handlers
+
+    # Make sure uvicorn and fastapi loggers use our configuration
+    for logger_name in [
+        "uvicorn",
+        "uvicorn.access",
+        "uvicorn.error",
+        "fastapi",
+        "ccproxy",
+    ]:
+        logger = logging.getLogger(logger_name)
+        logger.handlers = []  # Remove default handlers
+        logger.propagate = True  # Use root logger's handlers
+
+        # Set uvicorn loggers to WARNING when app log level is INFO to reduce noise
+        if logger_name.startswith("uvicorn") and log_level.upper() == "INFO":
+            logger.setLevel(logging.WARNING)
+        else:
+            logger.setLevel(getattr(logging, log_level.upper(), logging.INFO))
+
+    # Configure httpx logger separately - INFO when app is DEBUG, WARNING otherwise
+    httpx_logger = logging.getLogger("httpx")
+    httpx_logger.handlers = []  # Remove default handlers
+    httpx_logger.propagate = True  # Use root logger's handlers
+    if log_level.upper() == "DEBUG":
+        httpx_logger.setLevel(logging.INFO)
+    else:
+        httpx_logger.setLevel(logging.WARNING)
+
+    # Set noisy HTTP-related loggers to WARNING when app log level >= WARNING, else use app log level
+    app_log_level = getattr(logging, log_level.upper(), logging.INFO)
+    noisy_log_level = (
+        logging.WARNING if app_log_level <= logging.WARNING else app_log_level
+    )
+
+    for noisy_logger_name in [
+        "urllib3",
+        "urllib3.connectionpool",
+        "requests",
+        "aiohttp",
+        "httpcore",
+        "httpcore.http11",
+    ]:
+        noisy_logger = logging.getLogger(noisy_logger_name)
+        noisy_logger.handlers = []  # Remove default handlers
+        noisy_logger.propagate = True  # Use root logger's handlers
+        noisy_logger.setLevel(noisy_log_level)
+
+    return structlog.get_logger()  # type: ignore[no-any-return]
+
+
+# Create a convenience function for getting loggers
+def get_logger(name: str | None = None) -> BoundLogger:
+    """Get a structlog logger instance."""
+    return structlog.get_logger(name)  # type: ignore[no-any-return]

ccproxy/core/middleware.py

@@ -0,0 +1,114 @@
+"""Core middleware abstractions for request/response processing."""
+
+from abc import ABC, abstractmethod
+from collections.abc import Awaitable, Callable
+from typing import Any, Optional, Protocol, runtime_checkable
+
+from ccproxy.core.types import ProxyRequest, ProxyResponse
+
+
+# Type alias for the next middleware function
+NextMiddleware = Callable[[ProxyRequest], Awaitable[ProxyResponse]]
+
+
+class BaseMiddleware(ABC):
+    """Abstract base class for all middleware."""
+
+    @abstractmethod
+    async def __call__(
+        self, request: ProxyRequest, next: NextMiddleware
+    ) -> ProxyResponse:
+        """Process the request and call the next middleware.
+
+        Args:
+            request: The incoming request
+            next: The next middleware in the chain
+
+        Returns:
+            The response from the middleware chain
+
+        Raises:
+            MiddlewareError: If middleware processing fails
+        """
+        pass
+
+
+@runtime_checkable
+class MiddlewareProtocol(Protocol):
+    """Protocol defining the middleware interface."""
+
+    async def __call__(
+        self, request: ProxyRequest, next: NextMiddleware
+    ) -> ProxyResponse:
+        """Process the request and call the next middleware."""
+        ...
+
+
+class MiddlewareChain:
+    """Manages a chain of middleware."""
+
+    def __init__(self, middleware: list[BaseMiddleware]):
+        """Initialize with a list of middleware.
+
+        Args:
+            middleware: List of middleware to apply in order
+        """
+        self.middleware = middleware
+
+    async def __call__(
+        self, request: ProxyRequest, handler: NextMiddleware
+    ) -> ProxyResponse:
+        """Execute the middleware chain.
+
+        Args:
+            request: The incoming request
+            handler: The final request handler
+
+        Returns:
+            The response from the middleware chain
+        """
+        # Build the chain from the inside out
+        chain = handler
+        for mw in reversed(self.middleware):
+            # Create a closure to capture the current middleware and chain
+            def make_chain(
+                current_mw: BaseMiddleware, current_chain: NextMiddleware
+            ) -> NextMiddleware:
+                async def next_fn(req: ProxyRequest) -> ProxyResponse:
+                    return await current_chain(req)
+
+                async def new_chain(req: ProxyRequest) -> ProxyResponse:
+                    return await current_mw(req, next_fn)
+
+                return new_chain
+
+            chain = make_chain(mw, chain)
+
+        # Execute the complete chain
+        return await chain(request)
+
+
+class CompositeMiddleware(BaseMiddleware):
+    """Middleware that combines multiple middleware into one."""
+
+    def __init__(self, middleware: list[BaseMiddleware]):
+        """Initialize with a list of middleware to compose.
+
+        Args:
+            middleware: List of middleware to apply in order
+        """
+        self.chain = MiddlewareChain(middleware)
+
+    async def __call__(
+        self, request: ProxyRequest, next: NextMiddleware
+    ) -> ProxyResponse:
+        """Process the request through all composed middleware.
+
+        Args:
+            request: The incoming request
+            next: The next middleware in the chain
+
+        Returns:
+            The response from the middleware chain
+        """
+        return await self.chain(request, next)

ccproxy/core/proxy.py

@@ -0,0 +1,143 @@
+"""Core proxy abstractions for handling HTTP and WebSocket connections."""
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any, Optional, Protocol, runtime_checkable
+
+from ccproxy.core.types import ProxyRequest, ProxyResponse
+
+
+if TYPE_CHECKING:
+    from ccproxy.core.http import HTTPClient
+
+
+class BaseProxy(ABC):
+    """Abstract base class for all proxy implementations."""
+
+    @abstractmethod
+    async def forward(self, request: ProxyRequest) -> ProxyResponse:
+        """Forward a request and return the response.
+
+        Args:
+            request: The proxy request to forward
+
+        Returns:
+            The proxy response
+
+        Raises:
+            ProxyError: If the request cannot be forwarded
+        """
+        pass
+
+    @abstractmethod
+    async def close(self) -> None:
+        """Close any resources held by the proxy."""
+        pass
+
+
+class HTTPProxy(BaseProxy):
+    """HTTP proxy implementation using HTTPClient abstractions."""
+
+    def __init__(self, http_client: "HTTPClient") -> None:
+        """Initialize with an HTTP client.
+
+        Args:
+            http_client: The HTTP client to use for requests
+        """
+        self.http_client = http_client
+
+    async def forward(self, request: ProxyRequest) -> ProxyResponse:
+        """Forward an HTTP request using the HTTP client.
+
+        Args:
+            request: The proxy request to forward
+
+        Returns:
+            The proxy response
+
+        Raises:
+            ProxyError: If the request cannot be forwarded
+        """
+        from ccproxy.core.errors import ProxyError
+        from ccproxy.core.http import HTTPError
+
+        try:
+            # Convert ProxyRequest to HTTP client format
+            body_bytes = None
+            if request.body is not None:
+                if isinstance(request.body, bytes):
+                    body_bytes = request.body
+                elif isinstance(request.body, str):
+                    body_bytes = request.body.encode("utf-8")
+                elif isinstance(request.body, dict):
+                    import json
+
+                    body_bytes = json.dumps(request.body).encode("utf-8")
+
+            # Make the HTTP request
+            status_code, headers, response_body = await self.http_client.request(
+                method=request.method.value,
+                url=request.url,
+                headers=request.headers,
+                body=body_bytes,
+                timeout=request.timeout,
+            )
+
+            # Convert response body to appropriate format
+            body: str | bytes | dict[str, Any] | None = response_body
+            if response_body:
+                # Try to decode as JSON if content-type suggests it
+                content_type = headers.get("content-type", "").lower()
+                if "application/json" in content_type:
+                    try:
+                        import json
+
+                        body = json.loads(response_body.decode("utf-8"))
+                    except (json.JSONDecodeError, UnicodeDecodeError):
+                        # Keep as bytes if JSON parsing fails
+                        body = response_body
+                elif "text/" in content_type:
+                    try:
+                        body = response_body.decode("utf-8")
+                    except UnicodeDecodeError:
+                        # Keep as bytes if text decoding fails
+                        body = response_body
+
+            return ProxyResponse(
+                status_code=status_code,
+                headers=headers,
+                body=body,
+            )
+
+        except HTTPError as e:
+            raise ProxyError(f"HTTP request failed: {e}") from e
+        except Exception as e:
+            raise ProxyError(f"Unexpected error during HTTP request: {e}") from e
+
+    async def close(self) -> None:
+        """Close HTTP proxy resources."""
+        await self.http_client.close()
+
+
+class WebSocketProxy(BaseProxy):
+    """WebSocket proxy implementation placeholder."""
+
+    async def forward(self, request: ProxyRequest) -> ProxyResponse:
+        """Forward a WebSocket request."""
+        raise NotImplementedError("WebSocketProxy.forward not yet implemented")
+
+    async def close(self) -> None:
+        """Close WebSocket proxy resources."""
+        pass
+
+
+@runtime_checkable
+class ProxyProtocol(Protocol):
+    """Protocol defining the proxy interface."""
+
+    async def forward(self, request: ProxyRequest) -> ProxyResponse:
+        """Forward a request and return the response."""
+        ...
+
+    async def close(self) -> None:
+        """Close any resources held by the proxy."""
+        ...

ccproxy/core/system.py

@@ -0,0 +1,38 @@
+import os
+from pathlib import Path
+
+
+def get_xdg_config_home() -> Path:
+    """Get the XDG_CONFIG_HOME directory.
+
+    Returns:
+        Path to the XDG config directory. Falls back to ~/.config if not set.
+    """
+    xdg_config_home = os.environ.get("XDG_CONFIG_HOME")
+    if xdg_config_home:
+        return Path(xdg_config_home)
+    return Path.home() / ".config"
+
+
+def get_xdg_data_home() -> Path:
+    """Get the XDG_DATA_HOME directory.
+
+    Returns:
+        Path to the XDG data directory. Falls back to ~/.local/share if not set.
+    """
+    xdg_data_home = os.environ.get("XDG_DATA_HOME")
+    if xdg_data_home:
+        return Path(xdg_data_home)
+    return Path.home() / ".local" / "share"
+
+
+def get_xdg_cache_home() -> Path:
+    """Get the XDG_CACHE_HOME directory.
+
+    Returns:
+        Path to the XDG cache directory. Falls back to ~/.cache if not set.
+    """
+    xdg_cache_home = os.environ.get("XDG_CACHE_HOME")
+    if xdg_cache_home:
+        return Path(xdg_cache_home)
+    return Path.home() / ".cache"