mcp-proxy-adapter 2.1.17__py3-none-any.whl → 3.0.1__py3-none-any.whl

mcp_proxy_adapter/core/logging.py

@@ -0,0 +1,205 @@
+"""
+Module for configuring logging in the microservice.
+"""
+
+import logging
+import os
+import sys
+import uuid
+from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler
+from typing import Dict, Optional, Any
+
+from mcp_proxy_adapter.config import config
+
+
+class CustomFormatter(logging.Formatter):
+    """
+    Custom formatter for logs with colored output in console.
+    """
+    grey = "\x1b[38;20m"
+    yellow = "\x1b[33;20m"
+    red = "\x1b[31;20m"
+    bold_red = "\x1b[31;1m"
+    reset = "\x1b[0m"
+    format_str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+
+    FORMATS = {
+        logging.DEBUG: grey + format_str + reset,
+        logging.INFO: grey + format_str + reset,
+        logging.WARNING: yellow + format_str + reset,
+        logging.ERROR: red + format_str + reset,
+        logging.CRITICAL: bold_red + format_str + reset
+    }
+
+    def format(self, record):
+        log_fmt = self.FORMATS.get(record.levelno)
+        formatter = logging.Formatter(log_fmt)
+        return formatter.format(record)
+
+
+class RequestContextFilter(logging.Filter):
+    """
+    Filter for adding request context to logs.
+    """
+    
+    def __init__(self, request_id: Optional[str] = None):
+        super().__init__()
+        self.request_id = request_id
+    
+    def filter(self, record):
+        # Add request_id attribute to the record
+        record.request_id = self.request_id or "no-request-id"
+        return True
+
+
+class RequestLogger:
+    """
+    Logger class for logging requests with context.
+    """
+    
+    def __init__(self, logger_name: str, request_id: Optional[str] = None):
+        """
+        Initialize request logger.
+        
+        Args:
+            logger_name: Logger name.
+            request_id: Request identifier.
+        """
+        self.logger = logging.getLogger(logger_name)
+        self.request_id = request_id or str(uuid.uuid4())
+        self.filter = RequestContextFilter(self.request_id)
+        self.logger.addFilter(self.filter)
+    
+    def debug(self, msg: str, *args, **kwargs):
+        """Log message with DEBUG level."""
+        self.logger.debug(f"[{self.request_id}] {msg}", *args, **kwargs)
+    
+    def info(self, msg: str, *args, **kwargs):
+        """Log message with INFO level."""
+        self.logger.info(f"[{self.request_id}] {msg}", *args, **kwargs)
+    
+    def warning(self, msg: str, *args, **kwargs):
+        """Log message with WARNING level."""
+        self.logger.warning(f"[{self.request_id}] {msg}", *args, **kwargs)
+    
+    def error(self, msg: str, *args, **kwargs):
+        """Log message with ERROR level."""
+        self.logger.error(f"[{self.request_id}] {msg}", *args, **kwargs)
+    
+    def exception(self, msg: str, *args, **kwargs):
+        """Log exception with traceback."""
+        self.logger.exception(f"[{self.request_id}] {msg}", *args, **kwargs)
+    
+    def critical(self, msg: str, *args, **kwargs):
+        """Log message with CRITICAL level."""
+        self.logger.critical(f"[{self.request_id}] {msg}", *args, **kwargs)
+
+
+def setup_logging(
+    level: Optional[str] = None,
+    log_file: Optional[str] = None,
+    max_bytes: Optional[int] = None,
+    backup_count: Optional[int] = None,
+    rotation_type: Optional[str] = None,
+    rotation_when: Optional[str] = None,
+    rotation_interval: Optional[int] = None
+) -> logging.Logger:
+    """
+    Configure logging for the microservice.
+
+    Args:
+        level: Logging level. By default, taken from configuration.
+        log_file: Path to log file. By default, taken from configuration.
+        max_bytes: Maximum log file size in bytes. By default, taken from configuration.
+        backup_count: Number of rotation files. By default, taken from configuration.
+        rotation_type: Type of log rotation ('size' or 'time'). By default, taken from configuration.
+        rotation_when: Time unit for rotation (D, H, M, S). By default, taken from configuration.
+        rotation_interval: Interval for rotation. By default, taken from configuration.
+
+    Returns:
+        Configured logger.
+    """
+    # Get parameters from configuration if not explicitly specified
+    level = level or config.get("logging.level", "INFO")
+    log_file = log_file or config.get("logging.file")
+    rotation_type = rotation_type or config.get("logging.rotation.type", "size")
+    
+    # Size-based rotation parameters
+    max_bytes = max_bytes or config.get("logging.rotation.max_bytes", 10 * 1024 * 1024)  # 10 MB by default
+    backup_count = backup_count or config.get("logging.rotation.backup_count", 5)
+    
+    # Time-based rotation parameters
+    rotation_when = rotation_when or config.get("logging.rotation.when", "D")  # Daily by default
+    rotation_interval = rotation_interval or config.get("logging.rotation.interval", 1)
+
+    # Convert string logging level to constant
+    numeric_level = getattr(logging, level.upper(), None)
+    if not isinstance(numeric_level, int):
+        numeric_level = logging.INFO
+
+    # Create root logger
+    logger = logging.getLogger("mcp_proxy_adapter")
+    logger.setLevel(numeric_level)
+    logger.handlers = []  # Clear handlers in case of repeated call
+
+    # Create console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(numeric_level)
+    console_handler.setFormatter(CustomFormatter())
+    logger.addHandler(console_handler)
+
+    # Create file handler if file specified
+    if log_file:
+        # Create directory for log file if it doesn't exist
+        log_dir = os.path.dirname(log_file)
+        if log_dir and not os.path.exists(log_dir):
+            os.makedirs(log_dir, exist_ok=True)
+
+        # Choose rotation type
+        if rotation_type.lower() == "time":
+            file_handler = TimedRotatingFileHandler(
+                log_file,
+                when=rotation_when,
+                interval=rotation_interval,
+                backupCount=backup_count,
+                encoding="utf-8"
+            )
+        else:  # Default to size-based rotation
+            file_handler = RotatingFileHandler(
+                log_file,
+                maxBytes=max_bytes,
+                backupCount=backup_count,
+                encoding="utf-8"
+            )
+            
+        file_handler.setLevel(numeric_level)
+        file_formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        )
+        file_handler.setFormatter(file_formatter)
+        logger.addHandler(file_handler)
+
+    # Configure loggers for external libraries
+    log_levels = config.get("logging.levels", {})
+    for logger_name, logger_level in log_levels.items():
+        lib_logger = logging.getLogger(logger_name)
+        lib_logger.setLevel(getattr(logging, logger_level.upper(), logging.INFO))
+
+    return logger
+
+
+def get_logger(name: str) -> logging.Logger:
+    """
+    Get a logger with the specified name.
+    
+    Args:
+        name: Logger name.
+        
+    Returns:
+        Configured logger instance.
+    """
+    return logging.getLogger(name)
+
+
+# Global logger for use throughout the application
+logger = setup_logging()

