mcp-proxy-adapter 6.3.4__py3-none-any.whl → 6.3.5__py3-none-any.whl

mcp_proxy_adapter/api/middleware/error_handling.py

@@ -9,49 +9,56 @@ 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 mcp_proxy_adapter.core.errors import (
+    MicroserviceError,
+    CommandError,
+    ValidationError,
+)
 from .base import BaseMiddleware
 
+
 class ErrorHandlingMiddleware(BaseMiddleware):
     """
     Middleware for handling and formatting errors.
     """
-    
+
     def __init__(self, app):
         """
         Initialize error handling middleware.
-        
+
         Args:
             app: FastAPI application
         """
         super().__init__(app)
-    
-    async def dispatch(self, request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
+
+    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.debug(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(
@@ -61,26 +68,23 @@ class ErrorHandlingMiddleware(BaseMiddleware):
                         "error": {
                             "code": e.code,
                             "message": str(e),
-                            "data": e.data if hasattr(e, "data") and e.data else None
+                            "data": e.data if hasattr(e, "data") and e.data else None,
                         },
-                        "id": request_id_jsonrpc
-                    }
+                        "id": request_id_jsonrpc,
+                    },
                 )
-            
+
             # Regular API error
-            return JSONResponse(
-                status_code=400,
-                content=e.to_dict()
-            )
-            
+            return JSONResponse(status_code=400, content=e.to_dict())
+
         except ValidationError as e:
             # Validation error
             request_id = getattr(request.state, "request_id", "unknown")
             logger.debug(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(
@@ -90,26 +94,23 @@ class ErrorHandlingMiddleware(BaseMiddleware):
                         "error": {
                             "code": -32602,
                             "message": "Invalid params",
-                            "data": e.data if hasattr(e, "data") and e.data else None
+                            "data": e.data if hasattr(e, "data") and e.data else None,
                         },
-                        "id": request_id_jsonrpc
-                    }
+                        "id": request_id_jsonrpc,
+                    },
                 )
-            
+
             # Regular API error
-            return JSONResponse(
-                status_code=400,
-                content=e.to_dict()
-            )
-            
+            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.debug(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(
@@ -119,71 +120,60 @@ class ErrorHandlingMiddleware(BaseMiddleware):
                         "error": {
                             "code": -32000,
                             "message": str(e),
-                            "data": e.data if hasattr(e, "data") and e.data else None
+                            "data": e.data if hasattr(e, "data") and e.data else None,
                         },
-                        "id": request_id_jsonrpc
-                    }
+                        "id": request_id_jsonrpc,
+                    },
                 )
-            
+
             # Regular API error
-            return JSONResponse(
-                status_code=400,
-                content=e.to_dict()
-            )
-            
+            return JSONResponse(status_code=400, content=e.to_dict())
+
         except Exception as e:
             # Unexpected error
             request_id = getattr(request.state, "request_id", "unknown")
             logger.debug(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
-                    }
+                        "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"
-                    }
-                }
+                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.
         """
         # Only requests to /api/jsonrpc are JSON-RPC requests
         return request.url.path == "/api/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.
         """
@@ -191,18 +181,18 @@ class ErrorHandlingMiddleware(BaseMiddleware):
             # 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 
+
+        return None

mcp_proxy_adapter/api/middleware/factory.py

@@ -22,15 +22,15 @@ from .user_info_middleware import UserInfoMiddleware
 class MiddlewareFactory:
     """
     Factory for creating and managing middleware components.
-    
+
     Provides methods to create middleware components with proper configuration
     and dependency management.
     """
-    
+
     def __init__(self, app: FastAPI, config: Dict[str, Any]):
         """
         Initialize middleware factory.
-        
+
         Args:
             app: FastAPI application
             config: Application configuration
@@ -38,136 +38,134 @@ class MiddlewareFactory:
         self.app = app
         self.config = config
         self.middleware_stack: List[BaseMiddleware] = []
-        
+
         logger.info("Middleware factory initialized")
-    
+
     def create_security_middleware(self) -> Optional[UnifiedSecurityMiddleware]:
         """
         Create unified security middleware.
