mcp-proxy-adapter 6.9.16__py3-none-any.whl → 6.9.18__py3-none-any.whl

mcp_proxy_adapter/api/app.py

@@ -35,7 +35,7 @@ from mcp_proxy_adapter.api.schemas import (
 from mcp_proxy_adapter.api.tools import get_tool_description, execute_tool
 from mcp_proxy_adapter.config import config
 from mcp_proxy_adapter.core.errors import MicroserviceError, NotFoundError
-from mcp_proxy_adapter.core.logging import logger, RequestLogger
+from mcp_proxy_adapter.core.logging import get_global_logger, RequestLogger
 from mcp_proxy_adapter.core.ssl_utils import SSLUtils
 from mcp_proxy_adapter.commands.command_registry import registry
 from mcp_proxy_adapter.custom_openapi import custom_openapi_with_fallback
@@ -76,13 +76,13 @@ def _determine_registration_url(config: Dict[str, Any]) -> str:
         # Use protocol from registration configuration
         # Convert mtls to https for URL construction (mTLS is still HTTPS)
         protocol = "https" if registration_protocol == "mtls" else registration_protocol
-        logger.info(f"🔍 Using registration.protocol: {registration_protocol} -> {protocol}")
+        get_global_logger().info(f"🔍 Using registration.protocol: {registration_protocol} -> {protocol}")
     else:
         # Fallback to server protocol
         verify_client = config.get("transport", {}).get("verify_client", False)
         ssl_enabled = server_protocol in ["https", "mtls"] or verify_client
         protocol = "https" if ssl_enabled else "http"
-        logger.info(f"⚠️  Fallback to server.protocol: {server_protocol} -> {protocol} (verify_client={verify_client})")
+        get_global_logger().info(f"⚠️  Fallback to server.protocol: {server_protocol} -> {protocol} (verify_client={verify_client})")
     
     # Determine host
     if not public_host:
@@ -108,7 +108,7 @@ def _determine_registration_url(config: Dict[str, Any]) -> str:
     # Build URL
     server_url = f"{protocol}://{resolved_host}:{resolved_port}"
     
-    logger.info(
+    get_global_logger().info(
         "🔍 Registration URL selection: server_host=%s, server_port=%s, public_host=%s, public_port=%s, protocol=%s, resolved_host=%s, resolved_port=%s, server_url=%s",
         server_host, server_port, public_host, public_port, protocol, resolved_host, resolved_port, server_url
     )
@@ -187,14 +187,14 @@ def create_lifespan(config_path: Optional[str] = None, current_config: Optional[
             )
 
             # Initialize proxy registration
-            initialize_proxy_registration()
-            logger.info(
+            initialize_proxy_registration(config_to_use)
+            get_global_logger().info(
                 "🔍 Initialized proxy registration with server_url: %s",
                 early_server_url,
             )
             
         except Exception as e:
-            logger.error(f"Failed to initialize async registration: {e}")
+            get_global_logger().error(f"Failed to initialize async registration: {e}")
 
         # Initialize system using unified logic (may perform registration)
         # Set global config for reload_system
@@ -212,16 +212,16 @@ def create_lifespan(config_path: Optional[str] = None, current_config: Optional[
         else:
             init_result = await registry.reload_system(config_obj=config_obj)
 
-        logger.info(
+        get_global_logger().info(
             f"Application started with {init_result['total_commands']} commands registered"
         )
-        logger.info(f"System initialization result: {init_result}")
+        get_global_logger().info(f"System initialization result: {init_result}")
 
         # Proxy registration manager is already initialized in registry.reload_system()
 
         # Recompute registration URL AFTER config reload using final config
         try:
-            final_config = config.get_all()
+            final_config = config_to_use  # config_to_use is already a dict
             server_config = final_config.get("server", {})
             server_host = server_config.get("host", "0.0.0.0")
             server_port = server_config.get("port", 8000)
@@ -231,55 +231,57 @@ def create_lifespan(config_path: Optional[str] = None, current_config: Optional[
             
             # Update proxy registration with final server URL
             try:
-                logger.info(f"🔍 Updated proxy registration with final server_url: {server_url}")
+                get_global_logger().info(f"🔍 Updated proxy registration with final server_url: {server_url}")
                     
             except Exception as e:
-                logger.error(f"Failed to update proxy registration: {e}")
+                get_global_logger().error(f"Failed to update proxy registration: {e}")
             
             try:
                 print("🔍 Registration server_url resolved to (print):", server_url)
             except Exception:
                 pass
         except Exception as e:
-            logger.error(f"Failed to recompute registration URL: {e}")
+            get_global_logger().error(f"Failed to recompute registration URL: {e}")
             server_url = early_server_url
 
         # Proxy registration is now handled in registry.reload_system() 
         # after all commands are loaded, ensuring complete command schema
-        logger.info("ℹ️ Proxy registration will be handled after command loading completes")
+        get_global_logger().info("ℹ️ Proxy registration will be handled after command loading completes")
         
         # Add delayed registration task to allow server to fully start
         async def delayed_registration():
             """Delayed registration to ensure server is fully started."""
             await asyncio.sleep(2)  # Wait for server to start listening
-            logger.info("🔄 Attempting delayed proxy registration after server startup")
+            get_global_logger().info("🔄 Attempting delayed proxy registration after server startup")
             try:
-                from mcp_proxy_adapter.core.proxy_registration import register_with_proxy
+                from mcp_proxy_adapter.core.proxy_registration import register_with_proxy, initialize_proxy_registration
+                # Ensure proxy registration manager is initialized
+                initialize_proxy_registration(config_to_use)
                 success = await register_with_proxy(server_url)
                 if success:
-                    logger.info("✅ Delayed proxy registration successful")
+                    get_global_logger().info("✅ Delayed proxy registration successful")
                 else:
-                    logger.warning("⚠️ Delayed proxy registration failed")
+                    get_global_logger().warning("⚠️ Delayed proxy registration failed")
             except Exception as e:
-                logger.error(f"❌ Delayed proxy registration error: {e}")
+                get_global_logger().error(f"❌ Delayed proxy registration error: {e}")
         
         asyncio.create_task(delayed_registration())
 
         yield  # Application is running
 
         # Shutdown events
-        logger.info("Application shutting down")
+        get_global_logger().info("Application shutting down")
 
         # Stop proxy registration (this will also unregister)
         try:
             unregistration_success = await unregister_from_proxy()
             if unregistration_success:
-                logger.info("✅ Proxy unregistration completed successfully")
+                get_global_logger().info("✅ Proxy unregistration completed successfully")
             else:
-                logger.warning("⚠️ Proxy unregistration failed or was disabled")
+                get_global_logger().warning("⚠️ Proxy unregistration failed or was disabled")
             
         except Exception as e:
-            logger.error(f"❌ Failed to stop proxy registration: {e}")
+            get_global_logger().error(f"❌ Failed to stop proxy registration: {e}")
 
     return lifespan
 
@@ -304,7 +306,7 @@ def create_ssl_context(
     ssl_enabled = protocol in ["https", "mtls"] or verify_client
 
     if not ssl_enabled:
-        logger.info("SSL is disabled in configuration")
+        get_global_logger().info("SSL is disabled in configuration")
         return None
 
     # Get certificate paths from configuration
@@ -324,7 +326,7 @@ def create_ssl_context(
         ca_cert = str(project_root / ca_cert)
 
     if not cert_file or not key_file:
-        logger.warning("SSL enabled but certificate or key file not specified")
+        get_global_logger().warning("SSL enabled but certificate or key file not specified")
         return None
 
     try:
@@ -339,13 +341,13 @@ def create_ssl_context(
             max_tls_version="1.3",
         )
 
-        logger.info(
+        get_global_logger().info(
             f"SSL context created successfully for mode: https_only"
         )
         return ssl_context
 
     except Exception as e:
-        logger.error(f"Failed to create SSL context: {e}")
+        get_global_logger().error(f"Failed to create SSL context: {e}")
         return None
 
 
@@ -419,14 +421,14 @@ def create_app(
         warnings = [r for r in _validation_results if r.level == "warning"]
         
         if errors:
-            logger.critical("CRITICAL CONFIG ERROR: Invalid configuration at startup:")
+            get_global_logger().critical("CRITICAL CONFIG ERROR: Invalid configuration at startup:")
             for _e in errors:
-                logger.critical(f"  - {_e.message}")
+                get_global_logger().critical(f"  - {_e.message}")
             raise SystemExit(1)
         for _w in warnings:
-            logger.warning(f"Config warning: {_w.message}")
+            get_global_logger().warning(f"Config warning: {_w.message}")
     except Exception as _ex:
-        logger.error(f"Failed to run startup configuration validation: {_ex}")
+        get_global_logger().error(f"Failed to run startup configuration validation: {_ex}")
 
     # Security check: Validate all authentication configurations before startup (legacy checks kept for compatibility)
     security_errors = []
@@ -560,13 +562,13 @@ def create_app(
 
     # If there are security errors, block startup
     if security_errors:
-        logger.critical(
+        get_global_logger().critical(
             "CRITICAL SECURITY ERROR: Authentication configuration issues detected:"
         )
         for error in security_errors:
-            logger.critical(f"  - {error}")
-        logger.critical("Server startup blocked for security reasons.")
-        logger.critical(
+            get_global_logger().critical(f"  - {error}")
+        get_global_logger().critical("Server startup blocked for security reasons.")
+        get_global_logger().critical(
             "Please fix authentication configuration or disable authentication features."
         )
         raise SystemExit(1)
@@ -590,11 +592,11 @@ def create_app(
     # This ensures commands are available before the server starts accepting requests
     try:
         from mcp_proxy_adapter.commands.builtin_commands import register_builtin_commands
-        logger.info("Registering built-in commands during app creation...")
+        get_global_logger().info("Registering built-in commands during app creation...")
         registered_count = register_builtin_commands()
-        logger.info(f"Registered {registered_count} built-in commands during app creation")
+        get_global_logger().info(f"Registered {registered_count} built-in commands during app creation")
     except Exception as e:
-        logger.error(f"Failed to register built-in commands during app creation: {e}")
+        get_global_logger().error(f"Failed to register built-in commands during app creation: {e}")
         # Don't fail app creation, but log the error
 
     # Configure CORS
@@ -609,13 +611,13 @@ def create_app(
     # Add request logging middleware for debugging
     @app.middleware("http")
     async def debug_request_middleware(request: Request, call_next):
-        logger.debug(f"FastAPI Request START: {request.method} {request.url.path}")
+        get_global_logger().debug(f"FastAPI Request START: {request.method} {request.url.path}")
         try:
             response = await call_next(request)
-            logger.debug(f"FastAPI Request COMPLETED: {response.status_code}")
+            get_global_logger().debug(f"FastAPI Request COMPLETED: {response.status_code}")
             return response
         except Exception as e:
-            logger.error(f"FastAPI Request ERROR: {e}", exc_info=True)
+            get_global_logger().error(f"FastAPI Request ERROR: {e}", exc_info=True)
             raise
 
     # Setup middleware using the new middleware package
@@ -624,11 +626,11 @@ def create_app(
     # Add request logging middleware
     # @app.middleware("http")
     # async def log_requests(request: Request, call_next):
-    #     logger.info(f"🔍 REQUEST LOG: {request.method} {request.url.path}")
-    #     logger.info(f"🔍 REQUEST LOG: Headers: {dict(request.headers)}")
-    #     logger.info(f"🔍 REQUEST LOG: Client: {request.client}")
+    #     get_global_logger().info(f"🔍 REQUEST LOG: {request.method} {request.url.path}")
+    #     get_global_logger().info(f"🔍 REQUEST LOG: Headers: {dict(request.headers)}")
+    #     get_global_logger().info(f"🔍 REQUEST LOG: Client: {request.client}")
     #     response = await call_next(request)
-    #     logger.info(f"🔍 RESPONSE LOG: Status: {response.status_code}")
+    #     get_global_logger().info(f"🔍 RESPONSE LOG: Status: {response.status_code}")
     #     return response
 
     # Use custom OpenAPI schema
@@ -662,8 +664,8 @@ def create_app(
         # Get request_id from middleware state
         request_id = getattr(request.state, "request_id", None)
 
-        # Create request logger for this endpoint
-        req_logger = RequestLogger(__name__, request_id) if request_id else logger
+        # Create request get_global_logger() for this endpoint
+        req_logger = RequestLogger(__name__, request_id) if request_id else get_global_logger()
 
         # Check if it's a batch request
         if isinstance(request_data, list):
@@ -714,8 +716,8 @@ def create_app(
         # Get request_id from middleware state
         request_id = getattr(request.state, "request_id", None)
 
-        # Create request logger for this endpoint
-        req_logger = RequestLogger(__name__, request_id) if request_id else logger
+        # Create request get_global_logger() for this endpoint
+        req_logger = RequestLogger(__name__, request_id) if request_id else get_global_logger()
 
         try:
             # Determine request format (CommandRequest or JSON-RPC)
@@ -873,8 +875,8 @@ def create_app(
         # Get request_id from middleware state
         request_id = getattr(request.state, "request_id", None)
 
-        # Create request logger for this endpoint
-        req_logger = RequestLogger(__name__, request_id) if request_id else logger
+        # Create request get_global_logger() for this endpoint
+        req_logger = RequestLogger(__name__, request_id) if request_id else get_global_logger()
 
         try:
             command_info = registry.get_command_info(command_name)
@@ -920,12 +922,12 @@ def create_app(
                 return description
 
         except NotFoundError as e:
-            logger.warning(f"Tool not found: {tool_name}")
+            get_global_logger().warning(f"Tool not found: {tool_name}")
             return JSONResponse(
                 status_code=404, content={"error": {"code": 404, "message": str(e)}}
             )
         except Exception as e:
-            logger.exception(f"Error generating tool description: {e}")
+            get_global_logger().exception(f"Error generating tool description: {e}")
             return JSONResponse(
                 status_code=500,
                 content={
@@ -950,12 +952,12 @@ def create_app(
             result = await execute_tool(tool_name, **params)
             return result
         except NotFoundError as e:
-            logger.warning(f"Tool not found: {tool_name}")
+            get_global_logger().warning(f"Tool not found: {tool_name}")
             return JSONResponse(
                 status_code=404, content={"error": {"code": 404, "message": str(e)}}
             )
         except Exception as e:
-            logger.exception(f"Error executing tool {tool_name}: {e}")
+            get_global_logger().exception(f"Error executing tool {tool_name}: {e}")
             return JSONResponse(
                 status_code=500,
                 content={

mcp_proxy_adapter/api/handlers.py

@@ -21,7 +21,7 @@ from mcp_proxy_adapter.core.errors import (
     InternalError,
     CommandError,
 )
-from mcp_proxy_adapter.core.logging import logger, RequestLogger, get_logger
+from mcp_proxy_adapter.core.logging import get_global_logger, RequestLogger, get_logger
 
 
 async def execute_command(
@@ -45,8 +45,8 @@ async def execute_command(
         MethodNotFoundError: If command is not found.
         MicroserviceError: In case of command execution error.
     """
-    # Create request logger if request_id is provided
-    log = RequestLogger(__name__, request_id) if request_id else logger
+    # Create request get_global_logger() if request_id is provided
+    log = RequestLogger(__name__, request_id) if request_id else get_global_logger()
 
     try:
         log.info(f"Executing command: {command_name}")
@@ -155,8 +155,8 @@ async def handle_json_rpc(
     Returns:
         JSON-RPC response.
     """
-    # Create request logger if request_id is provided
-    log = RequestLogger(__name__, request_id) if request_id else logger
+    # Create request get_global_logger() if request_id is provided
+    log = RequestLogger(__name__, request_id) if request_id else get_global_logger()
 
     # Support both standard JSON-RPC and simplified formats
     method = None

mcp_proxy_adapter/api/middleware/__init__.py

@@ -6,7 +6,7 @@ This package contains middleware components for request processing.
 from typing import Dict, Any, Optional
 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.config import config
 from .base import BaseMiddleware
 from .factory import MiddlewareFactory
@@ -39,10 +39,10 @@ def setup_middleware(app: FastAPI, app_config: Optional[Dict[str, Any]] = None)
 
     # Validate middleware configuration
     if not factory.validate_middleware_config():
-        logger.error("Middleware configuration validation failed")
+        get_global_logger().error("Middleware configuration validation failed")
         raise SystemExit(1)
 
-    logger.info("Using unified security middleware")
+    get_global_logger().info("Using unified security middleware")
     middleware_list = factory.create_all_middleware()
 
     # Add middleware to application AFTER protocol middleware
@@ -52,13 +52,13 @@ def setup_middleware(app: FastAPI, app_config: Optional[Dict[str, Any]] = None)
             # This is a proper ASGI middleware
             app.middleware("http")(middleware.dispatch)
         else:
-            logger.warning(
+            get_global_logger().warning(
                 f"Middleware {middleware.__class__.__name__} doesn't have dispatch method"
             )
 
     # Log middleware information
     middleware_info = factory.get_middleware_info()
-    logger.info(f"Middleware setup completed:")
-    logger.info(f"  - Total middleware: {middleware_info['total_middleware']}")
-    logger.info(f"  - Types: {', '.join(middleware_info['middleware_types'])}")
-    logger.info(f"  - Security enabled: {middleware_info['security_enabled']}")
+    get_global_logger().info(f"Middleware setup completed:")
+    get_global_logger().info(f"  - Total middleware: {middleware_info['total_middleware']}")
+    get_global_logger().info(f"  - Types: {', '.join(middleware_info['middleware_types'])}")
+    get_global_logger().info(f"  - Security enabled: {middleware_info['security_enabled']}")

mcp_proxy_adapter/api/middleware/base.py

@@ -8,7 +8,7 @@ import logging
 from starlette.middleware.base import BaseHTTPMiddleware
 from fastapi import Request, Response
 
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 
 
 class BaseMiddleware(BaseHTTPMiddleware):
@@ -30,32 +30,32 @@ class BaseMiddleware(BaseHTTPMiddleware):
             Response.
         """
         middleware_name = self.__class__.__name__
-        logger.info(f"🔍 STEP 1: {middleware_name}.dispatch START - {request.method} {request.url.path}")
-        logger.info(f"🔍 STEP 1.1: {middleware_name} - Request headers: {dict(request.headers)}")
-        logger.info(f"🔍 STEP 1.2: {middleware_name} - Request URL: {request.url}")
-        logger.info(f"🔍 STEP 1.3: {middleware_name} - Request scope: {request.scope}")
+        get_global_logger().info(f"🔍 STEP 1: {middleware_name}.dispatch START - {request.method} {request.url.path}")
+        get_global_logger().info(f"🔍 STEP 1.1: {middleware_name} - Request headers: {dict(request.headers)}")
+        get_global_logger().info(f"🔍 STEP 1.2: {middleware_name} - Request URL: {request.url}")
+        get_global_logger().info(f"🔍 STEP 1.3: {middleware_name} - Request scope: {request.scope}")
         
         try:
             # Process request before calling the main handler
-            logger.info(f"🔍 STEP 2: {middleware_name}.before_request START")
+            get_global_logger().info(f"🔍 STEP 2: {middleware_name}.before_request START")
             await self.before_request(request)
-            logger.info(f"🔍 STEP 3: {middleware_name}.before_request COMPLETED")
+            get_global_logger().info(f"🔍 STEP 3: {middleware_name}.before_request COMPLETED")
 
             # Call the next middleware or main handler
-            logger.info(f"🔍 STEP 4: {middleware_name}.call_next START - About to call next middleware/endpoint")
+            get_global_logger().info(f"🔍 STEP 4: {middleware_name}.call_next START - About to call next middleware/endpoint")
             response = await call_next(request)
-            logger.info(f"🔍 STEP 5: {middleware_name}.call_next COMPLETED - Status: {response.status_code}")
-            logger.info(f"🔍 STEP 5.1: {middleware_name} - Response headers: {dict(response.headers)}")
+            get_global_logger().info(f"🔍 STEP 5: {middleware_name}.call_next COMPLETED - Status: {response.status_code}")
+            get_global_logger().info(f"🔍 STEP 5.1: {middleware_name} - Response headers: {dict(response.headers)}")
 
             # Process response after calling the main handler
-            logger.info(f"🔍 STEP 6: {middleware_name}.after_response START")
+            get_global_logger().info(f"🔍 STEP 6: {middleware_name}.after_response START")
             response = await self.after_response(request, response)
-            logger.info(f"🔍 STEP 7: {middleware_name}.after_response COMPLETED")
+            get_global_logger().info(f"🔍 STEP 7: {middleware_name}.after_response COMPLETED")
 
-            logger.info(f"🔍 STEP 8: {middleware_name}.dispatch COMPLETED SUCCESSFULLY")
+            get_global_logger().info(f"🔍 STEP 8: {middleware_name}.dispatch COMPLETED SUCCESSFULLY")
             return response
         except Exception as e:
-            logger.error(f"❌ STEP ERROR: {middleware_name}.dispatch ERROR: {str(e)}", exc_info=True)
+            get_global_logger().error(f"❌ STEP ERROR: {middleware_name}.dispatch ERROR: {str(e)}", exc_info=True)
             # If an error occurred, call the error handler
             return await self.handle_error(request, e)
 

mcp_proxy_adapter/api/middleware/command_permission_middleware.py

@@ -13,7 +13,7 @@ from typing import Dict, Any, Optional, 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
 
 
 class CommandPermissionMiddleware(BaseHTTPMiddleware):
@@ -45,7 +45,7 @@ class CommandPermissionMiddleware(BaseHTTPMiddleware):
             # Add more commands as needed
         }
 
-        logger.info("Command permission middleware initialized")
+        get_global_logger().info("Command permission middleware initialized")
 
     async def dispatch(
         self, request: Request, call_next: Callable[[Request], Awaitable[Response]]
@@ -90,13 +90,13 @@ class CommandPermissionMiddleware(BaseHTTPMiddleware):
             # Get user info from request state
             user_info = getattr(request.state, "user", None)
             if not user_info:
-                logger.warning(f"No user info found for command {method}")
+                get_global_logger().warning(f"No user info found for command {method}")
                 return await call_next(request)
 
             user_roles = user_info.get("roles", [])
             user_permissions = user_info.get("permissions", [])
 
-            logger.debug(
+            get_global_logger().debug(
                 f"Checking permissions for {method}: user_roles={user_roles}, required={required_permissions}"
             )
 
@@ -106,7 +106,7 @@ class CommandPermissionMiddleware(BaseHTTPMiddleware):
             )
 
             if not has_permission:
-                logger.warning(
+                get_global_logger().warning(
                     f"Permission denied for {method}: user_roles={user_roles}, required={required_permissions}"
                 )
 
@@ -125,11 +125,11 @@ class CommandPermissionMiddleware(BaseHTTPMiddleware):
                     media_type="application/json",
                 )
 
-            logger.debug(f"Permission granted for {method}")
+            get_global_logger().debug(f"Permission granted for {method}")
             return await call_next(request)
 
         except Exception as e:
-            logger.error(f"Error in command permission middleware: {e}")
+            get_global_logger().error(f"Error in command permission middleware: {e}")
             return await call_next(request)
 
     def _check_permissions(

mcp_proxy_adapter/api/middleware/error_handling.py

@@ -8,7 +8,7 @@ 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.logging import get_global_logger
 from mcp_proxy_adapter.core.errors import (
     MicroserviceError,
     CommandError,
@@ -44,18 +44,18 @@ class ErrorHandlingMiddleware(BaseMiddleware):
         Returns:
             Response.
         """
-        logger.debug(f"🔍 ErrorHandlingMiddleware.dispatch START - {request.method} {request.url.path}")
+        get_global_logger().debug(f"🔍 ErrorHandlingMiddleware.dispatch START - {request.method} {request.url.path}")
         try:
             # Call the next middleware or main handler
-            logger.debug(f"🔍 ErrorHandlingMiddleware - About to call next handler")
+            get_global_logger().debug(f"🔍 ErrorHandlingMiddleware - About to call next handler")
             response = await call_next(request)
-            logger.debug(f"🔍 ErrorHandlingMiddleware - Next handler completed with status: {response.status_code}")
+            get_global_logger().debug(f"🔍 ErrorHandlingMiddleware - Next handler completed with status: {response.status_code}")
             return response
 
         except CommandError as e:
             # Command error
             request_id = getattr(request.state, "request_id", "unknown")
-            logger.debug(f"[{request_id}] Command error: {str(e)}")
+            get_global_logger().debug(f"[{request_id}] Command error: {str(e)}")
 
             # Проверяем, является ли запрос JSON-RPC
             is_jsonrpc = self._is_json_rpc_request(request)
@@ -84,7 +84,7 @@ class ErrorHandlingMiddleware(BaseMiddleware):
         except ValidationError as e:
             # Validation error
             request_id = getattr(request.state, "request_id", "unknown")
-            logger.debug(f"[{request_id}] Validation error: {str(e)}")
+            get_global_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)
@@ -110,7 +110,7 @@ class ErrorHandlingMiddleware(BaseMiddleware):
         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_global_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)
@@ -136,7 +136,7 @@ class ErrorHandlingMiddleware(BaseMiddleware):
         except Exception as e:
             # Unexpected error
             request_id = getattr(request.state, "request_id", "unknown")
-            logger.debug(f"[{request_id}] Unexpected error: {str(e)}")
+            get_global_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)
@@ -197,6 +197,6 @@ class ErrorHandlingMiddleware(BaseMiddleware):
                 request.state.json_rpc_id = request_id
                 return request_id
         except Exception as e:
-            logger.warning(f"Error parsing JSON-RPC ID: {str(e)}")
+            get_global_logger().warning(f"Error parsing JSON-RPC ID: {str(e)}")
 
         return None