mcp_proxy_adapter/core/utils.py

@@ -0,0 +1,138 @@
+"""
+Module with utility functions for the microservice.
+"""
+
+import hashlib
+import json
+import os
+import sys
+import time
+import uuid
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from mcp_proxy_adapter.core.logging import logger
+
+
+def generate_id() -> str:
+    """
+    Generates a unique identifier.
+
+    Returns:
+        String with unique identifier.
+    """
+    return str(uuid.uuid4())
+
+
+def get_timestamp() -> int:
+    """
+    Returns current timestamp in milliseconds.
+
+    Returns:
+        Integer - timestamp in milliseconds.
+    """
+    return int(time.time() * 1000)
+
+
+def format_datetime(dt: Optional[datetime] = None, format_str: str = "%Y-%m-%dT%H:%M:%S.%fZ") -> str:
+    """
+    Formats date and time as string.
+
+    Args:
+        dt: Datetime object to format. If None, current time is used.
+        format_str: Format string for output.
+
+    Returns:
+        Formatted date/time string.
+    """
+    dt = dt or datetime.utcnow()
+    return dt.strftime(format_str)
+
+
+def parse_datetime(dt_str: str, format_str: str = "%Y-%m-%dT%H:%M:%S.%fZ") -> datetime:
+    """
+    Parses date/time string into datetime object.
+
+    Args:
+        dt_str: Date/time string.
+        format_str: Date/time string format.
+
+    Returns:
+        Datetime object.
+    """
+    return datetime.strptime(dt_str, format_str)
+
+
+def safe_json_loads(s: str, default: Any = None) -> Any:
+    """
+    Safe JSON string loading.
+
+    Args:
+        s: JSON string to load.
+        default: Default value on parsing error.
+
+    Returns:
+        Loaded object or default value on error.
+    """
+    try:
+        return json.loads(s)
+    except Exception as e:
+        logger.error(f"Error parsing JSON: {e}")
+        return default
+
+
+def safe_json_dumps(obj: Any, default: str = "{}", indent: Optional[int] = None) -> str:
+    """
+    Safe object conversion to JSON string.
+
+    Args:
+        obj: Object to convert.
+        default: Default string on serialization error.
+        indent: Indentation for JSON formatting.
+
+    Returns:
+        JSON string or default string on error.
+    """
+    try:
+        return json.dumps(obj, ensure_ascii=False, indent=indent)
+    except Exception as e:
+        logger.error(f"Error serializing to JSON: {e}")
+        return default
+
+
+def calculate_hash(data: Union[str, bytes], algorithm: str = "sha256") -> str:
+    """
+    Calculates hash for data.
+
+    Args:
+        data: Data to hash (string or bytes).
+        algorithm: Hashing algorithm (md5, sha1, sha256, etc.).
+
+    Returns:
+        String with hash in hexadecimal format.
+    """
+    if isinstance(data, str):
+        data = data.encode("utf-8")
+    
+    hash_obj = hashlib.new(algorithm)
+    hash_obj.update(data)
+    return hash_obj.hexdigest()
+
+
+def ensure_directory(path: str) -> bool:
+    """
+    Checks directory existence and creates it if necessary.
+
+    Args:
+        path: Path to directory.
+
+    Returns:
+        True if directory exists or was successfully created, otherwise False.
+    """
+    try:
+        if not os.path.exists(path):
+            os.makedirs(path, exist_ok=True)
+        return True
+    except Exception as e:
+        logger.error(f"Error creating directory {path}: {e}")
+        return False

