mcp-proxy-adapter 6.9.17__py3-none-any.whl → 6.9.19__py3-none-any.whl

mcp_proxy_adapter/api/middleware/factory.py

@@ -10,7 +10,7 @@ from typing import Dict, Any, List, Optional, Type
 
 from fastapi import FastAPI
 
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 from mcp_proxy_adapter.core.security_factory import SecurityFactory
 from .base import BaseMiddleware
 from .unified_security import UnifiedSecurityMiddleware
@@ -39,7 +39,7 @@ class MiddlewareFactory:
         self.config = config
         self.middleware_stack: List[BaseMiddleware] = []
 
-        logger.info("Middleware factory initialized")
+        get_global_logger().info("Middleware factory initialized")
 
     def create_security_middleware(self) -> Optional[UnifiedSecurityMiddleware]:
         """
@@ -52,17 +52,17 @@ class MiddlewareFactory:
             security_config = self.config.get("security", {})
 
             if not security_config.get("enabled", True):
-                logger.info("Security middleware disabled by configuration")
+                get_global_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")
+            get_global_logger().info("Unified security middleware created successfully")
             return middleware
 
         except Exception as e:
-            logger.error(f"Failed to create unified security middleware: {e}")
+            get_global_logger().error(f"Failed to create unified security middleware: {e}")
             return None
 
     def create_error_handling_middleware(self) -> Optional[ErrorHandlingMiddleware]:
@@ -79,11 +79,11 @@ class MiddlewareFactory:
             middleware = ErrorHandlingMiddleware(self.app)
             self.middleware_stack.append(middleware)
 
-            logger.info("Error handling middleware created successfully")
+            get_global_logger().info("Error handling middleware created successfully")
             return middleware
 
         except Exception as e:
-            logger.error(f"Failed to create error handling middleware: {e}")
+            get_global_logger().error(f"Failed to create error handling middleware: {e}")
             return None
 
     def create_logging_middleware(self) -> Optional[LoggingMiddleware]:
@@ -100,11 +100,11 @@ class MiddlewareFactory:
             middleware = LoggingMiddleware(self.app, self.config)
             self.middleware_stack.append(middleware)
 
-            logger.info("Logging middleware created successfully")
+            get_global_logger().info("Logging middleware created successfully")
             return middleware
 
         except Exception as e:
-            logger.error(f"Failed to create logging middleware: {e}")
+            get_global_logger().error(f"Failed to create logging middleware: {e}")
             return None
 
     def create_user_info_middleware(self) -> Optional[UserInfoMiddleware]:
@@ -118,11 +118,11 @@ class MiddlewareFactory:
             middleware = UserInfoMiddleware(self.app, self.config)
             self.middleware_stack.append(middleware)
 
-            logger.info("User info middleware created successfully")
+            get_global_logger().info("User info middleware created successfully")
             return middleware
 
         except Exception as e:
-            logger.error(f"Failed to create user info middleware: {e}")
+            get_global_logger().error(f"Failed to create user info middleware: {e}")
             return None
 
     def create_all_middleware(self) -> List[BaseMiddleware]:
@@ -154,7 +154,7 @@ class MiddlewareFactory:
         if user_info_middleware:
             middleware_list.append(user_info_middleware)
 
-        logger.info(f"Created {len(middleware_list)} middleware components")
+        get_global_logger().info(f"Created {len(middleware_list)} middleware components")
         return middleware_list
 
     def get_middleware_by_type(
@@ -195,7 +195,7 @@ class MiddlewareFactory:
 
             # Validate security configuration
             if not SecurityFactory.validate_config(self.config):
-                logger.error("Security configuration validation failed")
+                get_global_logger().error("Security configuration validation failed")
                 return False
 
             # Validate middleware-specific configurations
@@ -203,19 +203,19 @@ class MiddlewareFactory:
                 # Check required fields for security middleware
                 auth_config = security_config.get("auth", {})
                 if not isinstance(auth_config, dict):
-                    logger.error("Auth configuration must be a dictionary")
+                    get_global_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")
+                    get_global_logger().error("SSL configuration must be a dictionary")
                     return False
 
-            logger.info("Middleware configuration validation passed")
+            get_global_logger().info("Middleware configuration validation passed")
             return True
 
         except Exception as e:
-            logger.error(f"Middleware configuration validation failed: {e}")
+            get_global_logger().error(f"Middleware configuration validation failed: {e}")
             return False
 
     def get_middleware_info(self) -> Dict[str, Any]:

mcp_proxy_adapter/api/middleware/logging.py

@@ -9,7 +9,7 @@ from typing import Callable, Awaitable, Dict, Any
 
 from fastapi import Request, Response
 
-from mcp_proxy_adapter.core.logging import logger, RequestLogger
+from mcp_proxy_adapter.core.logging import get_global_logger, RequestLogger
 from .base import BaseMiddleware
 
 
@@ -42,14 +42,14 @@ class LoggingMiddleware(BaseMiddleware):
         Returns:
             Response.
         """
