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

mcp_proxy_adapter/core/security_adapter.py

@@ -32,7 +32,7 @@ except ImportError:
     PermissionConfig = None
     RateLimitConfig = None
 
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 
 
 class SecurityAdapter:
@@ -55,9 +55,9 @@ class SecurityAdapter:
 
         if SECURITY_FRAMEWORK_AVAILABLE:
             self.security_manager = self._create_security_manager()
-            logger.info("Security adapter initialized with mcp_security_framework")
+            get_global_logger().info("Security adapter initialized with mcp_security_framework")
         else:
-            logger.warning("mcp_security_framework not available, using fallback mode")
+            get_global_logger().warning("mcp_security_framework not available, using fallback mode")
 
     def _create_security_manager(self) -> Optional[SecurityManager]:
         """
@@ -73,7 +73,7 @@ class SecurityAdapter:
             security_config = self._convert_config()
             return SecurityManager(security_config)
         except Exception as e:
-            logger.error(f"Failed to create SecurityManager: {e}")
+            get_global_logger().error(f"Failed to create SecurityManager: {e}")
             return None
 
     def _convert_config(self) -> SecurityConfig:
@@ -225,10 +225,10 @@ class SecurityAdapter:
         Returns:
             Validation result dictionary
         """
-        logger.debug(f"Security manager available: {self.security_manager is not None}")
+        get_global_logger().debug(f"Security manager available: {self.security_manager is not None}")
         if not self.security_manager:
             # Fallback validation when framework is not available
-            logger.debug("Using fallback validation")
+            get_global_logger().debug("Using fallback validation")
             return self._fallback_validation(request_data)
 
         try:
@@ -241,7 +241,7 @@ class SecurityAdapter:
             return result.to_dict()
 
         except Exception as e:
-            logger.error(f"Security validation failed: {e}")
+            get_global_logger().error(f"Security validation failed: {e}")
             return {
                 "is_valid": False,
                 "error_code": -32603,
@@ -286,21 +286,21 @@ class SecurityAdapter:
 
         # Check for API key in headers (FastAPI converts headers to lowercase)
         api_key = headers.get("x-api-key") or headers.get("X-API-Key")
-        logger.debug(f"API key from headers: {api_key}")
+        get_global_logger().debug(f"API key from headers: {api_key}")
 
         # Check for API key in query parameters
         if not api_key:
             api_key = query_params.get("api_key")
-            logger.debug(f"API key from query params: {api_key}")
+            get_global_logger().debug(f"API key from query params: {api_key}")
 
         # Check for API key in JSON-RPC body
         if not api_key and isinstance(body, dict):
             api_key = body.get("params", {}).get("api_key")
-            logger.debug(f"API key from body: {api_key}")
+            get_global_logger().debug(f"API key from body: {api_key}")
 
         # Get API keys from config
         api_keys = self._get_api_keys()
-        logger.debug(f"Available API keys: {list(api_keys.keys())}")
+        get_global_logger().debug(f"Available API keys: {list(api_keys.keys())}")
 
         if api_key and api_key in api_keys:
             return {
@@ -331,17 +331,17 @@ class SecurityAdapter:
         auth_config = security_config.get("auth", {})
         api_keys = auth_config.get("api_keys", {})
 
-        logger.debug(f"Security config: {security_config}")
-        logger.debug(f"Auth config: {auth_config}")
-        logger.debug(f"API keys from security config: {api_keys}")
+        get_global_logger().debug(f"Security config: {security_config}")
+        get_global_logger().debug(f"Auth config: {auth_config}")
+        get_global_logger().debug(f"API keys from security config: {api_keys}")
 
         # Fallback to legacy SSL config
         if not api_keys:
             ssl_config = self.config.get("ssl", {})
             api_keys = ssl_config.get("api_keys", {})
-            logger.debug(f"API keys from SSL config: {api_keys}")
+            get_global_logger().debug(f"API keys from SSL config: {api_keys}")
 
-        logger.info(f"Total API keys loaded: {len(api_keys)}")
+        get_global_logger().info(f"Total API keys loaded: {len(api_keys)}")
         return api_keys
 
     def create_middleware(self, framework: str = "fastapi"):
@@ -355,7 +355,7 @@ class SecurityAdapter:
             Middleware instance
         """
         if not self.security_manager:
-            logger.warning("Cannot create middleware: security framework not available")
+            get_global_logger().warning("Cannot create middleware: security framework not available")
             return None
 
         try:
@@ -368,7 +368,7 @@ class SecurityAdapter:
             else:
                 raise ValueError(f"Unsupported framework: {framework}")
         except Exception as e:
-            logger.error(f"Failed to create middleware: {e}")
+            get_global_logger().error(f"Failed to create middleware: {e}")
             return None
 
     def is_available(self) -> bool:

mcp_proxy_adapter/core/security_factory.py

@@ -8,7 +8,7 @@ and middleware components with proper configuration and error handling.
 import logging
 from typing import Dict, Any, Optional
 
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 from .security_adapter import SecurityAdapter
 
 
@@ -33,10 +33,10 @@ class SecurityFactory:
         """
         try:
             adapter = SecurityAdapter(config)
-            logger.info("Security adapter created successfully")
+            get_global_logger().info("Security adapter created successfully")
             return adapter
         except Exception as e:
-            logger.error(f"Failed to create security adapter: {e}")
+            get_global_logger().error(f"Failed to create security adapter: {e}")
             raise
 
     @staticmethod
@@ -54,7 +54,7 @@ class SecurityFactory:
             adapter = SecurityFactory.create_security_adapter(config)
             return adapter.security_manager
         except Exception as e:
-            logger.error(f"Failed to create security manager: {e}")
+            get_global_logger().error(f"Failed to create security manager: {e}")
             return None
 
     @staticmethod
@@ -74,14 +74,14 @@ class SecurityFactory:
             middleware = adapter.create_middleware(framework)
 
             if middleware:
-                logger.info(f"Security middleware created for {framework}")
+                get_global_logger().info(f"Security middleware created for {framework}")
             else:
-                logger.warning(f"Failed to create security middleware for {framework}")
+                get_global_logger().warning(f"Failed to create security middleware for {framework}")
 
             return middleware
 
         except Exception as e:
-            logger.error(f"Failed to create security middleware: {e}")
+            get_global_logger().error(f"Failed to create security middleware: {e}")
             return None
 
     @staticmethod
@@ -114,38 +114,38 @@ class SecurityFactory:
 
             # Validate required fields
             if not isinstance(security_config, dict):
-                logger.error("Security configuration must be a dictionary")
+                get_global_logger().error("Security configuration must be a dictionary")
                 return False
 
             # Validate auth configuration
             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
 
             # Validate SSL configuration
             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
 
             # Validate permissions configuration
             permissions_config = security_config.get("permissions", {})
             if not isinstance(permissions_config, dict):
-                logger.error("Permissions configuration must be a dictionary")
+                get_global_logger().error("Permissions configuration must be a dictionary")
                 return False
 
             # Validate rate limit configuration
             rate_limit_config = security_config.get("rate_limit", {})
             if not isinstance(rate_limit_config, dict):
-                logger.error("Rate limit configuration must be a dictionary")
+                get_global_logger().error("Rate limit configuration must be a dictionary")
                 return False
 
-            logger.info("Security configuration validation passed")
+            get_global_logger().info("Security configuration validation passed")
             return True
 
         except Exception as e:
-            logger.error(f"Configuration validation failed: {e}")
+            get_global_logger().error(f"Configuration validation failed: {e}")
             return False
 
     @staticmethod
@@ -218,11 +218,11 @@ class SecurityFactory:
             # Deep merge security configuration
             SecurityFactory._deep_merge(merged_config["security"], security_config)
 
-            logger.info("Security configuration merged successfully")
+            get_global_logger().info("Security configuration merged successfully")
             return merged_config
 
         except Exception as e:
-            logger.error(f"Failed to merge security configuration: {e}")
+            get_global_logger().error(f"Failed to merge security configuration: {e}")
             return base_config
 
     @staticmethod

mcp_proxy_adapter/core/security_integration.py

@@ -48,7 +48,7 @@ except ImportError:
     RateLimiter = None
     FastAPISecurityMiddleware = None
 
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 
 
 class SecurityIntegration:
@@ -81,7 +81,7 @@ class SecurityIntegration:
         self.certificate_manager = CertificateManager(self.security_config.certificates)
         self.rate_limiter = RateLimiter(self.security_config.rate_limit)
 
-        logger.info("Security integration initialized with mcp_security_framework")
+        get_global_logger().info("Security integration initialized with mcp_security_framework")
 
     def _create_security_config(self) -> SecurityConfig:
         """Create SecurityConfig from project configuration."""
@@ -126,7 +126,7 @@ class SecurityIntegration:
         if permissions_enabled:
             # If roles_file is None or empty string, don't pass it to avoid framework errors
             if roles_file is None or roles_file == "":
-                logger.warning(
+                get_global_logger().warning(
                     "roles_file is None or empty, permissions will use default configuration"
                 )
                 roles_file = None
@@ -292,7 +292,7 @@ class SecurityIntegration:
             return await self.certificate_manager.validate_certificate(cert_path)
 
         except Exception as e:
-            logger.error(f"Certificate validation failed: {e}")
+            get_global_logger().error(f"Certificate validation failed: {e}")
             return False
 
     async def extract_roles_from_certificate(self, cert_path: str) -> List[str]:
@@ -371,8 +371,8 @@ def create_security_integration(config: Dict[str, Any]) -> SecurityIntegration:
     try:
         return SecurityIntegration(config)
     except ImportError as e:
-        logger.error(f"mcp_security_framework not available: {e}")
+        get_global_logger().error(f"mcp_security_framework not available: {e}")
         raise RuntimeError("Security framework is required but not available") from e
     except Exception as e:
-        logger.error(f"Failed to create security integration: {e}")
+        get_global_logger().error(f"Failed to create security integration: {e}")
         raise RuntimeError(f"Security integration failed: {e}") from e

mcp_proxy_adapter/core/server_adapter.py

@@ -41,13 +41,13 @@ class ServerConfigAdapter:
         """
         engine = ServerEngineFactory.get_engine(target_engine)
         if not engine:
-            logger.error(f"Unknown server engine: {target_engine}")
+            get_global_logger().error(f"Unknown server engine: {target_engine}")
             return {}
 
         if target_engine == "hypercorn":
             return ServerConfigAdapter._convert_to_hypercorn_ssl(ssl_config)
         else:
-            logger.warning(f"No SSL conversion available for engine: {target_engine}")
+            get_global_logger().warning(f"No SSL conversion available for engine: {target_engine}")
             return {}
 
     @staticmethod
@@ -71,7 +71,7 @@ class ServerConfigAdapter:
         if "chk_hostname" in ssl_config:
             hypercorn_ssl["check_hostname"] = ssl_config["chk_hostname"]
 
-        logger.debug(f"Converted SSL config to hypercorn: {hypercorn_ssl}")
+        get_global_logger().debug(f"Converted SSL config to hypercorn: {hypercorn_ssl}")
         return hypercorn_ssl
 
     @staticmethod
@@ -104,7 +104,7 @@ class ServerConfigAdapter:
         """
         engine = ServerEngineFactory.get_engine(engine_name)
         if not engine:
-            logger.error(f"Unknown engine: {engine_name}")
+            get_global_logger().error(f"Unknown engine: {engine_name}")
             return False
 
         # Check SSL requirements
@@ -115,7 +115,7 @@ class ServerConfigAdapter:
 
         if ssl_config.get("verify_client", False):
             if not engine.get_supported_features().get("mtls_client_certs", False):
-                logger.error(
+                get_global_logger().error(
                     f"Engine {engine_name} doesn't support mTLS client certificates"
                 )
                 return False
@@ -163,8 +163,8 @@ class UnifiedServerRunner:
         self.default_engine = default_engine
         self.available_engines = ServerEngineFactory.get_available_engines()
 
-        logger.info(f"Available engines: {list(self.available_engines.keys())}")
-        logger.info(f"Default engine: {default_engine}")
+        get_global_logger().info(f"Available engines: {list(self.available_engines.keys())}")
+        get_global_logger().info(f"Default engine: {default_engine}")
 
     def run_server(
         self, app: Any, config: Dict[str, Any], engine_name: Optional[str] = None
@@ -179,7 +179,7 @@ class UnifiedServerRunner:
         """
         # Use hypercorn as the only supported engine
         selected_engine = "hypercorn"
-        logger.info(f"Using hypercorn engine")
+        get_global_logger().info(f"Using hypercorn engine")
 
         # Validate compatibility
         if not ServerConfigAdapter.validate_engine_compatibility(
@@ -198,16 +198,16 @@ class UnifiedServerRunner:
         converted_config = self._prepare_config_for_engine(config, selected_engine)
 
         # Run server
-        logger.info(f"Starting server with {selected_engine} engine")
+        get_global_logger().info(f"Starting server with {selected_engine} engine")
         engine.run_server(app, converted_config)
 
     def _prepare_config_for_engine(
         self, config: Dict[str, Any], engine_name: str
     ) -> Dict[str, Any]:
-        logger.info(
+        get_global_logger().info(
             f"🔍 Debug: _prepare_config_for_engine called with config keys: {list(config.keys())}"
         )
-        logger.info(f"🔍 Debug: SSL config in input: {config.get('ssl', 'NOT_FOUND')}")
+        get_global_logger().info(f"🔍 Debug: SSL config in input: {config.get('ssl', 'NOT_FOUND')}")
         """
         Prepare configuration for a specific engine.
         
@@ -234,7 +234,7 @@ class UnifiedServerRunner:
             or "ca_certs" in config
             or "verify_mode" in config
         ):
-            logger.info(f"🔍 DEBUG: Direct SSL parameters found in config")
+            get_global_logger().info(f"🔍 DEBUG: Direct SSL parameters found in config")
             if "certfile" in config:
                 engine_config["certfile"] = config["certfile"]
             if "keyfile" in config:

mcp_proxy_adapter/core/server_engine.py

@@ -115,7 +115,7 @@ class HypercornEngine(ServerEngine):
 
         for field in required_fields:
             if field not in config:
-                logger.error(f"Missing required field: {field}")
+                get_global_logger().error(f"Missing required field: {field}")
                 return False
 
         # Validate SSL files exist if specified
@@ -123,7 +123,7 @@ class HypercornEngine(ServerEngine):
         for ssl_file in ssl_files:
             if ssl_file in config and config[ssl_file]:
                 if not Path(config[ssl_file]).exists():
-                    logger.error(f"SSL file not found: {config[ssl_file]}")
+                    get_global_logger().error(f"SSL file not found: {config[ssl_file]}")
                     return False
 
         return True
@@ -142,17 +142,17 @@ class HypercornEngine(ServerEngine):
             }
 
             # Add SSL configuration if provided
-            logger.info(f"🔍 DEBUG: Input config keys: {list(config.keys())}")
-            logger.info(
+            get_global_logger().info(f"🔍 DEBUG: Input config keys: {list(config.keys())}")
+            get_global_logger().info(
                 f"🔍 DEBUG: Input config certfile: {config.get('certfile', 'NOT_FOUND')}"
             )
-            logger.info(
+            get_global_logger().info(
                 f"🔍 DEBUG: Input config keyfile: {config.get('keyfile', 'NOT_FOUND')}"
             )
-            logger.info(
+            get_global_logger().info(
                 f"🔍 DEBUG: Input config ca_certs: {config.get('ca_certs', 'NOT_FOUND')}"
             )
-            logger.info(
+            get_global_logger().info(
                 f"🔍 DEBUG: Input config verify_mode: {config.get('verify_mode', 'NOT_FOUND')}"
             )
 
@@ -184,15 +184,15 @@ class HypercornEngine(ServerEngine):
             if "workers" in config and config["workers"]:
                 hypercorn_config["workers"] = config["workers"]
 
-            logger.info(f"Starting hypercorn server with config: {hypercorn_config}")
-            logger.info(f"SSL config from input: {config.get('ssl', 'NOT_FOUND')}")
-            logger.info(
+            get_global_logger().info(f"Starting hypercorn server with config: {hypercorn_config}")
+            get_global_logger().info(f"SSL config from input: {config.get('ssl', 'NOT_FOUND')}")
+            get_global_logger().info(
                 f"Security SSL config: {config.get('security', {}).get('ssl', 'NOT_FOUND')}"
             )
-            logger.info(
+            get_global_logger().info(
                 f"🔍 DEBUG: Hypercorn verify_mode: {hypercorn_config.get('verify_mode', 'NOT_SET')}"
             )
-            logger.info(
+            get_global_logger().info(
                 f"🔍 DEBUG: Hypercorn ca_certs: {hypercorn_config.get('ca_certs', 'NOT_SET')}"
             )
 
@@ -205,10 +205,10 @@ class HypercornEngine(ServerEngine):
             asyncio.run(hypercorn.asyncio.serve(app, config_obj))
 
         except ImportError:
-            logger.error("hypercorn not installed. Install with: pip install hypercorn")
+            get_global_logger().error("hypercorn not installed. Install with: pip install hypercorn")
             raise
         except Exception as e:
-            logger.error(f"Failed to start hypercorn server: {e}")
+            get_global_logger().error(f"Failed to start hypercorn server: {e}")
             raise
 
 
@@ -230,7 +230,7 @@ class ServerEngineFactory:
             engine: Server engine instance to register
         """
         cls._engines[engine.get_name()] = engine
-        logger.info(f"Registered server engine: {engine.get_name()}")
+        get_global_logger().info(f"Registered server engine: {engine.get_name()}")
 
     @classmethod
     def get_engine(cls, name: str) -> Optional[ServerEngine]:
@@ -279,9 +279,9 @@ class ServerEngineFactory:
             import hypercorn
 
             cls.register_engine(HypercornEngine())
-            logger.info("Hypercorn engine registered (full mTLS support available)")
+            get_global_logger().info("Hypercorn engine registered (full mTLS support available)")
         except ImportError:
-            logger.error("Hypercorn not available - this is required for the framework")
+            get_global_logger().error("Hypercorn not available - this is required for the framework")
             raise
 
 

mcp_proxy_adapter/core/signal_handler.py

@@ -12,7 +12,7 @@ import signal
 import asyncio
 import threading
 from typing import Optional, Callable, Any
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 
 
 class SignalHandler:
@@ -35,7 +35,7 @@ class SignalHandler:
             callback: Function to call during shutdown
         """
         self._shutdown_callback = callback
-        logger.info("Shutdown callback set for signal handler")
+        get_global_logger().info("Shutdown callback set for signal handler")
     
     def _setup_signal_handlers(self):
         """Setup signal handlers for graceful shutdown."""
@@ -54,7 +54,7 @@ class SignalHandler:
             signal.SIGHUP, self._handle_shutdown_signal
         )
         
-        logger.info("Signal handlers installed for SIGTERM, SIGINT, SIGHUP")
+        get_global_logger().info("Signal handlers installed for SIGTERM, SIGINT, SIGHUP")
     
     def _handle_shutdown_signal(self, signum: int, frame: Any):
         """
@@ -65,7 +65,7 @@ class SignalHandler:
             frame: Current stack frame
         """
         signal_name = signal.Signals(signum).name
-        logger.info(f"🛑 Received {signal_name} signal, initiating graceful shutdown...")
+        get_global_logger().info(f"🛑 Received {signal_name} signal, initiating graceful shutdown...")
         
         # Set shutdown event
         self._shutdown_event.set()
@@ -73,23 +73,23 @@ class SignalHandler:
         # Call shutdown callback if set
         if self._shutdown_callback:
             try:
-                logger.info("🔄 Executing shutdown callback...")
+                get_global_logger().info("🔄 Executing shutdown callback...")
                 self._shutdown_callback()
-                logger.info("✅ Shutdown callback completed successfully")
+                get_global_logger().info("✅ Shutdown callback completed successfully")
             except Exception as e:
-                logger.error(f"❌ Shutdown callback failed: {e}")
+                get_global_logger().error(f"❌ Shutdown callback failed: {e}")
         
         # Force exit immediately to avoid server hang
-        logger.info("🔄 Force exiting to avoid server hang...")
+        get_global_logger().info("🔄 Force exiting to avoid server hang...")
         import os
         # Use os._exit for immediate termination
-        logger.warning("⚠️ Using os._exit for immediate termination...")
+        get_global_logger().warning("⚠️ Using os._exit for immediate termination...")
         os._exit(0)
     
     def _force_exit(self):
         """Force exit if graceful shutdown takes too long."""
         if self._shutdown_event.is_set():
-            logger.warning("⚠️ Forcing exit after timeout")
+            get_global_logger().warning("⚠️ Forcing exit after timeout")
             import os
             os._exit(1)
     
@@ -119,7 +119,7 @@ class SignalHandler:
         for sig, handler in self._original_handlers.items():
             if handler is not None:
                 signal.signal(sig, handler)
-        logger.info("Original signal handlers restored")
+        get_global_logger().info("Original signal handlers restored")
 
 
 # Global signal handler instance
@@ -144,7 +144,7 @@ def setup_signal_handling(shutdown_callback: Optional[Callable] = None):
     handler = get_signal_handler()
     if shutdown_callback:
         handler.set_shutdown_callback(shutdown_callback)
-    logger.info("Signal handling setup completed")
+    get_global_logger().info("Signal handling setup completed")
 
 
 def wait_for_shutdown_signal(timeout: Optional[float] = None) -> bool:

mcp_proxy_adapter/core/ssl_utils.py

@@ -90,7 +90,7 @@ class SSLUtils:
                         f"Certificate is revoked according to CRL: {cert_file}"
                     )
             except Exception as e:
-                logger.error(f"CRL check failed: {e}")
+                get_global_logger().error(f"CRL check failed: {e}")
                 # For security, fail if CRL check fails
                 raise ValueError(f"CRL validation failed: {e}")
 
@@ -128,7 +128,7 @@ class SSLUtils:
         # Setup TLS versions
         SSLUtils.setup_tls_versions(context, min_tls_version, max_tls_version)
 
-        logger.info(f"SSL context created successfully with cert: {cert_file}")
+        get_global_logger().info(f"SSL context created successfully with cert: {cert_file}")
         return context
 
     @staticmethod
@@ -156,18 +156,18 @@ class SSLUtils:
                 try:
                     crl_manager = CRLManager(crl_config)
                     if crl_manager.is_certificate_revoked(cert_file):
-                        logger.warning(
+                        get_global_logger().warning(
                             f"Certificate is revoked according to CRL: {cert_file}"
                         )
                         return False
                 except Exception as e:
-                    logger.error(f"CRL check failed: {e}")
+                    get_global_logger().error(f"CRL check failed: {e}")
                     # For security, consider certificate invalid if CRL check fails
                     return False
 
             return True
         except Exception as e:
-            logger.error(f"Certificate validation failed: {e}")
+            get_global_logger().error(f"Certificate validation failed: {e}")
             return False
 
     @staticmethod
@@ -188,14 +188,14 @@ class SSLUtils:
             if cipher_name in SSLUtils.CIPHER_SUITES:
                 actual_ciphers.append(SSLUtils.CIPHER_SUITES[cipher_name])
             else:
-                logger.warning(f"Unknown cipher suite: {cipher_name}")
+                get_global_logger().warning(f"Unknown cipher suite: {cipher_name}")
 
         if actual_ciphers:
             try:
                 context.set_ciphers(":".join(actual_ciphers))
-                logger.info(f"Cipher suites configured: {actual_ciphers}")
+                get_global_logger().info(f"Cipher suites configured: {actual_ciphers}")
             except ssl.SSLError as e:
-                logger.error(f"Failed to set cipher suites: {e}")
+                get_global_logger().error(f"Failed to set cipher suites: {e}")
 
     @staticmethod
     def setup_tls_versions(
@@ -216,13 +216,13 @@ class SSLUtils:
             if min_tls and max_tls:
                 context.minimum_version = min_tls
                 context.maximum_version = max_tls
-                logger.info(f"TLS versions configured: {min_version} - {max_version}")
+                get_global_logger().info(f"TLS versions configured: {min_version} - {max_version}")
             else:
-                logger.warning(
+                get_global_logger().warning(
                     f"Invalid TLS version range: {min_version} - {max_version}"
                 )
         except Exception as e:
-            logger.error(f"Failed to set TLS versions: {e}")
+            get_global_logger().error(f"Failed to set TLS versions: {e}")
 
     @staticmethod
     def check_tls_version(min_version: str, max_version: str) -> bool:
@@ -275,5 +275,5 @@ class SSLUtils:
         if ssl_config.get("verify_client", False):
             hypercorn_ssl["verify_mode"] = "CERT_REQUIRED"
 
-        logger.info(f"Generated hypercorn SSL config: {hypercorn_ssl}")
+        get_global_logger().info(f"Generated hypercorn SSL config: {hypercorn_ssl}")
         return hypercorn_ssl