-        
+
         Returns:
             UnifiedSecurityMiddleware instance or None if creation failed
         """
         try:
             security_config = self.config.get("security", {})
-            
+
             if not security_config.get("enabled", True):
                 logger.info("Security middleware disabled by configuration")
                 return None
-            
+
             middleware = UnifiedSecurityMiddleware(self.app, self.config)
             self.middleware_stack.append(middleware)
-            
+
             logger.info("Unified security middleware created successfully")
             return middleware
-            
+
         except Exception as e:
             logger.error(f"Failed to create unified security middleware: {e}")
             return None
-    
+
     def create_error_handling_middleware(self) -> Optional[ErrorHandlingMiddleware]:
         """
         Create error handling middleware.
-        
+
         Returns:
             ErrorHandlingMiddleware instance or None if creation failed
         """
         try:
             # Import here to avoid circular imports
             from .error_handling import ErrorHandlingMiddleware
-            
+
             middleware = ErrorHandlingMiddleware(self.app)
             self.middleware_stack.append(middleware)
-            
+
             logger.info("Error handling middleware created successfully")
             return middleware
-            
+
         except Exception as e:
             logger.error(f"Failed to create error handling middleware: {e}")
             return None
-    
+
     def create_logging_middleware(self) -> Optional[LoggingMiddleware]:
         """
         Create logging middleware.
-        
+
         Returns:
             LoggingMiddleware instance or None if creation failed
         """
         try:
             # Import here to avoid circular imports
             from .logging import LoggingMiddleware
-            
+
             middleware = LoggingMiddleware(self.app, self.config)
             self.middleware_stack.append(middleware)
-            
+
             logger.info("Logging middleware created successfully")
             return middleware
-            
+
         except Exception as e:
             logger.error(f"Failed to create logging middleware: {e}")
             return None
-    
+
     def create_user_info_middleware(self) -> Optional[UserInfoMiddleware]:
         """
         Create user info middleware.
-        
+
         Returns:
             UserInfoMiddleware instance or None if creation failed
         """
         try:
             middleware = UserInfoMiddleware(self.app, self.config)
             self.middleware_stack.append(middleware)
-            
+
             logger.info("User info middleware created successfully")
             return middleware
-            
+
         except Exception as e:
             logger.error(f"Failed to create user info middleware: {e}")
             return None
-    
 
-    
     def create_all_middleware(self) -> List[BaseMiddleware]:
         """
         Create all required middleware components.
-        
+
         Returns:
             List of created middleware instances
         """
         middleware_list = []
-        
+
         # Create security middleware (unified)
         security_middleware = self.create_security_middleware()
         if security_middleware:
             middleware_list.append(security_middleware)
-        
+
         # Create error handling middleware
         error_middleware = self.create_error_handling_middleware()
         if error_middleware:
             middleware_list.append(error_middleware)
-        
+
         # Create logging middleware
         logging_middleware = self.create_logging_middleware()
         if logging_middleware:
             middleware_list.append(logging_middleware)
-        
+
         # Create user info middleware
         user_info_middleware = self.create_user_info_middleware()
         if user_info_middleware:
             middleware_list.append(user_info_middleware)
-        
+
         logger.info(f"Created {len(middleware_list)} middleware components")
         return middleware_list
-    
 
-    
-    def get_middleware_by_type(self, middleware_type: Type[BaseMiddleware]) -> Optional[BaseMiddleware]:
+    def get_middleware_by_type(
+        self, middleware_type: Type[BaseMiddleware]
+    ) -> Optional[BaseMiddleware]:
         """
         Get middleware instance by type.
-        
+
         Args:
             middleware_type: Type of middleware to find
-            
+
         Returns:
             Middleware instance or None if not found
         """
@@ -175,31 +173,31 @@ class MiddlewareFactory:
             if isinstance(middleware, middleware_type):
                 return middleware
         return None
-    
+
     def get_security_middleware(self) -> Optional[UnifiedSecurityMiddleware]:
         """
         Get unified security middleware instance.
