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

mcp_proxy_adapter/api/middleware/auth.py

@@ -0,0 +1,146 @@
+"""
+Middleware for authentication.
+"""
+
+import json
+from typing import Dict, List, Optional, Callable, Awaitable
+
+from fastapi import Request, Response
+from starlette.responses import JSONResponse
+
+from mcp_proxy_adapter.core.logging import logger
+from .base import BaseMiddleware
+
+class AuthMiddleware(BaseMiddleware):
+    """
+    Middleware for authenticating requests.
+    """
+    
+    def __init__(self, app, api_keys: Dict[str, str] = None, public_paths: List[str] = None, auth_enabled: bool = True):
+        """
+        Initializes middleware for authentication.
+        
+        Args:
+            app: FastAPI application
+            api_keys: Dictionary with API keys (key: username)
+            public_paths: List of paths accessible without authentication
+            auth_enabled: Flag to enable/disable authentication
+        """
+        super().__init__(app)
+        self.api_keys = api_keys or {}
+        self.public_paths = public_paths or [
+            "/docs", 
+            "/redoc", 
+            "/openapi.json", 
+            "/health"
+        ]
+        self.auth_enabled = auth_enabled
+    
+    async def dispatch(self, request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
+        """
+        Processes request and checks authentication.
+        
+        Args:
+            request: Request.
+            call_next: Next handler.
+            
+        Returns:
+            Response.
+        """
+        # Check if authentication is disabled
+        if not self.auth_enabled:
+            logger.debug("Authentication is disabled, skipping authentication check")
+            return await call_next(request)
+            
+        # Check if path is public
+        path = request.url.path
+        if self._is_public_path(path):
+            # If path is public, skip authentication
+            return await call_next(request)
+        
+        # Check for API key in header
+        api_key = request.headers.get("X-API-Key")
+        
+        if not api_key:
+            # Check for API key in query parameters
+            api_key = request.query_params.get("api_key")
+        
+        if not api_key and request.method in ["POST", "PUT", "PATCH"]:
+            # Check for API key in JSON-RPC request body
+            try:
+                body = await request.body()
+                if body:
+                    try:
+                        body_json = json.loads(body.decode("utf-8"))
+                        # Look for API key in params of JSON-RPC object
+                        if isinstance(body_json, dict) and "params" in body_json:
+                            api_key = body_json.get("params", {}).get("api_key")
+                    except json.JSONDecodeError:
+                        pass
+            except Exception:
+                pass
+        
+        # If API key not found, return error
+        if not api_key:
+            logger.warning(f"Authentication failed: API key not provided | Path: {path}")
+            return self._create_error_response("API key not provided", 401)
+        
+        # Check if API key is valid
+        username = self._validate_api_key(api_key)
+        if not username:
+            logger.warning(f"Authentication failed: Invalid API key | Path: {path}")
+            return self._create_error_response("Invalid API key", 401)
+        
+        # If API key is valid, save user information in request state
+        request.state.username = username
+        logger.info(f"Authentication successful: {username} | Path: {path}")
+        
+        # Call the next middleware or main handler
+        return await call_next(request)
+    
+    def _is_public_path(self, path: str) -> bool:
+        """
+        Checks if the path is public.
+        
+        Args:
+            path: Path to check.
+            
+        Returns:
+            True if path is public, False otherwise.
+        """
+        return any(path.startswith(public_path) for public_path in self.public_paths)
+    
+    def _validate_api_key(self, api_key: str) -> Optional[str]:
+        """
+        Validates API key.
+        
+        Args:
+            api_key: API key to validate.
+            
+        Returns:
+            Username if API key is valid, otherwise None.
+        """
+        return self.api_keys.get(api_key)
+    
+    def _create_error_response(self, message: str, status_code: int) -> Response:
+        """
+        Creates error response in JSON-RPC format.
+        
+        Args:
+            message: Error message.
+            status_code: HTTP status code.
+            
+        Returns:
+            JSON response with error.
+        """
+        return JSONResponse(
+            status_code=status_code,
+            content={
+                "jsonrpc": "2.0",
+                "error": {
+                    "code": -32000,
+                    "message": message
+                },
+                "id": None
+            }
+        ) 

mcp_proxy_adapter/api/middleware/base.py

@@ -0,0 +1,79 @@
+"""
+Base middleware module.
+"""
+
+from typing import Callable, Awaitable
+import logging
+
+from starlette.middleware.base import BaseHTTPMiddleware
+from fastapi import Request, Response
+
+from mcp_proxy_adapter.core.logging import logger
+
+class BaseMiddleware(BaseHTTPMiddleware):
+    """
+    Base class for all middleware.
+    """
+    
+    async def dispatch(self, request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
+        """
+        Method that will be overridden in child classes.
+        
+        Args:
+            request: Request.
+            call_next: Next handler.
+            
+        Returns:
+            Response.
+        """
+        try:
+            # Process request before calling the main handler
+            await self.before_request(request)
+            
+            # Call the next middleware or main handler
+            response = await call_next(request)
+            
+            # Process response after calling the main handler
+            response = await self.after_response(request, response)
+            
+            return response
+        except Exception as e:
+            logger.exception(f"Error in middleware: {str(e)}")
+            # If an error occurred, call the error handler
+            return await self.handle_error(request, e)
+    
+    async def before_request(self, request: Request) -> None:
+        """
+        Method for processing request before calling the main handler.
+        
+        Args:
+            request: Request.
+        """
+        pass
+    
+    async def after_response(self, request: Request, response: Response) -> Response:
+        """
+        Method for processing response after calling the main handler.
+        
+        Args:
+            request: Request.
+            response: Response.
+            
+        Returns:
+            Processed response.
+        """
+        return response
+    
+    async def handle_error(self, request: Request, exception: Exception) -> Response:
+        """
+        Method for handling errors that occurred in middleware.
+        
+        Args:
+            request: Request.
+            exception: Exception.
+            
+        Returns:
+            Error response.
+        """
+        # By default, just pass the error further
+        raise exception 

mcp_proxy_adapter/api/middleware/error_handling.py

@@ -0,0 +1,198 @@
+"""
+Middleware for error handling.
+"""
+
+import json
+from typing import Callable, Awaitable, Dict, Any, Optional
+
+from fastapi import Request, Response
+from starlette.responses import JSONResponse
+
+from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.errors import MicroserviceError, CommandError, ValidationError
+from .base import BaseMiddleware
+
+class ErrorHandlingMiddleware(BaseMiddleware):
+    """
+    Middleware for handling and formatting errors.
+    """
+    
+    async def dispatch(self, request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
+        """
+        Processes request and catches errors.
+        
+        Args:
+            request: Request.
+            call_next: Next handler.
+            
+        Returns:
+            Response.
+        """
+        try:
+            # Call the next middleware or main handler
+            return await call_next(request)
+            
+        except CommandError as e:
+            # Command error
+            request_id = getattr(request.state, "request_id", "unknown")
+            logger.error(f"[{request_id}] Command error: {str(e)}")
+            
+            # Проверяем, является ли запрос JSON-RPC
+            is_jsonrpc = self._is_json_rpc_request(request)
+            
+            # Get JSON-RPC request ID if available
+            request_id_jsonrpc = await self._get_json_rpc_id(request)
+            
+            # If request was JSON-RPC
+            if is_jsonrpc:
+                return JSONResponse(
+                    status_code=400,
+                    content={
+                        "jsonrpc": "2.0",
+                        "error": {
+                            "code": e.code,
+                            "message": str(e),
+                            "data": e.details if hasattr(e, "details") else None
+                        },
+                        "id": request_id_jsonrpc
+                    }
+                )
+            
+            # Regular API error
+            return JSONResponse(
+                status_code=400,
+                content=e.to_dict()
+            )
+            
+        except ValidationError as e:
+            # Validation error
+            request_id = getattr(request.state, "request_id", "unknown")
+            logger.error(f"[{request_id}] Validation error: {str(e)}")
+            
+            # Get JSON-RPC request ID if available
+            request_id_jsonrpc = await self._get_json_rpc_id(request)
+            
+            # If request was JSON-RPC
+            if self._is_json_rpc_request(request):
+                return JSONResponse(
+                    status_code=400,
+                    content={
+                        "jsonrpc": "2.0",
+                        "error": {
+                            "code": -32602,
+                            "message": "Invalid params",
+                            "data": e.details if hasattr(e, "details") else None
+                        },
+                        "id": request_id_jsonrpc
+                    }
+                )
+            
+            # Regular API error
+            return JSONResponse(
+                status_code=400,
+                content=e.to_dict()
+            )
+            
+        except MicroserviceError as e:
+            # Other microservice error
+            request_id = getattr(request.state, "request_id", "unknown")
+            logger.error(f"[{request_id}] Microservice error: {str(e)}")
+            
+            # Get JSON-RPC request ID if available
+            request_id_jsonrpc = await self._get_json_rpc_id(request)
+            
+            # If request was JSON-RPC
+            if self._is_json_rpc_request(request):
+                return JSONResponse(
+                    status_code=e.code,
+                    content={
+                        "jsonrpc": "2.0",
+                        "error": {
+                            "code": -32000,
+                            "message": str(e),
+                            "data": e.details if hasattr(e, "details") else None
+                        },
+                        "id": request_id_jsonrpc
+                    }
+                )
+            
+            # Regular API error
+            return JSONResponse(
+                status_code=e.code,
+                content=e.to_dict()
+            )
+            
+        except Exception as e:
+            # Unexpected error
+            request_id = getattr(request.state, "request_id", "unknown")
+            logger.exception(f"[{request_id}] Unexpected error: {str(e)}")
+            
+            # Get JSON-RPC request ID if available
+            request_id_jsonrpc = await self._get_json_rpc_id(request)
+            
+            # If request was JSON-RPC
+            if self._is_json_rpc_request(request):
+                return JSONResponse(
+                    status_code=500,
+                    content={
+                        "jsonrpc": "2.0",
+                        "error": {
+                            "code": -32603,
+                            "message": "Internal error"
+                        },
+                        "id": request_id_jsonrpc
+                    }
+                )
+            
+            # Regular API error
+            return JSONResponse(
+                status_code=500,
+                content={
+                    "error": {
+                        "code": 500,
+                        "message": "Internal server error"
+                    }
+                }
+            )
+    
+    def _is_json_rpc_request(self, request: Request) -> bool:
+        """
+        Checks if request is a JSON-RPC request.
+        
+        Args:
+            request: Request.
+            
+        Returns:
+            True if request is JSON-RPC, False otherwise.
+        """
+        return request.url.path.endswith("/jsonrpc")
+    
+    async def _get_json_rpc_id(self, request: Request) -> Optional[Any]:
+        """
+        Gets JSON-RPC request ID.
+        
+        Args:
+            request: Request.
+            
+        Returns:
+            JSON-RPC request ID if available, None otherwise.
+        """
+        try:
+            # Use request state to avoid body parsing if already done
+            if hasattr(request.state, "json_rpc_id"):
+                return request.state.json_rpc_id
+                
+            # Parse request body
+            body = await request.body()
+            if body:
+                body_text = body.decode("utf-8")
+                body_json = json.loads(body_text)
+                request_id = body_json.get("id")
+                
+                # Save ID in request state to avoid reparsing
+                request.state.json_rpc_id = request_id
+                return request_id
+        except Exception as e:
+            logger.warning(f"Error parsing JSON-RPC ID: {str(e)}")
+        
+        return None 

mcp_proxy_adapter/api/middleware/logging.py

@@ -0,0 +1,96 @@
+"""
+Middleware for request logging.
+"""
+
+import time
+import json
+import uuid
+from typing import Callable, Awaitable
+
+from fastapi import Request, Response
+
+from mcp_proxy_adapter.core.logging import logger, RequestLogger
+from .base import BaseMiddleware
+
+class LoggingMiddleware(BaseMiddleware):
+    """
+    Middleware for logging requests and responses.
+    """
+    
+    async def dispatch(self, request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
+        """
+        Processes request and logs information about it.
+        
+        Args:
+            request: Request.
+            call_next: Next handler.
+            
+        Returns:
+            Response.
+        """
+        # Generate unique ID for request
+        request_id = str(uuid.uuid4())
+        request.state.request_id = request_id
+        
+        # Create context logger for this request
+        req_logger = RequestLogger("mcp_proxy_adapter.api.middleware", request_id)
+        
+        # Log request start
+        start_time = time.time()
+        
+        # Request information
+        method = request.method
+        url = str(request.url)
+        client_host = request.client.host if request.client else "unknown"
+        
+        req_logger.info(f"Request started: {method} {url} | Client: {client_host}")
+        
+        # Log request body if not GET or HEAD
+        if method not in ["GET", "HEAD"]:
+            try:
+                body = await request.body()
+                if body:
+                    # Try to parse JSON
+                    try:
+                        body_text = body.decode("utf-8")
+                        # Hide sensitive data (like passwords)
+                        body_json = json.loads(body_text)
+                        if isinstance(body_json, dict) and "params" in body_json:
+                            # Replace sensitive fields with "***"
+                            if isinstance(body_json["params"], dict):
+                                for sensitive_field in ["password", "token", "secret", "api_key"]:
+                                    if sensitive_field in body_json["params"]:
+                                        body_json["params"][sensitive_field] = "***"
+                        
+                        req_logger.debug(f"Request body: {json.dumps(body_json)}")
+                    except json.JSONDecodeError:
+                        # If not JSON, log as is
+                        req_logger.debug(f"Request body: {body_text}")
+                    except Exception as e:
+                        req_logger.warning(f"Error logging request body: {str(e)}")
+            except Exception as e:
+                req_logger.warning(f"Error reading request body: {str(e)}")
+        
+        # Call the next middleware or main handler
+        try:
+            response = await call_next(request)
+            
+            # Log request completion
+            process_time = time.time() - start_time
+            status_code = response.status_code
+            
+            req_logger.info(f"Request completed: {method} {url} | Status: {status_code} | "
+                            f"Time: {process_time:.3f}s")
+            
+            # Add request ID to response headers
+            response.headers["X-Request-ID"] = request_id
+            response.headers["X-Process-Time"] = f"{process_time:.3f}s"
+            
+            return response
+        except Exception as e:
+            # Log error
+            process_time = time.time() - start_time
+            req_logger.error(f"Request failed: {method} {url} | Error: {str(e)} | "
+                            f"Time: {process_time:.3f}s")
+            
+            raise 

mcp_proxy_adapter/api/middleware/performance.py

@@ -0,0 +1,83 @@
+"""
+Middleware for performance monitoring.
+"""
+
+import time
+import statistics
+from typing import Dict, List, Callable, Awaitable
+
+from fastapi import Request, Response
+
+from mcp_proxy_adapter.core.logging import logger
+from .base import BaseMiddleware
+
+class PerformanceMiddleware(BaseMiddleware):
+    """
+    Middleware for measuring performance.
+    """
+    
+    def __init__(self, app):
+        """
+        Initializes performance middleware.
+        
+        Args:
+            app: FastAPI application.
+        """
+        super().__init__(app)
+        self.request_times: Dict[str, List[float]] = {}
+        self.log_interval = 100  # Log statistics every 100 requests
+        self.request_count = 0
+    
+    async def dispatch(self, request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
+        """
+        Processes request and measures performance.
+        
+        Args:
+            request: Request.
+            call_next: Next handler.
+            
+        Returns:
+            Response.
+        """
+        # Measure processing time
+        start_time = time.time()
+        
+        # Call the next middleware or main handler
+        response = await call_next(request)
+        
+        # Calculate processing time
+        process_time = time.time() - start_time
+        
+        # Save time in statistics
+        path = request.url.path
+        if path not in self.request_times:
+            self.request_times[path] = []
+        
+        self.request_times[path].append(process_time)
+        
+        # Logging statistics
+        self.request_count += 1
+        if self.request_count % self.log_interval == 0:
+            self._log_stats()
+        
+        return response
+    
+    def _log_stats(self) -> None:
+        """
+        Logs performance statistics.
+        """
+        logger.info("Performance statistics:")
+        
+        for path, times in self.request_times.items():
+            if len(times) > 1:
+                avg_time = statistics.mean(times)
+                min_time = min(times)
+                max_time = max(times)
+                # Calculate 95th percentile
+                p95_time = sorted(times)[int(len(times) * 0.95)]
+                
+                logger.info(
+                    f"Path: {path}, Requests: {len(times)}, "
+                    f"Avg: {avg_time:.3f}s, Min: {min_time:.3f}s, "
+                    f"Max: {max_time:.3f}s, p95: {p95_time:.3f}s"
+                )