-        logger.debug(f"🔍 LoggingMiddleware.dispatch START - {request.method} {request.url.path}")
+        get_global_logger().debug(f"🔍 LoggingMiddleware.dispatch START - {request.method} {request.url.path}")
         
         # Generate unique ID for request
         request_id = str(uuid.uuid4())
         request.state.request_id = request_id
-        logger.debug(f"🔍 LoggingMiddleware - Generated request ID: {request_id}")
+        get_global_logger().debug(f"🔍 LoggingMiddleware - Generated request ID: {request_id}")
 
-        # Create context logger for this request
+        # Create context get_global_logger() for this request
         req_logger = RequestLogger("mcp_proxy_adapter.api.middleware", request_id)
 
         # Log request start
@@ -101,9 +101,9 @@ class LoggingMiddleware(BaseMiddleware):
 
         # Call the next middleware or main handler
         try:
-            logger.debug(f"🔍 LoggingMiddleware - About to call next handler")
+            get_global_logger().debug(f"🔍 LoggingMiddleware - About to call next handler")
             response = await call_next(request)
-            logger.debug(f"🔍 LoggingMiddleware - Next handler completed with status: {response.status_code}")
+            get_global_logger().debug(f"🔍 LoggingMiddleware - Next handler completed with status: {response.status_code}")
 
             # Log request completion
             process_time = time.time() - start_time

mcp_proxy_adapter/api/middleware/performance.py

@@ -8,7 +8,7 @@ from typing import Dict, List, Callable, Awaitable
 
 from fastapi import Request, Response
 
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 from .base import BaseMiddleware
 
 
@@ -69,7 +69,7 @@ class PerformanceMiddleware(BaseMiddleware):
         """
         Logs performance statistics.
         """
-        logger.info("Performance statistics:")
+        get_global_logger().info("Performance statistics:")
 
         for path, times in self.request_times.items():
             if len(times) > 1:
@@ -79,7 +79,7 @@ class PerformanceMiddleware(BaseMiddleware):
                 # Calculate 95th percentile
                 p95_time = sorted(times)[int(len(times) * 0.95)]
 