mcp_proxy_adapter/custom_openapi.py

@@ -0,0 +1,125 @@
+"""
+Custom OpenAPI schema generator for MCP Microservice compatible with MCP-Proxy.
+"""
+import json
+from copy import deepcopy
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set, Type
+
+from fastapi import FastAPI
+from fastapi.openapi.utils import get_openapi
+
+from mcp_proxy_adapter.commands.command_registry import registry
+from mcp_proxy_adapter.commands.base import Command
+from mcp_proxy_adapter.core.logging import logger
+
+
+class CustomOpenAPIGenerator:
+    """
+    Custom OpenAPI schema generator for compatibility with MCP-Proxy.
+    
+    This generator creates an OpenAPI schema that matches the format expected by MCP-Proxy,
+    enabling dynamic command loading and proper tool representation in AI models.
+    """
+    
+    def __init__(self):
+        """Initialize the generator."""
+        self.base_schema_path = Path(__file__).parent / "schemas" / "openapi_schema.json"
+        self.base_schema = self._load_base_schema()
+        
+    def _load_base_schema(self) -> Dict[str, Any]:
+        """
+        Load the base OpenAPI schema from file.
+        
+        Returns:
+            Dict containing the base OpenAPI schema.
+        """
+        with open(self.base_schema_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    
+    def _add_commands_to_schema(self, schema: Dict[str, Any]) -> None:
+        """
+        Add all registered commands to the OpenAPI schema.
+        
+        Args:
+            schema: The OpenAPI schema to update.
+        """
+        # Get all commands from the registry
+        commands = registry.get_all_commands()
+        
+        # Add command names to the CommandRequest enum
+        schema["components"]["schemas"]["CommandRequest"]["properties"]["command"]["enum"] = [
+            cmd for cmd in commands.keys()
+        ]
+        
+        # Add command parameters to oneOf
+        params_refs = []
+        
+        for name, cmd_class in commands.items():
+            # Create schema for command parameters
+            param_schema_name = f"{name.capitalize()}Params"
+            schema["components"]["schemas"][param_schema_name] = self._create_params_schema(cmd_class)
+            
+            # Add to oneOf
+            params_refs.append({"$ref": f"#/components/schemas/{param_schema_name}"})
+        
+        # Add null option for commands without parameters
+        params_refs.append({"type": "null"})
+        
+        # Set oneOf for params
+        schema["components"]["schemas"]["CommandRequest"]["properties"]["params"]["oneOf"] = params_refs
+    
+    def _create_params_schema(self, cmd_class: Type[Command]) -> Dict[str, Any]:
+        """
+        Create a schema for command parameters.
+        
+        Args:
+            cmd_class: The command class.
+            
+        Returns:
+            Dict containing the parameter schema.
+        """
+        # Get command schema
+        cmd_schema = cmd_class.get_schema()
+        
+        # Add title and description
+        cmd_schema["title"] = f"Parameters for {cmd_class.name}"
+        cmd_schema["description"] = f"Parameters for the {cmd_class.name} command"
+        
+        return cmd_schema
+        
+    def generate(self) -> Dict[str, Any]:
+        """
+        Generate the complete OpenAPI schema compatible with MCP-Proxy.
+        
+        Returns:
+            Dict containing the complete OpenAPI schema.
+        """
+        # Deep copy the base schema to avoid modifying it
+        schema = deepcopy(self.base_schema)
+        
+        # Add commands to schema
+        self._add_commands_to_schema(schema)
+        
+        logger.info(f"Generated OpenAPI schema with {len(registry.get_all_commands())} commands")
+        
+        return schema
+
+
+def custom_openapi(app: FastAPI) -> Dict[str, Any]:
+    """
+    Create a custom OpenAPI schema for the FastAPI application.
+    
+    Args:
+        app: The FastAPI application.
+        
+    Returns:
+        Dict containing the custom OpenAPI schema.
+    """
+    generator = CustomOpenAPIGenerator()
+    openapi_schema = generator.generate()
+    
+    # Cache the schema
+    app.openapi_schema = openapi_schema
+    
+    return openapi_schema