-        
+
         Returns:
             UnifiedSecurityMiddleware instance or None if not found
         """
         return self.get_middleware_by_type(UnifiedSecurityMiddleware)
-    
+
     def validate_middleware_config(self) -> bool:
         """
         Validate middleware configuration.
-        
+
         Returns:
             True if configuration is valid, False otherwise
         """
         try:
             security_config = self.config.get("security", {})
-            
+
             # Validate security configuration
             if not SecurityFactory.validate_config(self.config):
                 logger.error("Security configuration validation failed")
                 return False
-            
+
             # Validate middleware-specific configurations
             if security_config.get("enabled", True):
                 # Check required fields for security middleware
@@ -207,37 +205,37 @@ class MiddlewareFactory:
                 if not isinstance(auth_config, dict):
                     logger.error("Auth configuration must be a dictionary")
                     return False
-                
+
                 ssl_config = security_config.get("ssl", {})
                 if not isinstance(ssl_config, dict):
                     logger.error("SSL configuration must be a dictionary")
                     return False
-            
+
             logger.info("Middleware configuration validation passed")
             return True
-            
+
         except Exception as e:
             logger.error(f"Middleware configuration validation failed: {e}")
             return False
-    
+
     def get_middleware_info(self) -> Dict[str, Any]:
         """
         Get information about created middleware.
-        
+
         Returns:
             Dictionary with middleware information
         """
         info = {
             "total_middleware": len(self.middleware_stack),
             "middleware_types": [],
-            "security_enabled": False
+            "security_enabled": False,
         }
-        
+
         for middleware in self.middleware_stack:
             middleware_type = type(middleware).__name__
             info["middleware_types"].append(middleware_type)
-            
+
             if isinstance(middleware, UnifiedSecurityMiddleware):
                 info["security_enabled"] = True
-        
+
         return info

mcp_proxy_adapter/api/middleware/logging.py

@@ -12,56 +12,59 @@ 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.
     """
-    
+
     def __init__(self, app, config: Dict[str, Any] = None):
         """
         Initialize logging middleware.
-        
+
         Args:
             app: FastAPI application
             config: Application configuration (optional)
         """
         super().__init__(app)
         self.config = config or {}
-    
-    async def dispatch(self, request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
+
+    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"
-        
+
         # Check if this is an OpenAPI schema request (should be logged at DEBUG level)
         is_openapi_request = "/openapi.json" in url
-        
+
         if is_openapi_request:
             req_logger.debug(f"Request started: {method} {url} | Client: {client_host}")
         else:
             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:
@@ -75,10 +78,15 @@ class LoggingMiddleware(BaseMiddleware):
                         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"]:
+                                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
@@ -87,36 +95,44 @@ class LoggingMiddleware(BaseMiddleware):
                         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
-            
+
             if is_openapi_request:
-                req_logger.debug(f"Request completed: {method} {url} | Status: {status_code} | "
-                                f"Time: {process_time:.3f}s")
+                req_logger.debug(
+                    f"Request completed: {method} {url} | Status: {status_code} | "
+                    f"Time: {process_time:.3f}s"
+                )
             else:
-                req_logger.info(f"Request completed: {method} {url} | Status: {status_code} | "
-                                f"Time: {process_time:.3f}s")
-            
+                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
-            
+
             if is_openapi_request:
-                req_logger.debug(f"Request failed: {method} {url} | Error: {str(e)} | "
-                                f"Time: {process_time:.3f}s")
+                req_logger.debug(
+                    f"Request failed: {method} {url} | Error: {str(e)} | "
+                    f"Time: {process_time:.3f}s"
+                )
             else:
-                req_logger.error(f"Request failed: {method} {url} | Error: {str(e)} | "
-                                f"Time: {process_time:.3f}s")
-            
-            raise 
+                req_logger.error(
+                    f"Request failed: {method} {url} | Error: {str(e)} | "
+                    f"Time: {process_time:.3f}s"
+                )
+
+            raise