-                logger.info(
+                get_global_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"

mcp_proxy_adapter/api/middleware/protocol_middleware.py

@@ -10,7 +10,7 @@ from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.responses import JSONResponse
 
 from mcp_proxy_adapter.core.protocol_manager import get_protocol_manager
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 
 
 class ProtocolMiddleware(BaseHTTPMiddleware):
@@ -38,27 +38,27 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
             try:
                 normalized_config = app_config.get_all()
             except Exception as e:
-                logger.debug(
+                get_global_logger().debug(
                     f"ProtocolMiddleware - Error calling get_all(): {e}, type: {type(app_config)}"
                 )
                 normalized_config = None
         elif hasattr(app_config, "keys"):
             normalized_config = app_config  # Already dict-like
         else:
-            logger.debug(
+            get_global_logger().debug(
                 f"ProtocolMiddleware - app_config is not dict-like, type: {type(app_config)}, value: {repr(app_config)}"
             )
             normalized_config = None
 
-        logger.debug(
+        get_global_logger().debug(
             f"ProtocolMiddleware - normalized_config type: {type(normalized_config)}"
         )
         if normalized_config:
-            logger.debug(
+            get_global_logger().debug(
                 f"ProtocolMiddleware - protocols in config: {'protocols' in normalized_config}"
             )
             if "protocols" in normalized_config:
-                logger.debug(
+                get_global_logger().debug(
                     f"ProtocolMiddleware - protocols type: {type(normalized_config['protocols'])}"
                 )
 
@@ -84,7 +84,7 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
         else:
             self.app_config = None
         self.protocol_manager = get_protocol_manager(self.app_config)
-        logger.info("Protocol middleware configuration updated")
+        get_global_logger().info("Protocol middleware configuration updated")
 
     async def dispatch(self, request: Request, call_next: Callable) -> Response:
         """
@@ -97,19 +97,19 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
         Returns:
             Response object
         """
-        logger.debug(f"ProtocolMiddleware processing {request.method} {request.url.path}")
+        get_global_logger().debug(f"ProtocolMiddleware processing {request.method} {request.url.path}")
         
         try:
             # Get protocol from request
             protocol = self._get_request_protocol(request)
-            logger.debug(f"Detected protocol: {protocol} for {request.method} {request.url.path}")
+            get_global_logger().debug(f"Detected protocol: {protocol} for {request.method} {request.url.path}")
 
             # Check if protocol is allowed
             is_allowed = self.protocol_manager.is_protocol_allowed(protocol)
-            logger.debug(f"Protocol '{protocol}' allowed: {is_allowed}")
+            get_global_logger().debug(f"Protocol '{protocol}' allowed: {is_allowed}")
             
             if not is_allowed:
-                logger.warning(f"Protocol '{protocol}' not allowed for request to {request.url.path}")
+                get_global_logger().warning(f"Protocol '{protocol}' not allowed for request to {request.url.path}")
                 return JSONResponse(
                     status_code=403,
                     content={
@@ -121,14 +121,14 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
 
             # Continue processing
             request.state.protocol = protocol
-            logger.debug(f"Protocol '{protocol}' added to request state")
+            get_global_logger().debug(f"Protocol '{protocol}' added to request state")
             
             response = await call_next(request)
-            logger.debug(f"ProtocolMiddleware completed with status: {response.status_code}")
+            get_global_logger().debug(f"ProtocolMiddleware completed with status: {response.status_code}")
             return response
 
         except Exception as e:
-            logger.error(f"❌ PROTOCOL STEP ERROR: ProtocolMiddleware ERROR: {str(e)}", exc_info=True)
+            get_global_logger().error(f"❌ PROTOCOL STEP ERROR: ProtocolMiddleware ERROR: {str(e)}", exc_info=True)
             return JSONResponse(
                 status_code=500,
                 content={"error": "Protocol validation error", "message": str(e)},
@@ -163,7 +163,7 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
                                         try:
                                             cert = ssl_object.getpeercert()
                                             if cert:
-                                                logger.debug(f"mTLS client certificate detected: {cert.get('subject', 'unknown')}")
+                                                get_global_logger().debug(f"mTLS client certificate detected: {cert.get('subject', 'unknown')}")
                                                 return "mtls"
                                         except Exception:
                                             pass
@@ -181,7 +181,7 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
                             request.headers.get("x-forwarded-client-cert")
                         ]
                         if any(mtls_headers):
-                            logger.debug("mTLS client certificate detected in headers")
+                            get_global_logger().debug("mTLS client certificate detected in headers")
                             return "mtls"
                     except Exception:
                         pass
@@ -199,7 +199,7 @@ class ProtocolMiddleware(BaseHTTPMiddleware):
             return "http"
             
         except Exception as e:
-            logger.error(f"Error extracting protocol from request: {e}", exc_info=True)
+            get_global_logger().error(f"Error extracting protocol from request: {e}", exc_info=True)
             # Fallback to HTTP if there's any error
             return "http"
 
@@ -231,6 +231,6 @@ def setup_protocol_middleware(app, app_config: Optional[Dict[str, Any]] = None):
         # Create protocol middleware with current configuration
         middleware = ProtocolMiddleware(app, app_config)
         app.add_middleware(ProtocolMiddleware, app_config=app_config)
-        logger.info("Protocol middleware added to application")
+        get_global_logger().info("Protocol middleware added to application")
     else:
-        logger.info("Protocol management is disabled, skipping protocol middleware")
+        get_global_logger().info("Protocol management is disabled, skipping protocol middleware")

mcp_proxy_adapter/api/middleware/transport_middleware.py

@@ -10,7 +10,7 @@ from fastapi.responses import JSONResponse
 from starlette.middleware.base import BaseHTTPMiddleware
 
 from mcp_proxy_adapter.core.transport_manager import transport_manager
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 
 
 class TransportMiddleware(BaseHTTPMiddleware):
@@ -47,7 +47,7 @@ class TransportMiddleware(BaseHTTPMiddleware):
             configured_type_str = (
                 configured_type.value if configured_type else "not configured"
             )
-            logger.warning(f"Transport not allowed: {transport_type} for {request.url}")
+            get_global_logger().warning(f"Transport not allowed: {transport_type} for {request.url}")
             return JSONResponse(
                 status_code=403,
                 content={
@@ -118,7 +118,7 @@ class TransportMiddleware(BaseHTTPMiddleware):
         """
         configured_type = self.transport_manager.get_transport_type()
         if not configured_type:
-            logger.error("Transport not configured")
+            get_global_logger().error("Transport not configured")
             return False
 
         return transport_type == configured_type.value

mcp_proxy_adapter/api/middleware/unified_security.py

@@ -29,7 +29,7 @@ except ImportError:
     SecurityManager = None
     SecurityConfig = None
 
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 from mcp_proxy_adapter.core.security_integration import create_security_integration
 
 
@@ -74,18 +74,18 @@ class UnifiedSecurityMiddleware(BaseHTTPMiddleware):
                 self.framework_middleware = (
                     self.security_integration.security_manager.create_fastapi_middleware()
                 )
-                logger.info("Using mcp_security_framework FastAPI middleware")
+                get_global_logger().info("Using mcp_security_framework FastAPI middleware")
                 # IMPORTANT: Don't replace self.app! This breaks the middleware chain.
                 # Instead, store the framework middleware for use in dispatch method.
-                logger.info("Framework middleware will be used in dispatch method")
+                get_global_logger().info("Framework middleware will be used in dispatch method")
             else:
-                logger.info("Security disabled, skipping mcp_security_framework integration")
+                get_global_logger().info("Security disabled, skipping mcp_security_framework integration")
                 self.security_integration = None
                 self.framework_middleware = None
         except Exception as e:
-            logger.error(f"Security framework integration failed: {e}")
+            get_global_logger().error(f"Security framework integration failed: {e}")
             # Instead of raising error, log warning and continue without security
-            logger.warning(
+            get_global_logger().warning(
                 "Continuing without security framework - some security features will be disabled"
             )
             self.security_integration = None
@@ -93,7 +93,7 @@ class UnifiedSecurityMiddleware(BaseHTTPMiddleware):
             # Keep original app in place when framework middleware is unavailable
             # BaseHTTPMiddleware initialized it via super().__init__(app)
 
-        logger.info("Unified security middleware initialized")
+        get_global_logger().info("Unified security middleware initialized")
 
     async def dispatch(
         self, request: Request, call_next: Callable[[Request], Awaitable[Response]]
@@ -151,7 +151,7 @@ class UnifiedSecurityMiddleware(BaseHTTPMiddleware):
             if self.framework_middleware:
                 # If framework middleware exists, we need to call it manually
                 # This is a workaround since we can't chain ASGI apps in BaseHTTPMiddleware
-                logger.debug(
+                get_global_logger().debug(
                     "Framework middleware exists, continuing with regular call_next"
                 )
                 return await call_next(request)
@@ -164,7 +164,7 @@ class UnifiedSecurityMiddleware(BaseHTTPMiddleware):
             return await self._handle_security_error(request, e)
         except Exception as e:
             # Handle other errors
-            logger.error(f"Unexpected error in unified security middleware: {e}")
+            get_global_logger().error(f"Unexpected error in unified security middleware: {e}")
             return await self._handle_general_error(request, e)
 
     async def _handle_security_error(
@@ -190,7 +190,7 @@ class UnifiedSecurityMiddleware(BaseHTTPMiddleware):
             }
         }
 
-        logger.warning(f"Security validation failed: {error.message}")
+        get_global_logger().warning(f"Security validation failed: {error.message}")
 
         return JSONResponse(status_code=error.error_code, content=error_response)
 
@@ -217,6 +217,6 @@ class UnifiedSecurityMiddleware(BaseHTTPMiddleware):
             }
         }
 
-        logger.error(f"General error in security middleware: {error}")
+        get_global_logger().error(f"General error in security middleware: {error}")
 
         return JSONResponse(status_code=500, content=error_response)

mcp_proxy_adapter/api/middleware/user_info_middleware.py

@@ -12,7 +12,7 @@ from typing import Dict, Any, Callable, Awaitable
 from fastapi import Request, Response
 from starlette.middleware.base import BaseHTTPMiddleware
 
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 
 # Import mcp_security_framework components
 try:
@@ -57,7 +57,7 @@ class UserInfoMiddleware(BaseHTTPMiddleware):
                 # Check if security is enabled
                 security_enabled = security_config.get("enabled", False)
                 if not security_enabled:
-                    logger.info("ℹ️ Security disabled in configuration, using basic auth")
+                    get_global_logger().info("ℹ️ Security disabled in configuration, using basic auth")
                     self._security_available = False
                 else:
                     auth_config = security_config.get("auth", {})
@@ -78,7 +78,7 @@ class UserInfoMiddleware(BaseHTTPMiddleware):
                         # Create PermissionConfig for mcp_security_framework
                         roles_file = permissions_config.get("roles_file")
                         if roles_file is None:
-                            logger.warning("⚠️ Permissions enabled but no roles_file specified, using default configuration")
+                            get_global_logger().warning("⚠️ Permissions enabled but no roles_file specified, using default configuration")
                             roles_file = None
                         
                         mcp_permission_config = PermissionConfig(
@@ -106,17 +106,17 @@ class UserInfoMiddleware(BaseHTTPMiddleware):
                         self.auth_manager = AuthManager(
                             mcp_auth_config, self.permission_manager
                         )
-                        logger.info(
+                        get_global_logger().info(
                             "✅ User info middleware initialized with " "mcp_security_framework"
                         )
                     else:
                         # When permissions are disabled, use basic auth without mcp_security_framework
-                        logger.info("ℹ️ Permissions disabled, using basic token auth without mcp_security_framework")
+                        get_global_logger().info("ℹ️ Permissions disabled, using basic token auth without mcp_security_framework")
                         self._security_available = False
                         # Initialize api_keys for basic auth
                         self.api_keys = auth_config.get("api_keys", {})
             except Exception as e:
-                logger.warning(f"⚠️ Failed to initialize AuthManager: {e}")
+                get_global_logger().warning(f"⚠️ Failed to initialize AuthManager: {e}")
                 self._security_available = False
 
         # Always initialize api_keys for fallback
@@ -126,9 +126,9 @@ class UserInfoMiddleware(BaseHTTPMiddleware):
         
         if not self._security_available:
             # Fallback to basic API key handling
-            logger.info("ℹ️ User info middleware initialized with basic auth")
+            get_global_logger().info("ℹ️ User info middleware initialized with basic auth")
         else:
-            logger.info("ℹ️ User info middleware initialized with mcp_security_framework (fallback enabled)")
+            get_global_logger().info("ℹ️ User info middleware initialized with mcp_security_framework (fallback enabled)")
 
     async def dispatch(
         self, request: Request, call_next: Callable[[Request], Awaitable[Response]]
@@ -143,14 +143,14 @@ class UserInfoMiddleware(BaseHTTPMiddleware):
         Returns:
             Response object
         """
-        logger.debug(f"🔍 UserInfoMiddleware.dispatch START - {request.method} {request.url.path}")
-        logger.debug(f"🔍 UserInfoMiddleware - Headers: {dict(request.headers)}")
-        logger.debug(f"🔍 UserInfoMiddleware - AuthManager available: {self.auth_manager is not None}")
-        logger.debug(f"🔍 UserInfoMiddleware - Security available: {self._security_available}")
+        get_global_logger().debug(f"🔍 UserInfoMiddleware.dispatch START - {request.method} {request.url.path}")
+        get_global_logger().debug(f"🔍 UserInfoMiddleware - Headers: {dict(request.headers)}")
+        get_global_logger().debug(f"🔍 UserInfoMiddleware - AuthManager available: {self.auth_manager is not None}")
+        get_global_logger().debug(f"🔍 UserInfoMiddleware - Security available: {self._security_available}")
         
         # Extract API key from headers
         api_key = request.headers.get("X-API-Key")
-        logger.debug(f"🔍 UserInfoMiddleware - API Key: {api_key[:8] + '...' if api_key else 'None'}")
+        get_global_logger().debug(f"🔍 UserInfoMiddleware - API Key: {api_key[:8] + '...' if api_key else 'None'}")
         if api_key:
             if self.auth_manager and self._security_available:
                 try:
@@ -169,7 +169,7 @@ class UserInfoMiddleware(BaseHTTPMiddleware):
                                 auth_result, "permissions", ["read"]
                             ),
                         }
-                        logger.debug(
+                        get_global_logger().debug(
                             f"✅ Authenticated user with "
                             f"mcp_security_framework: "
                             f"{request.state.user}"
@@ -182,12 +182,12 @@ class UserInfoMiddleware(BaseHTTPMiddleware):
                             "roles": ["guest"],
                             "permissions": ["read"],
                         }
-                        logger.debug(
+                        get_global_logger().debug(
                             f"❌ Authentication failed for API key: "
                             f"{api_key[:8]}..."
                         )
                 except Exception as e:
-                    logger.warning(
+                    get_global_logger().warning(
                         f"⚠️ AuthManager error: {e}, " f"falling back to basic auth"
                     )
                     self._security_available = False
@@ -221,7 +221,7 @@ class UserInfoMiddleware(BaseHTTPMiddleware):
                         "roles": [user_role],
                         "permissions": role_permissions,
                     }
-                    logger.debug(
+                    get_global_logger().debug(
                         f"✅ User authenticated with API key: "
                         f"{api_key[:8]}..."
                     )
@@ -233,7 +233,7 @@ class UserInfoMiddleware(BaseHTTPMiddleware):
                         "roles": ["guest"],
                         "permissions": ["read"],
                     }
-                    logger.debug(f"❌ API key not found: {api_key[:8]}...")
+                    get_global_logger().debug(f"❌ API key not found: {api_key[:8]}...")
         else:
             # No API key provided - guest access
             request.state.user = {
@@ -242,9 +242,9 @@ class UserInfoMiddleware(BaseHTTPMiddleware):
                 "roles": ["guest"],
                 "permissions": ["read"],
             }
-            logger.debug("ℹ️ No API key provided, using guest access")
+            get_global_logger().debug("ℹ️ No API key provided, using guest access")
 
-        logger.debug(f"🔍 UserInfoMiddleware - About to call next handler")
+        get_global_logger().debug(f"🔍 UserInfoMiddleware - About to call next handler")
         response = await call_next(request)
-        logger.debug(f"🔍 UserInfoMiddleware - Next handler completed with status: {response.status_code}")
+        get_global_logger().debug(f"🔍 UserInfoMiddleware - Next handler completed with status: {response.status_code}")
         return response

mcp_proxy_adapter/api/tool_integration.py

@@ -13,6 +13,7 @@ import logging
 from mcp_proxy_adapter.api.schemas import APIToolDescription
 from mcp_proxy_adapter.commands.command_registry import CommandRegistry
 
+from mcp_proxy_adapter.core.logging import get_global_logger
 logger = logging.getLogger(__name__)
 
 
@@ -138,9 +139,9 @@ class ToolIntegration:
 
                 results[tool_name] = {"status": "success", "schema": schema}
 
-                logger.info(f"Successfully registered tool: {tool_name}")
+                get_global_logger().info(f"Successfully registered tool: {tool_name}")
             except Exception as e:
-                logger.debug(f"Error registering tool {tool_name}: {e}")
+                get_global_logger().debug(f"Error registering tool {tool_name}: {e}")
                 results[tool_name] = {"status": "error", "error": str(e)}
 
         return results

mcp_proxy_adapter/api/tools.py

@@ -13,6 +13,7 @@ from mcp_proxy_adapter.api.tool_integration import ToolIntegration
 from mcp_proxy_adapter.commands.command_registry import registry
 from mcp_proxy_adapter.core.errors import NotFoundError, InvalidParamsError
 
+from mcp_proxy_adapter.core.logging import get_global_logger
 logger = logging.getLogger(__name__)
 
 
@@ -48,7 +49,7 @@ class TSTCommandExecutor:
         if not params:
             params = {}
 
-        logger.info(f"Executing command via TST: {command}, params: {params}")
+        get_global_logger().info(f"Executing command via TST: {command}, params: {params}")
 
         try:
             # Проверяем существование команды
@@ -64,10 +65,10 @@ class TSTCommandExecutor:
             # Возвращаем результат
             return result.to_dict()
         except NotFoundError as e:
-            logger.error(f"Command not found: {command}")
+            get_global_logger().error(f"Command not found: {command}")
             raise
         except Exception as e:
-            logger.exception(f"Error executing command {command}: {e}")
+            get_global_logger().exception(f"Error executing command {command}: {e}")
             raise
 
     @classmethod

mcp_proxy_adapter/commands/auth_validation_command.py

@@ -20,6 +20,7 @@ from ..commands.result import SuccessResult, ErrorResult
 from ..core.auth_validator import AuthValidator, AuthValidationResult
 
 
+from mcp_proxy_adapter.core.logging import get_global_logger
 class AuthValidationCommand(Command):
     """
     Authentication validation commands.
@@ -74,7 +75,7 @@ class AuthValidationCommand(Command):
                 )
 
         except Exception as e:
-            self.logger.error(f"Authentication validation error: {e}")
+            self.get_global_logger().error(f"Authentication validation error: {e}")
             return ErrorResult(
                 message=f"Internal authentication validation error: {str(e)}",
                 code=-32603,
@@ -115,7 +116,7 @@ class AuthValidationCommand(Command):
                 )
 
         except Exception as e:
-            self.logger.error(f"Certificate validation error: {e}")
+            self.get_global_logger().error(f"Certificate validation error: {e}")
             return ErrorResult(
                 message=f"Internal certificate validation error: {str(e)}", code=-32603
             )
@@ -154,7 +155,7 @@ class AuthValidationCommand(Command):
                 )
 
         except Exception as e:
-            self.logger.error(f"Token validation error: {e}")
+            self.get_global_logger().error(f"Token validation error: {e}")
             return ErrorResult(
                 message=f"Internal token validation error: {str(e)}", code=-32603
             )
@@ -194,7 +195,7 @@ class AuthValidationCommand(Command):
                 )
 
         except Exception as e:
-            self.logger.error(f"mTLS validation error: {e}")
+            self.get_global_logger().error(f"mTLS validation error: {e}")
             return ErrorResult(
                 message=f"Internal mTLS validation error: {str(e)}", code=-32603
             )
@@ -232,7 +233,7 @@ class AuthValidationCommand(Command):
                 )
 
         except Exception as e:
-            self.logger.error(f"SSL validation error: {e}")
+            self.get_global_logger().error(f"SSL validation error: {e}")
             return ErrorResult(
                 message=f"Internal SSL validation error: {str(e)}", code=-32603
             )