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

mcp_proxy_adapter/commands/help_command.py

@@ -10,6 +10,7 @@ from mcp_proxy_adapter.commands.base import Command
 from mcp_proxy_adapter.commands.result import CommandResult
 from mcp_proxy_adapter.commands.command_registry import registry
 from mcp_proxy_adapter.core.errors import NotFoundError
+from mcp_proxy_adapter.core.logging import get_global_logger
 
 # Добавляем логирование
 logger = logging.getLogger("mcp_proxy_adapter.commands.help_command")
@@ -32,7 +33,7 @@ class HelpResult(CommandResult):
             commands_info: Information about all commands (for request without parameters)
             command_info: Information about a specific command (for request with cmdname parameter)
         """
-        logger.debug(
+        get_global_logger().debug(
             f"HelpResult.__init__: commands_info={commands_info is not None}, command_info={command_info is not None}"
         )
         self.commands_info = commands_info
@@ -46,13 +47,13 @@ class HelpResult(CommandResult):
             Dict[str, Any]: Result as dictionary
         """
         try:
-            logger.debug(
+            get_global_logger().debug(
                 f"HelpResult.to_dict: command_info={self.command_info is not None}, commands_info={self.commands_info is not None}"
             )
 
             # Защита от None для self.command_info
             if self.command_info is not None:
-                logger.debug(
+                get_global_logger().debug(
                     f"HelpResult.to_dict: returning command_info for {self.command_info.get('name', 'unknown')}"
                 )
                 # Делаем безопасное получение всех полей с дефолтными значениями
@@ -70,7 +71,7 @@ class HelpResult(CommandResult):
 
             # Защита от None для self.commands_info
             if self.commands_info is None:
-                logger.warning(
+                get_global_logger().warning(
                     "HelpResult.to_dict: commands_info is None, создаем пустой результат"
                 )
                 # Возвращаем пустой список команд вместо ошибки
@@ -100,7 +101,7 @@ class HelpResult(CommandResult):
                 }
 
             # For list of all commands, return as is (already formatted)
-            logger.debug(
+            get_global_logger().debug(
                 f"HelpResult.to_dict: processing commands_info with {len(self.commands_info.get('commands', {}))} commands"
             )
             result = self.commands_info.copy()
@@ -112,13 +113,13 @@ class HelpResult(CommandResult):
                 'To get detailed information about a specific command, call help with parameter: POST /cmd {"command": "help", "params": {"cmdname": "<command_name>"}}'
             )
 
-            logger.debug(
+            get_global_logger().debug(
                 f"HelpResult.to_dict: returning result with {result['total']} commands"
             )
             return result
         except Exception as e:
-            logger.error(f"Ошибка в HelpResult.to_dict: {e}")
-            logger.debug(f"Трассировка: {traceback.format_exc()}")
+            get_global_logger().error(f"Ошибка в HelpResult.to_dict: {e}")
+            get_global_logger().debug(f"Трассировка: {traceback.format_exc()}")
             # В случае неожиданной ошибки возвращаем базовый ответ вместо ошибки
             return {
                 "tool_info": {
@@ -206,21 +207,21 @@ class HelpCommand(Command):
         Raises:
             NotFoundError: If specified command not found
         """
-        logger.debug(f"HelpCommand.execute начало: cmdname={cmdname}, kwargs={kwargs}")
+        get_global_logger().debug(f"HelpCommand.execute начало: cmdname={cmdname}, kwargs={kwargs}")
 
         try:
             # Handle case when cmdname is provided
             if cmdname is not None and cmdname != "":
-                logger.debug(f"Обработка запроса для конкретной команды: {cmdname}")
+                get_global_logger().debug(f"Обработка запроса для конкретной команды: {cmdname}")
                 try:
                     # Get command info from registry
                     command_info = registry.get_command_info(cmdname)
                     if command_info is None:
                         raise NotFoundError(f"Command '{cmdname}' not found")
-                    logger.debug(f"Получены метаданные для команды {cmdname}")
+                    get_global_logger().debug(f"Получены метаданные для команды {cmdname}")
                     return HelpResult(command_info=command_info)
                 except NotFoundError:
-                    logger.warning(f"Команда '{cmdname}' не найдена")
+                    get_global_logger().warning(f"Команда '{cmdname}' не найдена")
                     # Получаем список всех команд
                     all_commands = list(registry.get_all_commands().keys())
                     if all_commands:
@@ -243,11 +244,11 @@ class HelpCommand(Command):
                     )
 
             # Otherwise, return information about all available commands
-            logger.debug("Обработка запроса для всех команд")
+            get_global_logger().debug("Обработка запроса для всех команд")
 
             # Get info for all commands
             all_commands_info = registry.get_all_commands_info()
-            logger.debug(
+            get_global_logger().debug(
                 f"Получены метаданные для {len(all_commands_info.get('commands', {}))} команд"
             )
 
@@ -279,7 +280,7 @@ class HelpCommand(Command):
             commands_data = all_commands_info.get("commands", {})
             for name, command_info in commands_data.items():
                 try:
-                    logger.debug(f"Обработка метаданных команды {name}")
+                    get_global_logger().debug(f"Обработка метаданных команды {name}")
                     # Безопасное получение параметров с проверкой на наличие ключей
                     metadata = command_info.get("metadata", {})
                     schema = command_info.get("schema", {})
@@ -288,18 +289,18 @@ class HelpCommand(Command):
                         "params_count": len(schema.get("properties", {})),
                     }
                 except Exception as e:
-                    logger.error(f"Ошибка при обработке метаданных команды {name}: {e}")
-                    logger.debug(f"Метаданные команды {name}: {command_info}")
+                    get_global_logger().error(f"Ошибка при обработке метаданных команды {name}: {e}")
+                    get_global_logger().debug(f"Метаданные команды {name}: {command_info}")
                     # Пропускаем проблемную команду
                     continue
 
-            logger.debug(
+            get_global_logger().debug(
                 f"HelpCommand.execute завершение: возвращаем результат с {len(result['commands'])} командами"
             )
             return HelpResult(commands_info=result)
         except Exception as e:
-            logger.error(f"Неожиданная ошибка в HelpCommand.execute: {e}")
-            logger.debug(f"Трассировка: {traceback.format_exc()}")
+            get_global_logger().error(f"Неожиданная ошибка в HelpCommand.execute: {e}")
+            get_global_logger().debug(f"Трассировка: {traceback.format_exc()}")
             # В случае неожиданной ошибки возвращаем пустой результат вместо ошибки
             return HelpResult(
                 commands_info={

mcp_proxy_adapter/commands/hooks.py

@@ -8,7 +8,7 @@ that will be called during system initialization.
 from typing import Callable, List, Optional, Dict, Any, Union
 from enum import Enum
 from dataclasses import dataclass
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 
 
 class HookType(Enum):
@@ -65,7 +65,7 @@ class CommandHooks:
                       Should accept registry as parameter.
         """
         self._custom_commands_hooks.append(hook_func)
-        logger.debug(f"Registered custom commands hook: {hook_func.__name__}")
+        get_global_logger().debug(f"Registered custom commands hook: {hook_func.__name__}")
 
     def register_before_init_hook(self, hook_func: Callable) -> None:
         """
@@ -75,7 +75,7 @@ class CommandHooks:
             hook_func: Function to call before initialization.
         """
         self._before_init_hooks.append(hook_func)
-        logger.debug(f"Registered before init hook: {hook_func.__name__}")
+        get_global_logger().debug(f"Registered before init hook: {hook_func.__name__}")
 
     def register_after_init_hook(self, hook_func: Callable) -> None:
         """
@@ -85,7 +85,7 @@ class CommandHooks:
             hook_func: Function to call after initialization.
         """
         self._after_init_hooks.append(hook_func)
-        logger.debug(f"Registered after init hook: {hook_func.__name__}")
+        get_global_logger().debug(f"Registered after init hook: {hook_func.__name__}")
 
     def register_before_command_hook(self, hook_func: Callable) -> None:
         """
@@ -96,7 +96,7 @@ class CommandHooks:
                       Should accept command_name and params as parameters.
         """
         self._before_command_hooks.append(hook_func)
-        logger.debug(f"Registered before command hook: {hook_func.__name__}")
+        get_global_logger().debug(f"Registered before command hook: {hook_func.__name__}")
 
     def register_after_command_hook(self, hook_func: Callable) -> None:
         """
@@ -107,7 +107,7 @@ class CommandHooks:
                       Should accept command_name, params, and result as parameters.
         """
         self._after_command_hooks.append(hook_func)
-        logger.debug(f"Registered after command hook: {hook_func.__name__}")
+        get_global_logger().debug(f"Registered after command hook: {hook_func.__name__}")
 
     def execute_custom_commands_hooks(self, registry) -> int:
         """
@@ -119,20 +119,20 @@ class CommandHooks:
         Returns:
             Number of hooks executed.
         """
-        logger.debug("Executing custom commands hooks...")
+        get_global_logger().debug("Executing custom commands hooks...")
         hooks_executed = 0
 
         for hook_func in self._custom_commands_hooks:
             try:
                 hook_func(registry)
                 hooks_executed += 1
-                logger.debug(f"Executed custom commands hook: {hook_func.__name__}")
+                get_global_logger().debug(f"Executed custom commands hook: {hook_func.__name__}")
             except Exception as e:
-                logger.error(
+                get_global_logger().error(
                     f"Failed to execute custom commands hook {hook_func.__name__}: {e}"
                 )
 
-        logger.info(f"Executed {hooks_executed} custom commands hooks")
+        get_global_logger().info(f"Executed {hooks_executed} custom commands hooks")
         return hooks_executed
 
     def execute_before_init_hooks(self) -> int:
@@ -142,20 +142,20 @@ class CommandHooks:
         Returns:
             Number of hooks executed.
         """
-        logger.debug("Executing before init hooks...")
+        get_global_logger().debug("Executing before init hooks...")
         hooks_executed = 0
 
         for hook_func in self._before_init_hooks:
             try:
                 hook_func()
                 hooks_executed += 1
-                logger.debug(f"Executed before init hook: {hook_func.__name__}")
+                get_global_logger().debug(f"Executed before init hook: {hook_func.__name__}")
             except Exception as e:
-                logger.error(
+                get_global_logger().error(
                     f"Failed to execute before init hook {hook_func.__name__}: {e}"
                 )
 
-        logger.debug(f"Executed {hooks_executed} before init hooks")
+        get_global_logger().debug(f"Executed {hooks_executed} before init hooks")
         return hooks_executed
 
     def execute_after_init_hooks(self) -> int:
@@ -165,20 +165,20 @@ class CommandHooks:
         Returns:
             Number of hooks executed.
         """
-        logger.debug("Executing after init hooks...")
+        get_global_logger().debug("Executing after init hooks...")
         hooks_executed = 0
 
         for hook_func in self._after_init_hooks:
             try:
                 hook_func()
                 hooks_executed += 1
-                logger.debug(f"Executed after init hook: {hook_func.__name__}")
+                get_global_logger().debug(f"Executed after init hook: {hook_func.__name__}")
             except Exception as e:
-                logger.error(
+                get_global_logger().error(
                     f"Failed to execute after init hook {hook_func.__name__}: {e}"
                 )
 
-        logger.debug(f"Executed {hooks_executed} after init hooks")
+        get_global_logger().debug(f"Executed {hooks_executed} after init hooks")
         return hooks_executed
 
     def execute_before_command_hooks(
@@ -194,20 +194,20 @@ class CommandHooks:
         Returns:
             Number of hooks executed.
         """
-        logger.debug(f"Executing before command hooks for: {command_name}")
+        get_global_logger().debug(f"Executing before command hooks for: {command_name}")
         hooks_executed = 0
 
         for hook_func in self._before_command_hooks:
             try:
                 hook_func(command_name, params)
                 hooks_executed += 1
-                logger.debug(f"Executed before command hook: {hook_func.__name__}")
+                get_global_logger().debug(f"Executed before command hook: {hook_func.__name__}")
             except Exception as e:
-                logger.error(
+                get_global_logger().error(
                     f"Failed to execute before command hook {hook_func.__name__}: {e}"
                 )
 
-        logger.debug(f"Executed {hooks_executed} before command hooks")
+        get_global_logger().debug(f"Executed {hooks_executed} before command hooks")
         return hooks_executed
 
     def execute_after_command_hooks(
@@ -224,20 +224,20 @@ class CommandHooks:
         Returns:
             Number of hooks executed.
         """
-        logger.debug(f"Executing after command hooks for: {command_name}")
+        get_global_logger().debug(f"Executing after command hooks for: {command_name}")
         hooks_executed = 0
 
         for hook_func in self._after_command_hooks:
             try:
                 hook_func(command_name, params, result)
                 hooks_executed += 1
-                logger.debug(f"Executed after command hook: {hook_func.__name__}")
+                get_global_logger().debug(f"Executed after command hook: {hook_func.__name__}")
             except Exception as e:
-                logger.error(
+                get_global_logger().error(
                     f"Failed to execute after command hook {hook_func.__name__}: {e}"
                 )
 
-        logger.debug(f"Executed {hooks_executed} after command hooks")
+        get_global_logger().debug(f"Executed {hooks_executed} after command hooks")
         return hooks_executed
 
     def clear_hooks(self) -> None:
@@ -249,7 +249,7 @@ class CommandHooks:
         self._after_init_hooks.clear()
         self._before_command_hooks.clear()
         self._after_command_hooks.clear()
-        logger.debug("Cleared all hooks")
+        get_global_logger().debug("Cleared all hooks")
 
 
 # Global hooks instance

mcp_proxy_adapter/commands/key_management_command.py

@@ -19,6 +19,7 @@ from .base import Command
 from .result import CommandResult, SuccessResult, ErrorResult
 from ..core.certificate_utils import CertificateUtils
 
+from mcp_proxy_adapter.core.logging import get_global_logger
 logger = logging.getLogger(__name__)
 
 
@@ -205,7 +206,7 @@ class KeyManagementCommand(Command):
             CommandResult with key generation status
         """
         try:
-            logger.info(f"Generating {key_type} key with size {key_size} bits")
+            get_global_logger().info(f"Generating {key_type} key with size {key_size} bits")
 
             # Validate parameters
             if key_type not in ["RSA", "ECDSA"]:
@@ -240,11 +241,11 @@ class KeyManagementCommand(Command):
                 status="valid",
             )
 
-            logger.info(f"Key generated successfully: {output_path}")
+            get_global_logger().info(f"Key generated successfully: {output_path}")
             return SuccessResult(data={"key": key_result.to_dict(), "details": result})
 
         except Exception as e:
-            logger.error(f"Key generation failed: {e}")
+            get_global_logger().error(f"Key generation failed: {e}")
             return ErrorResult(message=f"Key generation failed: {str(e)}")
 
     async def key_validate(
@@ -261,7 +262,7 @@ class KeyManagementCommand(Command):
             CommandResult with key validation status
         """
         try:
-            logger.info(f"Validating key: {key_path}")
+            get_global_logger().info(f"Validating key: {key_path}")
 
             # Validate parameters
             if not key_path or not os.path.exists(key_path):
@@ -281,11 +282,11 @@ class KeyManagementCommand(Command):
                 status="valid",
             )
 
-            logger.info(f"Key validation completed: {key_path}")
+            get_global_logger().info(f"Key validation completed: {key_path}")
             return SuccessResult(data={"key": key_result.to_dict()})
 
         except Exception as e:
-            logger.error(f"Key validation failed: {e}")
+            get_global_logger().error(f"Key validation failed: {e}")
             return ErrorResult(message=f"Key validation failed: {str(e)}")
 
     async def key_rotate(
@@ -308,7 +309,7 @@ class KeyManagementCommand(Command):
             CommandResult with key rotation status
         """
         try:
-            logger.info(f"Rotating key from {old_key_path} to {new_key_path}")
+            get_global_logger().info(f"Rotating key from {old_key_path} to {new_key_path}")
 
             # Validate parameters
             if not old_key_path or not os.path.exists(old_key_path):
@@ -338,7 +339,7 @@ class KeyManagementCommand(Command):
                     f"{old_key_path}.backup.{datetime.now().strftime('%Y%m%d_%H%M%S')}"
                 )
                 shutil.copy2(old_key_path, backup_path)
-                logger.info(f"Old key backed up to: {backup_path}")
+                get_global_logger().info(f"Old key backed up to: {backup_path}")
 
             # Update certificate if provided
             cert_updated = False
@@ -347,16 +348,16 @@ class KeyManagementCommand(Command):
                     # This would require implementing certificate re-signing
                     # For now, we'll just note that it needs to be done
                     cert_updated = True
-                    logger.info(
+                    get_global_logger().info(
                         f"Certificate {cert_path} needs to be re-signed with new key"
                     )
                 except Exception as e:
-                    logger.warning(f"Could not update certificate {cert_path}: {e}")
+                    get_global_logger().warning(f"Could not update certificate {cert_path}: {e}")
 
             # Replace old key with new key
             shutil.copy2(new_key_path, old_key_path)
 
-            logger.info(f"Key rotation completed successfully")
+            get_global_logger().info(f"Key rotation completed successfully")
             return SuccessResult(
                 data={
                     "old_key_path": old_key_path,
@@ -368,7 +369,7 @@ class KeyManagementCommand(Command):
             )
 
         except Exception as e:
-            logger.error(f"Key rotation failed: {e}")
+            get_global_logger().error(f"Key rotation failed: {e}")
             return ErrorResult(message=f"Key rotation failed: {str(e)}")
 
     async def key_backup(
@@ -391,7 +392,7 @@ class KeyManagementCommand(Command):
             CommandResult with backup status
         """
         try:
-            logger.info(f"Backing up key: {key_path}")
+            get_global_logger().info(f"Backing up key: {key_path}")
 
             # Validate parameters
             if not key_path or not os.path.exists(key_path):
@@ -427,7 +428,7 @@ class KeyManagementCommand(Command):
             if not os.path.exists(backup_path):
                 return ErrorResult(message="Backup file was not created")
 
-            logger.info(f"Key backup completed successfully: {backup_path}")
+            get_global_logger().info(f"Key backup completed successfully: {backup_path}")
             return SuccessResult(
                 data={
                     "key_path": key_path,
@@ -439,7 +440,7 @@ class KeyManagementCommand(Command):
             )
 
         except Exception as e:
-            logger.error(f"Key backup failed: {e}")
+            get_global_logger().error(f"Key backup failed: {e}")
             return ErrorResult(message=f"Key backup failed: {str(e)}")
 
     async def key_restore(
@@ -457,7 +458,7 @@ class KeyManagementCommand(Command):
             CommandResult with restore status
         """
         try:
-            logger.info(f"Restoring key from backup: {backup_path}")
+            get_global_logger().info(f"Restoring key from backup: {backup_path}")
 
             # Validate parameters
             if not backup_path or not os.path.exists(backup_path):
@@ -489,7 +490,7 @@ class KeyManagementCommand(Command):
                     message=f"Restored key validation failed: {key_validation.to_dict()['error']['message']}"
                 )
 
-            logger.info(f"Key restore completed successfully: {key_path}")
+            get_global_logger().info(f"Key restore completed successfully: {key_path}")
             return SuccessResult(
                 data={
                     "backup_path": backup_path,
@@ -504,5 +505,5 @@ class KeyManagementCommand(Command):
             )
 
         except Exception as e:
-            logger.error(f"Key restore failed: {e}")
+            get_global_logger().error(f"Key restore failed: {e}")
             return ErrorResult(message=f"Key restore failed: {str(e)}")

mcp_proxy_adapter/commands/plugins_command.py

@@ -7,7 +7,7 @@ from typing import Dict, Any, Optional, List
 from mcp_proxy_adapter.commands.base import Command
 from mcp_proxy_adapter.commands.result import CommandResult, SuccessResult
 from mcp_proxy_adapter.commands.command_registry import registry
-from mcp_proxy_adapter.config import config as config_instance
+from mcp_proxy_adapter.config import get_config
 
 
 class PluginsResult(SuccessResult):
@@ -141,6 +141,7 @@ class PluginsCommand(Command):
         """
         try:
             # Get configuration from the global config instance
+            config_instance = get_config()
             plugins_server_url = config_instance.get("commands.plugins_server")
 
             if not plugins_server_url:

mcp_proxy_adapter/commands/protocol_management_command.py

@@ -11,7 +11,7 @@ from dataclasses import dataclass
 from mcp_proxy_adapter.commands.base import Command
 from mcp_proxy_adapter.commands.result import SuccessResult, ErrorResult
 from mcp_proxy_adapter.core.protocol_manager import protocol_manager
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 
 
 @dataclass
@@ -112,7 +112,7 @@ class ProtocolManagementCommand(Command):
                 return ErrorResult(f"Unknown action: {action}")
 
         except Exception as e:
-            logger.error(f"Protocol management command error: {e}")
+            get_global_logger().error(f"Protocol management command error: {e}")
             return ErrorResult(f"Protocol management error: {str(e)}")
 
     async def _get_protocol_info(self) -> SuccessResult:
@@ -150,7 +150,7 @@ class ProtocolManagementCommand(Command):
             )
 
         except Exception as e:
-            logger.error(f"Error getting protocol info: {e}")
+            get_global_logger().error(f"Error getting protocol info: {e}")
             return ErrorResult(f"Failed to get protocol info: {str(e)}")
 
     async def _validate_configuration(self) -> SuccessResult:
@@ -174,7 +174,7 @@ class ProtocolManagementCommand(Command):
             )
 
         except Exception as e:
-            logger.error(f"Error validating configuration: {e}")
+            get_global_logger().error(f"Error validating configuration: {e}")
             return ErrorResult(f"Failed to validate configuration: {str(e)}")
 
     async def _get_allowed_protocols(self) -> SuccessResult:
@@ -196,7 +196,7 @@ class ProtocolManagementCommand(Command):
             )
 
         except Exception as e:
-            logger.error(f"Error getting allowed protocols: {e}")
+            get_global_logger().error(f"Error getting allowed protocols: {e}")
             return ErrorResult(f"Failed to get allowed protocols: {str(e)}")
 
     async def _check_protocol(self, protocol: str) -> SuccessResult:
@@ -240,5 +240,5 @@ class ProtocolManagementCommand(Command):
             )
 
         except Exception as e:
-            logger.error(f"Error checking protocol {protocol}: {e}")
+            get_global_logger().error(f"Error checking protocol {protocol}: {e}")
             return ErrorResult(f"Failed to check protocol {protocol}: {str(e)}")

mcp_proxy_adapter/commands/proxy_registration_command.py

@@ -16,7 +16,7 @@ from dataclasses import dataclass
 
 from mcp_proxy_adapter.commands.base import Command
 from mcp_proxy_adapter.commands.result import SuccessResult
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 
 
 @dataclass
@@ -125,7 +125,7 @@ class ProxyRegistrationCommand(Command):
         
         # Only check permissions if security is enabled
         if security_enabled:
-            logger.info(
+            get_global_logger().info(
                 f"Checking permissions: user_permissions={user_permissions}, required={required_permissions}"
             )
             if not self._check_permissions(user_permissions, required_permissions):
@@ -135,10 +135,10 @@ class ProxyRegistrationCommand(Command):
                     message=f"Permission denied: {operation} requires {required_permissions}",
                 )
         else:
-            logger.debug(f"Security disabled, skipping permission check for operation: {operation}")
+            get_global_logger().debug(f"Security disabled, skipping permission check for operation: {operation}")
 
-        logger.info(f"Executing proxy registration operation: {operation}")
-        logger.debug(
+        get_global_logger().info(f"Executing proxy registration operation: {operation}")
+        get_global_logger().debug(
             f"User permissions: {user_permissions}, required: {required_permissions}"
         )
 
@@ -203,7 +203,7 @@ class ProxyRegistrationCommand(Command):
 
         self._registry[server_key] = server_record
 
-        logger.info(f"Registered server: {server_key} at {server_url}")
+        get_global_logger().info(f"Registered server: {server_key} at {server_url}")
 
         return ProxyRegistrationCommandResult(
             operation="register",
@@ -235,7 +235,7 @@ class ProxyRegistrationCommand(Command):
 
         if server_key in self._registry:
             del self._registry[server_key]
-            logger.info(f"Unregistered server: {server_key}")
+            get_global_logger().info(f"Unregistered server: {server_key}")
 
             return ProxyRegistrationCommandResult(
                 operation="unregister",
@@ -271,7 +271,7 @@ class ProxyRegistrationCommand(Command):
             self._registry[server_key]["last_heartbeat"] = timestamp
             self._registry[server_key]["status"] = status
 
-            logger.debug(f"Heartbeat received for server: {server_key}")
+            get_global_logger().debug(f"Heartbeat received for server: {server_key}")
 
             return ProxyRegistrationCommandResult(
                 operation="heartbeat",
@@ -318,7 +318,7 @@ class ProxyRegistrationCommand(Command):
                 }
                 proxies.append(proxy_info)
 
-        logger.info(f"Discovery request returned {len(proxies)} active servers")
+        get_global_logger().info(f"Discovery request returned {len(proxies)} active servers")
 
         return ProxyRegistrationCommandResult(
             operation="discover",

mcp_proxy_adapter/commands/registration_status_command.py

@@ -13,7 +13,7 @@ from dataclasses import dataclass
 
 from mcp_proxy_adapter.commands.base import Command
 from mcp_proxy_adapter.commands.result import SuccessResult
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 
 
 @dataclass
@@ -79,7 +79,7 @@ class RegistrationStatusCommand(Command):
         Returns:
             RegistrationStatusCommandResult with current status
         """
-        logger.info("Executing registration status command")
+        get_global_logger().info("Executing registration status command")
 
         try:
             from mcp_proxy_adapter.core.async_proxy_registration import (
@@ -88,7 +88,7 @@ class RegistrationStatusCommand(Command):
 
             status = get_registration_status()
             
-            logger.info(f"Registration status retrieved: {status}")
+            get_global_logger().info(f"Registration status retrieved: {status}")
 
             return RegistrationStatusCommandResult(
                 status=status,
@@ -96,7 +96,7 @@ class RegistrationStatusCommand(Command):
             )
 
         except Exception as e:
-            logger.error(f"Failed to get registration status: {e}")
+            get_global_logger().error(f"Failed to get registration status: {e}")
             
             error_status = {
                 "state": "error",