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

mcp_proxy_adapter/core/protocol_manager.py

@@ -10,7 +10,7 @@ from typing import Dict, List, Optional, Tuple, Union
 from urllib.parse import urlparse
 
 from mcp_proxy_adapter.config import config
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 
 
 class ProtocolManager:
@@ -37,31 +37,31 @@ class ProtocolManager:
         current_config = (
             self.app_config if self.app_config is not None else config.get_all()
         )
-        logger.debug(
+        get_global_logger().debug(
             f"ProtocolManager._load_config - current_config type: {type(current_config)}"
         )
 
         if not hasattr(current_config, "get"):
             # Not a dict-like config, fallback to global
-            logger.debug(
+            get_global_logger().debug(
                 f"ProtocolManager._load_config - current_config is not dict-like, falling back to global config"
             )
             current_config = config.get_all()
 
-        logger.debug(
+        get_global_logger().debug(
             f"ProtocolManager._load_config - final current_config type: {type(current_config)}"
         )
         if hasattr(current_config, "get"):
-            logger.debug(
+            get_global_logger().debug(
                 f"ProtocolManager._load_config - current_config keys: {list(current_config.keys()) if hasattr(current_config, 'keys') else 'no keys'}"
             )
 
         # Get server protocol configuration (new simplified structure)
-        logger.debug(f"ProtocolManager._load_config - before getting server protocol")
+        get_global_logger().debug(f"ProtocolManager._load_config - before getting server protocol")
         try:
             server_config = current_config.get("server", {})
             server_protocol = server_config.get("protocol", "http")
-            logger.debug(f"ProtocolManager._load_config - server protocol: {server_protocol}")
+            get_global_logger().debug(f"ProtocolManager._load_config - server protocol: {server_protocol}")
             
             # Set allowed protocols based on server protocol
             if server_protocol == "http":
@@ -73,19 +73,19 @@ class ProtocolManager:
             else:
                 # Fallback to HTTP
                 self.allowed_protocols = ["http"]
-                logger.warning(f"Unknown server protocol '{server_protocol}', defaulting to HTTP")
+                get_global_logger().warning(f"Unknown server protocol '{server_protocol}', defaulting to HTTP")
                 
-            logger.debug(f"ProtocolManager._load_config - allowed protocols: {self.allowed_protocols}")
+            get_global_logger().debug(f"ProtocolManager._load_config - allowed protocols: {self.allowed_protocols}")
             
         except Exception as e:
-            logger.debug(f"ProtocolManager._load_config - ERROR getting server protocol: {e}")
+            get_global_logger().debug(f"ProtocolManager._load_config - ERROR getting server protocol: {e}")
             # Fallback to HTTP
             self.allowed_protocols = ["http"]
 
         # Protocol management is always enabled in new structure
         self.enabled = True
 
-        logger.debug(
+        get_global_logger().debug(
             f"Protocol manager loaded config: enabled={self.enabled}, allowed_protocols={self.allowed_protocols}"
         )
 
@@ -104,16 +104,16 @@ class ProtocolManager:
         ssl_config = security_config.get("ssl", {})
 
         if ssl_config.get("enabled", False):
-            logger.debug("SSL enabled via security.ssl configuration")
+            get_global_logger().debug("SSL enabled via security.ssl configuration")
             return True
 
         # Fallback to legacy SSL config
         legacy_ssl_config = current_config.get("ssl", {})
         if legacy_ssl_config.get("enabled", False):
-            logger.debug("SSL enabled via legacy ssl configuration")
+            get_global_logger().debug("SSL enabled via legacy ssl configuration")
             return True
 
-        logger.debug("SSL is disabled in configuration")
+        get_global_logger().debug("SSL is disabled in configuration")
         return False
 
     def update_config(self, new_config: Dict):
@@ -125,7 +125,7 @@ class ProtocolManager:
         """
         self.app_config = new_config
         self._load_config()
-        logger.info(
+        get_global_logger().info(
             f"Protocol manager configuration updated: allowed_protocols={self.allowed_protocols}"
         )
 
@@ -143,18 +143,18 @@ class ProtocolManager:
         Returns:
             True if protocol is allowed, False otherwise
         """
-        logger.debug(f"🔍 ProtocolManager.is_protocol_allowed - protocol: {protocol}")
-        logger.debug(f"🔍 ProtocolManager.is_protocol_allowed - enabled: {self.enabled}")
-        logger.debug(f"🔍 ProtocolManager.is_protocol_allowed - allowed_protocols: {self.allowed_protocols}")
+        get_global_logger().debug(f"🔍 ProtocolManager.is_protocol_allowed - protocol: {protocol}")
+        get_global_logger().debug(f"🔍 ProtocolManager.is_protocol_allowed - enabled: {self.enabled}")
+        get_global_logger().debug(f"🔍 ProtocolManager.is_protocol_allowed - allowed_protocols: {self.allowed_protocols}")
         
         if not self.enabled:
-            logger.debug("✅ ProtocolManager.is_protocol_allowed - Protocol management is disabled, allowing all protocols")
+            get_global_logger().debug("✅ ProtocolManager.is_protocol_allowed - Protocol management is disabled, allowing all protocols")
             return True
 
         protocol_lower = protocol.lower()
         is_allowed = protocol_lower in self.allowed_protocols
 
-        logger.debug(f"🔍 ProtocolManager.is_protocol_allowed - Protocol '{protocol}' allowed: {is_allowed}")
+        get_global_logger().debug(f"🔍 ProtocolManager.is_protocol_allowed - Protocol '{protocol}' allowed: {is_allowed}")
         return is_allowed
 
     def get_protocol_port(self, protocol: str) -> Optional[int]:
@@ -171,11 +171,11 @@ class ProtocolManager:
         protocol_config = self.protocols_config.get(protocol_lower, {})
 
         if not protocol_config.get("enabled", False):
-            logger.debug(f"Protocol '{protocol}' is not enabled")
+            get_global_logger().debug(f"Protocol '{protocol}' is not enabled")
             return None
 
         port = protocol_config.get("port")
-        logger.debug(f"Protocol '{protocol}' port: {port}")
+        get_global_logger().debug(f"Protocol '{protocol}' port: {port}")
         return port
 
     def get_allowed_protocols(self) -> List[str]:
@@ -257,7 +257,7 @@ class ProtocolManager:
         ssl_config = self._get_ssl_config(current_config)
 
         if not ssl_config.get("enabled", False):
-            logger.warning(
+            get_global_logger().warning(
                 f"SSL required for protocol '{protocol}' but SSL is disabled"
             )
             return None
@@ -266,7 +266,7 @@ class ProtocolManager:
         key_file = ssl_config.get("key_file")
 
         if not cert_file or not key_file:
-            logger.warning(
+            get_global_logger().warning(
                 f"SSL required for protocol '{protocol}' but certificate files not configured"
             )
             return None
@@ -285,11 +285,11 @@ class ProtocolManager:
                 max_tls_version=ssl_config.get("max_tls_version", "1.3"),
             )
 
-            logger.info(f"SSL context created for protocol '{protocol}'")
+            get_global_logger().info(f"SSL context created for protocol '{protocol}'")
             return ssl_context
 
         except Exception as e:
-            logger.error(f"Failed to create SSL context for protocol '{protocol}': {e}")
+            get_global_logger().error(f"Failed to create SSL context for protocol '{protocol}': {e}")
             return None
 
     def _get_ssl_config(self, current_config: Dict) -> Dict:
@@ -307,13 +307,13 @@ class ProtocolManager:
         ssl_config = security_config.get("ssl", {})
 
         if ssl_config.get("enabled", False):
-            logger.debug("Using security.ssl configuration")
+            get_global_logger().debug("Using security.ssl configuration")
             return ssl_config
 
         # Fallback to legacy SSL config
         legacy_ssl_config = current_config.get("ssl", {})
         if legacy_ssl_config.get("enabled", False):
-            logger.debug("Using legacy ssl configuration")
+            get_global_logger().debug("Using legacy ssl configuration")
             return legacy_ssl_config
 
         # Return empty config if SSL is disabled
@@ -417,6 +417,6 @@ def get_protocol_manager(app_config: Optional[Dict] = None) -> ProtocolManager:
     # Create new instance if none exists or config changed
     if protocol_manager is None or protocol_manager.app_config != app_config:
         protocol_manager = ProtocolManager(app_config)
-        logger.info("Protocol manager created with new configuration")
+        get_global_logger().info("Protocol manager created with new configuration")
 
     return protocol_manager

mcp_proxy_adapter/core/proxy_registration.py

@@ -22,7 +22,7 @@ import aiohttp
 import os
 import glob
 
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 from mcp_proxy_adapter.core.client_security import create_client_security_manager
 
 
@@ -193,7 +193,7 @@ class ProxyRegistrationManager:
         self.server_url: Optional[str] = None
         self.heartbeat_task: Optional[asyncio.Task] = None
 
-        logger.info(
+        get_global_logger().info(
             "Proxy registration manager initialized with security framework integration"
         )
 
@@ -214,7 +214,7 @@ class ProxyRegistrationManager:
             server_url: The URL where this server is accessible.
         """
         self.server_url = server_url
-        logger.info(f"Proxy registration server URL set to: {server_url}")
+        get_global_logger().info(f"Proxy registration server URL set to: {server_url}")
 
     def _get_auth_headers(self) -> Dict[str, str]:
         """
@@ -250,21 +250,21 @@ class ProxyRegistrationManager:
         Returns:
             SSL context or None if SSL not needed
         """
-        logger.debug("_create_ssl_context called")
+        get_global_logger().debug("_create_ssl_context called")
         
         # Decide SSL strictly by proxy URL scheme: use SSL only for https proxy URLs
         try:
             from urllib.parse import urlparse as _urlparse
             scheme = _urlparse(self.proxy_url).scheme if self.proxy_url else "http"
             if scheme.lower() != "https":
-                logger.debug("Proxy URL is HTTP, skipping SSL context creation for registration")
+                get_global_logger().debug("Proxy URL is HTTP, skipping SSL context creation for registration")
                 return None
         except Exception:
-            logger.debug("Failed to parse proxy_url, assuming HTTP and skipping SSL context")
+            get_global_logger().debug("Failed to parse proxy_url, assuming HTTP and skipping SSL context")
             return None
             
         if not self.client_security:
-            logger.debug("SSL context creation failed: client_security is None")
+            get_global_logger().debug("SSL context creation failed: client_security is None")
             return None
 
         try:
@@ -301,7 +301,7 @@ class ProxyRegistrationManager:
                     "in your configuration file."
                 )
 
-            logger.debug(
+            get_global_logger().debug(
                 f"SSL context creation: cert_config={cert_config}, ssl_config={ssl_config}"
             )
 
@@ -314,7 +314,7 @@ class ProxyRegistrationManager:
                 else:
                     # No CA certificate configured - use system default
                     context = ssl.create_default_context()
-                    logger.warning(
+                    get_global_logger().warning(
                         "No CA certificate configured for proxy registration. "
                         "This may cause SSL verification failures if the proxy uses self-signed certificates. "
                         "Consider configuring 'proxy_registration.ssl.ca_cert' in your configuration file."
@@ -327,7 +327,7 @@ class ProxyRegistrationManager:
 
                     if cert_file and key_file:
                         context.load_cert_chain(cert_file, key_file)
-                        logger.debug(
+                        get_global_logger().debug(
                             f"Loaded client certificates for mTLS: cert={cert_file}, key={key_file}"
                         )
 
@@ -340,42 +340,42 @@ class ProxyRegistrationManager:
                     # Load CA certificate if provided
                     if ca_cert_file:
                         context.load_verify_locations(ca_cert_file)
-                        logger.debug(f"Loaded CA certificate: {ca_cert_file}")
+                        get_global_logger().debug(f"Loaded CA certificate: {ca_cert_file}")
 
                     # Check if verify_ssl is disabled in ssl_config
                     if verify_ssl == False:
                         context.check_hostname = False
                         context.verify_mode = ssl.CERT_NONE
-                        logger.debug("SSL verification disabled (verify_ssl=False)")
+                        get_global_logger().debug("SSL verification disabled (verify_ssl=False)")
                     elif verify_mode == "CERT_NONE":
                         context.check_hostname = False
                         context.verify_mode = ssl.CERT_NONE
-                        logger.debug("SSL verification disabled (CERT_NONE)")
+                        get_global_logger().debug("SSL verification disabled (CERT_NONE)")
                     elif verify_mode == "CERT_REQUIRED":
                         context.check_hostname = True
                         context.verify_mode = ssl.CERT_REQUIRED
-                        logger.debug("SSL verification enabled (CERT_REQUIRED)")
+                        get_global_logger().debug("SSL verification enabled (CERT_REQUIRED)")
                     else:
                         # For test environments, default to CERT_NONE to avoid certificate issues
                         context.check_hostname = False
                         context.verify_mode = ssl.CERT_NONE
-                        logger.debug("SSL verification disabled (default for test environment)")
+                        get_global_logger().debug("SSL verification disabled (default for test environment)")
                 else:
                     # No specific ssl_config, default to CERT_NONE for test environments
                     context.check_hostname = False
                     context.verify_mode = ssl.CERT_NONE
-                    logger.debug("Using CERT_NONE for test environment (no ssl_config)")
+                    get_global_logger().debug("Using CERT_NONE for test environment (no ssl_config)")
 
-                logger.info("Created custom SSL context for proxy registration")
+                get_global_logger().info("Created custom SSL context for proxy registration")
                 return context
             else:
-                logger.debug(
+                get_global_logger().debug(
                     "SSL context creation skipped: no cert_config or ssl_config"
                 )
 
             return None
         except Exception as e:
-            logger.warning(f"Failed to create SSL context: {e}")
+            get_global_logger().warning(f"Failed to create SSL context: {e}")
             # Don't fail the entire operation, just return None
             return None
 
@@ -387,11 +387,11 @@ class ProxyRegistrationManager:
             True if registration was successful, False otherwise.
         """
         if not self.is_enabled():
-            logger.info("Proxy registration is disabled in configuration")
+            get_global_logger().info("Proxy registration is disabled in configuration")
             return False
 
         if not self.server_url:
-            logger.error("Server URL not set, cannot register with proxy")
+            get_global_logger().error("Server URL not set, cannot register with proxy")
             return False
 
         # Normalize server_url for docker host if needed
@@ -409,11 +409,11 @@ class ProxyRegistrationManager:
                     normalized = urlunparse(parsed._replace(netloc=new_netloc))
                     if normalized != self.server_url:
                         self.server_url = normalized
-                        logger.info(
+                        get_global_logger().info(
                             f"Normalized server_url for docker host: {self.server_url}"
                         )
         except Exception as _e:
-            logger.debug(f"server_url normalization skipped: {_e}")
+            get_global_logger().debug(f"server_url normalization skipped: {_e}")
 
         # Prepare registration data with proxy info
         proxy_info = self.registration_config.get("proxy_info", {})
@@ -430,8 +430,8 @@ class ProxyRegistrationManager:
             ),
         }
 
-        logger.info(f"Attempting to register server with proxy at {self.proxy_url}")
-        logger.debug(f"Registration data: {registration_data}")
+        get_global_logger().info(f"Attempting to register server with proxy at {self.proxy_url}")
+        get_global_logger().debug(f"Registration data: {registration_data}")
 
         # Do not block application startup: single attempt, no sleeps here
         for attempt in range(1):
@@ -447,7 +447,7 @@ class ProxyRegistrationManager:
                         self.server_key = result.get("server_key")
                     else:
                         self.server_key = None
-                    logger.info(
+                    get_global_logger().info(
                         f"✅ Successfully registered with proxy. Server key: {self.server_key}"
                     )
 
@@ -461,11 +461,11 @@ class ProxyRegistrationManager:
                 else:
                     # Be robust if result is not a dict
                     error_msg = None
-                    logger.error(f"DEBUG: result type = {type(result)}, result = {result}")
+                    get_global_logger().error(f"DEBUG: result type = {type(result)}, result = {result}")
                     if isinstance(result, dict):
-                        logger.error(f"DEBUG: result is dict, getting error field")
+                        get_global_logger().error(f"DEBUG: result is dict, getting error field")
                         error_field = result.get("error", {})
-                        logger.error(f"DEBUG: error_field type = {type(error_field)}, error_field = {error_field}")
+                        get_global_logger().error(f"DEBUG: error_field type = {type(error_field)}, error_field = {error_field}")
                         if isinstance(error_field, dict):
                             error_msg = error_field.get("message", "Unknown error")
                         elif isinstance(error_field, str):
@@ -491,7 +491,7 @@ class ProxyRegistrationManager:
 
                         if (error_code in ("DUPLICATE_SERVER_URL", "REGISTRATION_ERROR") or already_registered) and existing_server_key:
                             try:
-                                logger.info(f"Attempting auto-unregistration of existing instance: {existing_server_key}")
+                                get_global_logger().info(f"Attempting auto-unregistration of existing instance: {existing_server_key}")
                                 # Build unregistration payload using parsed server_key
                                 try:
                                     copy_number = int(existing_server_key.split("_")[-1])
@@ -501,7 +501,7 @@ class ProxyRegistrationManager:
                                 # Reuse secure unregistration request directly
                                 unreg_success, _unreg_result = await self._make_secure_unregistration_request(unregistration_data)
                                 if unreg_success:
-                                    logger.info("Auto-unregistration succeeded, retrying registration once...")
+                                    get_global_logger().info("Auto-unregistration succeeded, retrying registration once...")
                                     # Retry registration once immediately
                                     retry_success, retry_result = await self._make_secure_registration_request(registration_data)
                                     if retry_success:
@@ -510,29 +510,29 @@ class ProxyRegistrationManager:
                                             self.server_key = retry_result.get("server_key")
                                         else:
                                             self.server_key = None
-                                        logger.info(f"✅ Successfully registered after auto-unregistration. Server key: {self.server_key}")
+                                        get_global_logger().info(f"✅ Successfully registered after auto-unregistration. Server key: {self.server_key}")
                                         if self.registration_config.get("heartbeat", {}).get("enabled", True):
                                             await self._start_heartbeat()
                                         return True
                                     else:
-                                        logger.warning(f"Retry registration failed after auto-unregistration: {retry_result}")
+                                        get_global_logger().warning(f"Retry registration failed after auto-unregistration: {retry_result}")
                                 else:
-                                    logger.warning(f"Auto-unregistration failed: {_unreg_result}")
+                                    get_global_logger().warning(f"Auto-unregistration failed: {_unreg_result}")
                             except Exception as _auto_e:
-                                logger.warning(f"Auto-unregistration/registration flow error: {_auto_e}")
+                                get_global_logger().warning(f"Auto-unregistration/registration flow error: {_auto_e}")
                     else:
                         error_msg = str(result)
-                    logger.warning(
+                    get_global_logger().warning(
                         f"❌ Registration attempt {attempt + 1} failed: {error_msg}"
                     )
 
             except Exception as e:
-                logger.error(
+                get_global_logger().error(
                     f"❌ Registration attempt {attempt + 1} failed with exception: {e}"
                 )
-                logger.error(f"Full traceback: {traceback.format_exc()}")
+                get_global_logger().error(f"Full traceback: {traceback.format_exc()}")
 
-        logger.error(
+        get_global_logger().error(
             f"❌ Failed to register with proxy after {self.retry_attempts} attempts"
         )
         return False
@@ -545,11 +545,11 @@ class ProxyRegistrationManager:
             True if unregistration was successful, False otherwise.
         """
         if not self.is_enabled():
-            logger.info("Proxy registration is disabled, skipping unregistration")
+            get_global_logger().info("Proxy registration is disabled, skipping unregistration")
             return True
 
         if not self.registered or not self.server_key:
-            logger.info("Server not registered with proxy, skipping unregistration")
+            get_global_logger().info("Server not registered with proxy, skipping unregistration")
             return True
 
         # Stop heartbeat
@@ -563,8 +563,8 @@ class ProxyRegistrationManager:
 
         unregistration_data = {"server_id": self.server_id, "copy_number": copy_number}
 
-        logger.info(f"Attempting to unregister server from proxy at {self.proxy_url}")
-        logger.debug(f"Unregistration data: {unregistration_data}")
+        get_global_logger().info(f"Attempting to unregister server from proxy at {self.proxy_url}")
+        get_global_logger().debug(f"Unregistration data: {unregistration_data}")
 
         try:
             success, result = await self._make_secure_unregistration_request(
@@ -574,20 +574,20 @@ class ProxyRegistrationManager:
             if success:
                 unregistered = result.get("unregistered", False)
                 if unregistered:
-                    logger.info("✅ Successfully unregistered from proxy")
+                    get_global_logger().info("✅ Successfully unregistered from proxy")
                 else:
-                    logger.warning("⚠️ Server was not found in proxy registry")
+                    get_global_logger().warning("⚠️ Server was not found in proxy registry")
 
                 self.registered = False
                 self.server_key = None
                 return True
             else:
                 error_msg = result.get("error", {}).get("message", "Unknown error")
-                logger.error(f"❌ Failed to unregister from proxy: {error_msg}")
+                get_global_logger().error(f"❌ Failed to unregister from proxy: {error_msg}")
                 return False
 
         except Exception as e:
-            logger.error(f"❌ Unregistration failed with exception: {e}")
+            get_global_logger().error(f"❌ Unregistration failed with exception: {e}")
             return False
 
     async def _make_secure_registration_request(
@@ -626,10 +626,10 @@ class ProxyRegistrationManager:
                 ) as response:
                     try:
                         result = await response.json()
-                        logger.debug(f"Response JSON parsed successfully: {type(result)} - {result}")
+                        get_global_logger().debug(f"Response JSON parsed successfully: {type(result)} - {result}")
                     except Exception as e:
                         text_body = await response.text()
-                        logger.debug(f"JSON parsing failed: {e}, text_body: {text_body}")
+                        get_global_logger().debug(f"JSON parsing failed: {e}, text_body: {text_body}")
                         result = {"success": False, "error": {"code": "NON_JSON_RESPONSE", "message": text_body}}
 
                     # Validate response headers if security framework available
@@ -648,7 +648,7 @@ class ProxyRegistrationManager:
 
                             # Handle duplicate server URL as successful registration
                             if error_code == "DUPLICATE_SERVER_URL":
-                                logger.info(
+                                get_global_logger().info(
                                     f"✅ Server already registered: {error_msg}"
                                 )
                                 # Extract server_key from details if available
@@ -656,18 +656,18 @@ class ProxyRegistrationManager:
                                 existing_server_key = details.get("existing_server_key")
                                 if existing_server_key:
                                     result["server_key"] = existing_server_key
-                                    logger.info(
+                                    get_global_logger().info(
                                         f"✅ Retrieved existing server key: {existing_server_key}"
                                     )
                                 # Return success=True for duplicate registration
                                 return True, result
                             else:
-                                logger.warning(
+                                get_global_logger().warning(
                                     f"Registration failed: {error_code} - {error_msg}"
                                 )
                         return success, result
                     else:
-                        logger.warning(
+                        get_global_logger().warning(
                             f"Registration failed with HTTP status: {response.status}"
                         )
                         # Ensure result is a dict for consistent error handling
@@ -727,12 +727,12 @@ class ProxyRegistrationManager:
                             error_info = result.get("error", {})
                             error_msg = error_info.get("message", "Unknown error")
                             error_code = error_info.get("code", "UNKNOWN_ERROR")
-                            logger.warning(
+                            get_global_logger().warning(
                                 f"Unregistration failed: {error_code} - {error_msg}"
                             )
                         return success, result
                     else:
-                        logger.warning(
+                        get_global_logger().warning(
                             f"Unregistration failed with HTTP status: {response.status}"
                         )
                         return False, result
@@ -746,7 +746,7 @@ class ProxyRegistrationManager:
             return
 
         self.heartbeat_task = asyncio.create_task(self._heartbeat_loop())
-        logger.info("Heartbeat task started")
+        get_global_logger().info("Heartbeat task started")
 
     async def _stop_heartbeat(self) -> None:
         """Stop heartbeat task."""
@@ -756,7 +756,7 @@ class ProxyRegistrationManager:
                 await self.heartbeat_task
             except asyncio.CancelledError:
                 pass
-            logger.info("Heartbeat task stopped")
+            get_global_logger().info("Heartbeat task stopped")
 
     async def _heartbeat_loop(self) -> None:
         """Heartbeat loop to keep registration alive."""
@@ -770,13 +770,13 @@ class ProxyRegistrationManager:
                 # Send heartbeat
                 success = await self._send_heartbeat()
                 if not success:
-                    logger.warning("Heartbeat failed, attempting to re-register")
+                    get_global_logger().warning("Heartbeat failed, attempting to re-register")
                     await self.register_server()
 
             except asyncio.CancelledError:
                 break
             except Exception as e:
-                logger.error(f"Heartbeat error: {e}")
+                get_global_logger().error(f"Heartbeat error: {e}")
 
     async def heartbeat(self) -> bool:
         """
@@ -810,15 +810,15 @@ class ProxyRegistrationManager:
                 try:
                     async with session.get(url, headers=headers, timeout=timeout) as resp:
                         if resp.status == 200:
-                            logger.debug("Heartbeat (GET) succeeded")
+                            get_global_logger().debug("Heartbeat (GET) succeeded")
                             return True
                         # If method not allowed, fall back to POST
                         if resp.status != 405:
-                            logger.warning(
+                            get_global_logger().warning(
                                 f"Heartbeat (GET) failed with status: {resp.status}"
                             )
                 except Exception as ge:
-                    logger.debug(f"Heartbeat (GET) error: {ge}")
+                    get_global_logger().debug(f"Heartbeat (GET) error: {ge}")
 
                 # Fallback to POST if GET not supported
                 heartbeat_data = {
@@ -832,14 +832,14 @@ class ProxyRegistrationManager:
                     url, json=heartbeat_data, headers=post_headers, timeout=timeout
                 ) as resp:
                     if resp.status == 200:
-                        logger.debug("Heartbeat (POST) succeeded")
+                        get_global_logger().debug("Heartbeat (POST) succeeded")
                         return True
-                        logger.warning(
+                        get_global_logger().warning(
                         f"Heartbeat (POST) failed with status: {resp.status}"
                         )
                         return False
         except Exception as e:
-            logger.error(f"Heartbeat error: {e}")
+            get_global_logger().error(f"Heartbeat error: {e}")
             return False
         finally:
             if connector:
@@ -904,7 +904,7 @@ async def register_with_proxy(server_url: str) -> bool:
         True if registration was successful, False otherwise.
     """
     if not proxy_registration_manager:
-        logger.error("Proxy registration manager not initialized")
+        get_global_logger().error("Proxy registration manager not initialized")
         return False
 
     proxy_registration_manager.set_server_url(server_url)
@@ -919,7 +919,7 @@ async def unregister_from_proxy() -> bool:
         True if unregistration was successful, False otherwise.
     """
     if not proxy_registration_manager:
-        logger.error("Proxy registration manager not initialized")
+        get_global_logger().error("Proxy registration manager not initialized")
         return False
 
     return await proxy_registration_manager.unregister_server()