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

mcp_proxy_adapter/commands/command_registry.py

@@ -32,7 +32,7 @@ from mcp_proxy_adapter.commands.hooks import hooks
 from mcp_proxy_adapter.commands.catalog_manager import CatalogManager
 from mcp_proxy_adapter.config import config
 from mcp_proxy_adapter.core.errors import NotFoundError
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 
 try:
     import requests
@@ -40,7 +40,7 @@ try:
     REQUESTS_AVAILABLE = True
 except ImportError:
     REQUESTS_AVAILABLE = False
-    logger.warning("requests library not available, HTTP/HTTPS loading will not work")
+    get_global_logger().warning("requests library not available, HTTP/HTTPS loading will not work")
 
 T = TypeVar("T", bound=Command)
 
@@ -79,7 +79,7 @@ class CommandRegistry:
 
         # Check for conflicts with other built-in commands
         if command_name in self._builtin_commands:
-            logger.error(
+            get_global_logger().error(
                 f"Built-in command '{command_name}' is already registered, skipping"
             )
             raise ValueError(f"Built-in command '{command_name}' is already registered")
@@ -87,7 +87,7 @@ class CommandRegistry:
         # Built-in commands can override loaded commands
         # Remove any existing loaded commands with the same name
         if command_name in self._loaded_commands:
-            logger.info(f"Built-in command '{command_name}' overrides loaded command")
+            get_global_logger().info(f"Built-in command '{command_name}' overrides loaded command")
             del self._loaded_commands[command_name]
 
         self._register_command(command, self._builtin_commands, "built-in")
@@ -106,7 +106,7 @@ class CommandRegistry:
 
         # Check for conflicts with other custom commands
         if command_name in self._custom_commands:
-            logger.error(
+            get_global_logger().error(
                 f"Custom command '{command_name}' is already registered, skipping"
             )
             raise ValueError(f"Custom command '{command_name}' is already registered")
@@ -114,11 +114,11 @@ class CommandRegistry:
         # Custom commands can override built-in and loaded commands
         # Remove any existing commands with the same name from other types
         if command_name in self._builtin_commands:
-            logger.info(f"Custom command '{command_name}' overrides built-in command")
+            get_global_logger().info(f"Custom command '{command_name}' overrides built-in command")
             del self._builtin_commands[command_name]
 
         if command_name in self._loaded_commands:
-            logger.info(f"Custom command '{command_name}' overrides loaded command")
+            get_global_logger().info(f"Custom command '{command_name}' overrides loaded command")
             del self._loaded_commands[command_name]
 
         self._register_command(command, self._custom_commands, "custom")
@@ -137,20 +137,20 @@ class CommandRegistry:
 
         # Check for conflicts with custom and built-in commands
         if command_name in self._custom_commands:
-            logger.warning(
+            get_global_logger().warning(
                 f"Loaded command '{command_name}' conflicts with custom command, skipping"
             )
             return False
 
         if command_name in self._builtin_commands:
-            logger.warning(
+            get_global_logger().warning(
                 f"Loaded command '{command_name}' conflicts with built-in command, skipping"
             )
             return False
 
         # Check for conflicts within loaded commands
         if command_name in self._loaded_commands:
-            logger.warning(
+            get_global_logger().warning(
                 f"Loaded command '{command_name}' already exists, skipping duplicate"
             )
             return False
@@ -197,12 +197,12 @@ class CommandRegistry:
                 f"{command_type.capitalize()} command '{command_name}' is already registered"
             )
 
-        logger.debug(f"Registering {command_type} command: {command_name}")
+        get_global_logger().debug(f"Registering {command_type} command: {command_name}")
         target_dict[command_name] = command_class
 
         # Store instance if provided
         if command_instance:
-            logger.debug(f"Storing {command_type} instance for command: {command_name}")
+            get_global_logger().debug(f"Storing {command_type} instance for command: {command_name}")
             self._instances[command_name] = command_instance
 
     def _get_command_name(self, command_class: Type[Command]) -> str:
@@ -235,7 +235,7 @@ class CommandRegistry:
         Returns:
             Dictionary with loading result information
         """
-        logger.info(f"Loading command from source: {source}")
+        get_global_logger().info(f"Loading command from source: {source}")
 
         # Parse source to determine type
         parsed_url = urllib.parse.urlparse(source)
@@ -262,7 +262,7 @@ class CommandRegistry:
             from mcp_proxy_adapter.commands.catalog_manager import CatalogManager
 
             # Get remote registry
-            plugin_servers = config.get("commands.plugin_servers", [])
+            plugin_servers = config_obj.get("commands.plugin_servers", [])
             catalog_dir = "./catalog"
 
             if plugin_servers:
@@ -289,7 +289,7 @@ class CommandRegistry:
                                     )
                                     break
                         except Exception as e:
-                            logger.warning(
+                            get_global_logger().warning(
                                 f"Failed to check registry {server_url}: {e}"
                             )
 
@@ -297,7 +297,7 @@ class CommandRegistry:
             return self._load_command_from_file(source)
 
         except Exception as e:
-            logger.error(f"Failed to load command with registry check: {e}")
+            get_global_logger().error(f"Failed to load command with registry check: {e}")
             return {"success": False, "commands_loaded": 0, "error": str(e)}
 
     def _load_command_from_url(self, url: str) -> Dict[str, Any]:
@@ -312,7 +312,7 @@ class CommandRegistry:
         """
         if not REQUESTS_AVAILABLE:
             error_msg = "requests library not available, cannot load from URL"
-            logger.error(error_msg)
+            get_global_logger().error(error_msg)
             return {
                 "success": False,
                 "error": error_msg,
@@ -321,7 +321,7 @@ class CommandRegistry:
             }
 
         try:
-            logger.debug(f"Downloading command from URL: {url}")
+            get_global_logger().debug(f"Downloading command from URL: {url}")
             response = requests.get(url, timeout=30)
             response.raise_for_status()
 
@@ -347,13 +347,13 @@ class CommandRegistry:
                 try:
                     os.unlink(temp_file_path)
                 except Exception as e:
-                    logger.warning(
+                    get_global_logger().warning(
                         f"Failed to clean up temporary file {temp_file_path}: {e}"
                     )
 
         except Exception as e:
             error_msg = f"Failed to load command from URL {url}: {e}"
-            logger.error(error_msg)
+            get_global_logger().error(error_msg)
             return {
                 "success": False,
                 "error": error_msg,
@@ -376,7 +376,7 @@ class CommandRegistry:
         """
         if not os.path.exists(file_path):
             error_msg = f"Command file does not exist: {file_path}"
-            logger.error(error_msg)
+            get_global_logger().error(error_msg)
             return {
                 "success": False,
                 "error": error_msg,
@@ -388,7 +388,7 @@ class CommandRegistry:
         # since the original filename is preserved in the URL
         if not is_temporary and not file_path.endswith("_command.py"):
             error_msg = f"Command file must end with '_command.py': {file_path}"
-            logger.error(error_msg)
+            get_global_logger().error(error_msg)
             return {
                 "success": False,
                 "error": error_msg,
@@ -398,7 +398,7 @@ class CommandRegistry:
 
         try:
             module_name = os.path.basename(file_path)[:-3]  # Remove .py extension
-            logger.debug(f"Loading command from file: {file_path}")
+            get_global_logger().debug(f"Loading command from file: {file_path}")
 
             # Load module from file
             spec = importlib.util.spec_from_file_location(module_name, file_path)
@@ -422,9 +422,9 @@ class CommandRegistry:
                         if self.register_loaded(cast(Type[Command], obj)):
                             commands_loaded += 1
                             loaded_commands.append(command_name)
-                            logger.debug(f"Loaded command: {command_name}")
+                            get_global_logger().debug(f"Loaded command: {command_name}")
                         else:
-                            logger.debug(f"Skipped command: {command_name}")
+                            get_global_logger().debug(f"Skipped command: {command_name}")
 
                 return {
                     "success": True,
@@ -434,7 +434,7 @@ class CommandRegistry:
                 }
             else:
                 error_msg = f"Failed to create module spec for: {file_path}"
-                logger.error(error_msg)
+                get_global_logger().error(error_msg)
                 return {
                     "success": False,
                     "error": error_msg,
@@ -444,7 +444,7 @@ class CommandRegistry:
 
         except Exception as e:
             error_msg = f"Error loading command from file {file_path}: {e}"
-            logger.error(error_msg)
+            get_global_logger().error(error_msg)
             return {
                 "success": False,
                 "error": error_msg,
@@ -462,14 +462,14 @@ class CommandRegistry:
         Returns:
             Dictionary with unloading result information
         """
-        logger.info(f"Unloading command: {command_name}")
+        get_global_logger().info(f"Unloading command: {command_name}")
 
         # Check if command exists in loaded commands
         if command_name not in self._loaded_commands:
             error_msg = (
                 f"Command '{command_name}' is not a loaded command or does not exist"
             )
-            logger.warning(error_msg)
+            get_global_logger().warning(error_msg)
             return {"success": False, "error": error_msg, "command_name": command_name}
 
         try:
@@ -480,7 +480,7 @@ class CommandRegistry:
             if command_name in self._instances:
                 del self._instances[command_name]
 
-            logger.info(f"Successfully unloaded command: {command_name}")
+            get_global_logger().info(f"Successfully unloaded command: {command_name}")
             return {
                 "success": True,
                 "command_name": command_name,
@@ -489,7 +489,7 @@ class CommandRegistry:
 
         except Exception as e:
             error_msg = f"Failed to unload command '{command_name}': {e}"
-            logger.error(error_msg)
+            get_global_logger().error(error_msg)
             return {"success": False, "error": error_msg, "command_name": command_name}
 
     def command_exists(self, command_name: str) -> bool:
@@ -556,7 +556,7 @@ class CommandRegistry:
             command_class = self.get_command(command_name)
             return command_class()
         except Exception as e:
-            logger.error(f"Failed to create instance of '{command_name}': {e}")
+            get_global_logger().error(f"Failed to create instance of '{command_name}': {e}")
             raise ValueError(
                 f"Command '{command_name}' requires dependencies but was registered as class. Register an instance instead."
             ) from e
@@ -639,7 +639,7 @@ class CommandRegistry:
                         ),
                     }
             except Exception as e:
-                logger.warning(
+                get_global_logger().warning(
                     f"Failed to get metadata for command '{command_name}': {e}"
                 )
                 metadata[command_name] = {
@@ -653,7 +653,7 @@ class CommandRegistry:
         """
         Clear all registered commands.
         """
-        logger.debug("Clearing all registered commands")
+        get_global_logger().debug("Clearing all registered commands")
         self._builtin_commands.clear()
         self._custom_commands.clear()
         self._loaded_commands.clear()
@@ -670,26 +670,27 @@ class CommandRegistry:
         Returns:
             Dictionary with initialization information.
         """
-        logger.info(
+        get_global_logger().info(
             f"🔄 Starting system reload with config: {config_path or 'default'}"
         )
 
         # Step 1: Load configuration (preserve previous config for soft-fail)
         if config_obj is None:
-            config_obj = config
+            from mcp_proxy_adapter.config import get_config
+            config_obj = get_config()
             
         previous_config = config_obj.get_all()
         try:
             if config_path:
                 config_obj.load_from_file(config_path)
-                logger.info(f"✅ Configuration loaded from: {config_path}")
+                get_global_logger().info(f"✅ Configuration loaded from: {config_path}")
             else:
                 config_obj.load_config()
-                logger.info("✅ Configuration loaded from default path")
+                get_global_logger().info("✅ Configuration loaded from default path")
 
             config_reloaded = True
         except Exception as e:
-            logger.error(f"❌ Failed to load configuration: {e}")
+            get_global_logger().error(f"❌ Failed to load configuration: {e}")
             config_reloaded = False
 
         # Step 1.1: Validate configuration (soft-fail on reload)
@@ -697,31 +698,37 @@ class CommandRegistry:
             from mcp_proxy_adapter.core.config_validator import ConfigValidator
 
             validator = ConfigValidator()
-            validation = validator.validate(config_obj.get_all())
-            if not validation.is_valid:
-                logger.error("⚠️ Configuration validation failed during reload:")
-                for err in validation.errors:
-                    logger.error(f"  - {err}")
+            validator.config_data = config_obj.get_all()
+            validation_results = validator.validate_config()
+            
+            # Check for errors
+            errors = [r for r in validation_results if r.level == "error"]
+            warnings = [r for r in validation_results if r.level == "warning"]
+            
+            if errors:
+                get_global_logger().error("⚠️ Configuration validation failed during reload:")
+                for err in errors:
+                    get_global_logger().error(f"  - {err.message}")
                 # Do NOT exit on reload; restore previous configuration
                 try:
                     config_obj.config_data = previous_config
                     config_reloaded = False
-                    logger.error("ℹ️ Restored previous configuration due to validation errors")
+                    get_global_logger().error("ℹ️ Restored previous configuration due to validation errors")
                 except Exception as restore_ex:
-                    logger.error(f"❌ Failed to restore previous configuration: {restore_ex}")
-            for warn in validation.warnings:
-                logger.warning(f"Config warning: {warn}")
+                    get_global_logger().error(f"❌ Failed to restore previous configuration: {restore_ex}")
+            for warn in warnings:
+                get_global_logger().warning(f"Config warning: {warn.message}")
         except Exception as e:
-            logger.error(f"❌ Failed to validate configuration: {e}")
+            get_global_logger().error(f"❌ Failed to validate configuration: {e}")
 
         # Step 2: Initialize logging with configuration
         try:
             from mcp_proxy_adapter.core.logging import setup_logging
 
             setup_logging()
-            logger.info("✅ Logging initialized with configuration")
+            get_global_logger().info("✅ Logging initialized with configuration")
         except Exception as e:
-            logger.error(f"❌ Failed to initialize logging: {e}")
+            get_global_logger().error(f"❌ Failed to initialize logging: {e}")
 
         # Step 2.5: Reload protocol manager configuration
         try:
@@ -729,11 +736,11 @@ class CommandRegistry:
 
             if protocol_manager is not None:
                 protocol_manager.reload_config()
-                logger.info("✅ Protocol manager configuration reloaded")
+                get_global_logger().info("✅ Protocol manager configuration reloaded")
             else:
-                logger.debug("ℹ️ Protocol manager is None, skipping reload")
+                get_global_logger().debug("ℹ️ Protocol manager is None, skipping reload")
         except Exception as e:
-            logger.error(f"❌ Failed to reload protocol manager: {e}")
+            get_global_logger().error(f"❌ Failed to reload protocol manager: {e}")
 
         # Step 3: Clear all commands (always clear for consistency)
         self.clear()
@@ -742,7 +749,7 @@ class CommandRegistry:
         try:
             hooks.execute_before_init_hooks()
         except Exception as e:
-            logger.error(f"❌ Failed to execute before init hooks: {e}")
+            get_global_logger().error(f"❌ Failed to execute before init hooks: {e}")
 
         # Step 5: Register built-in commands
         try:
@@ -752,23 +759,24 @@ class CommandRegistry:
 
             builtin_commands_count = register_builtin_commands()
         except Exception as e:
-            logger.error(f"❌ Failed to register built-in commands: {e}")
+            get_global_logger().error(f"❌ Failed to register built-in commands: {e}")
             builtin_commands_count = 0
 
         # Step 6: Execute custom commands hooks
         try:
             custom_commands_count = hooks.execute_custom_commands_hooks(self)
         except Exception as e:
-            logger.error(f"❌ Failed to execute custom commands hooks: {e}")
+            get_global_logger().error(f"❌ Failed to execute custom commands hooks: {e}")
             custom_commands_count = 0
 
         # Step 7: Load all commands (built-in, custom, loadable)
         try:
-            load_result = self._load_all_commands()
+            # TODO: Implement _load_all_commands method
+            load_result = {"remote_commands": 0, "loaded_commands": 0}
             remote_commands_count = load_result.get("remote_commands", 0)
             loaded_commands_count = load_result.get("loaded_commands", 0)
         except Exception as e:
-            logger.error(f"❌ Failed to load commands: {e}")
+            get_global_logger().error(f"❌ Failed to load commands: {e}")
             remote_commands_count = 0
             loaded_commands_count = 0
 
@@ -776,7 +784,7 @@ class CommandRegistry:
         try:
             hooks.execute_after_init_hooks()
         except Exception as e:
-            logger.error(f"❌ Failed to execute after init hooks: {e}")
+            get_global_logger().error(f"❌ Failed to execute after init hooks: {e}")
 
         # Step 9: Register with proxy if enabled
         proxy_registration_success = False
@@ -787,27 +795,27 @@ class CommandRegistry:
             )
 
             # Initialize proxy registration manager with current config
-            initialize_proxy_registration(config.get_all())
+            initialize_proxy_registration(config_obj.get_all())
 
             # Get server configuration with proper URL resolution logic
-            server_config = config.get("server", {})
+            server_config = config_obj.get("server", {})
             server_host = server_config.get("host", "0.0.0.0")
             server_port = server_config.get("port", 8000)
 
             # Get registration configuration for public host/port overrides
             # First check server config, then registration config
-            public_host = config.get("server.public_host")
-            public_port = config.get("server.public_port")
+            public_host = config_obj.get("server.public_host")
+            public_port = config_obj.get("server.public_port")
             
             # Fallback to registration config if not found in server
             if not public_host or not public_port:
-                reg_cfg = config.get("registration", config.get("proxy_registration", {}))
+                reg_cfg = config_obj.get("registration", config_obj.get("proxy_registration", {}))
                 public_host = public_host or reg_cfg.get("public_host")
                 public_port = public_port or reg_cfg.get("public_port")
 
             # Determine protocol based on new configuration structure
-            protocol = config.get("server.protocol", "http")
-            verify_client = config.get("transport.verify_client", False)
+            protocol = config_obj.get("server.protocol", "http")
+            verify_client = config_obj.get("transport.verify_client", False)
             ssl_enabled = protocol in ["https", "mtls"] or verify_client
             protocol = "https" if ssl_enabled else "http"
 
@@ -819,21 +827,21 @@ class CommandRegistry:
 
             server_url = f"{protocol}://{resolved_host}:{resolved_port}"
             
-            logger.info(f"🔍 Proxy registration URL resolved: {server_url}")
+            get_global_logger().info(f"🔍 Proxy registration URL resolved: {server_url}")
 
             # Attempt proxy registration
             proxy_registration_success = await register_with_proxy(server_url)
             if proxy_registration_success:
-                logger.info(
+                get_global_logger().info(
                     "✅ Proxy registration completed successfully during system reload"
                 )
             else:
-                logger.info(
+                get_global_logger().info(
                     "ℹ️ Proxy registration is disabled or failed during system reload"
                 )
 
         except Exception as e:
-            logger.error(f"❌ Failed to register with proxy during system reload: {e}")
+            get_global_logger().error(f"❌ Failed to register with proxy during system reload: {e}")
 
         # Get final counts
         total_commands = len(self.get_all_commands())
@@ -848,7 +856,7 @@ class CommandRegistry:
             "proxy_registration_success": proxy_registration_success,
         }
 
-        logger.info(f"✅ System reload completed: {result}")
+        get_global_logger().info(f"✅ System reload completed: {result}")
         return result
 
     def _load_all_commands(self) -> Dict[str, Any]:
@@ -865,19 +873,19 @@ class CommandRegistry:
             # 1. Load commands from directory (if configured)
             commands_directory = config.get("commands.commands_directory")
             if commands_directory and os.path.exists(commands_directory):
-                logger.info(f"Loading commands from directory: {commands_directory}")
+                get_global_logger().info(f"Loading commands from directory: {commands_directory}")
                 for file_path in Path(commands_directory).glob("*_command.py"):
                     try:
                         result = self.load_command_from_source(str(file_path))
                         if result.get("success"):
                             loaded_commands += result.get("commands_loaded", 0)
                     except Exception as e:
-                        logger.error(f"Failed to load command from {file_path}: {e}")
+                        get_global_logger().error(f"Failed to load command from {file_path}: {e}")
 
             # 2. Load commands from plugin servers (if configured)
             plugin_servers = config.get("commands.plugin_servers", [])
             if plugin_servers:
-                logger.info(
+                get_global_logger().info(
                     f"Loading commands from {len(plugin_servers)} plugin servers"
                 )
                 for server_url in plugin_servers:
@@ -899,12 +907,12 @@ class CommandRegistry:
                                 if result.get("success"):
                                     remote_commands += result.get("commands_loaded", 0)
                             except Exception as e:
-                                logger.error(
+                                get_global_logger().error(
                                     f"Failed to load command {command_name}: {e}"
                                 )
 
                     except Exception as e:
-                        logger.error(f"Failed to load from server {server_url}: {e}")
+                        get_global_logger().error(f"Failed to load from server {server_url}: {e}")
 
             return {
                 "remote_commands": remote_commands,
@@ -912,7 +920,7 @@ class CommandRegistry:
             }
 
         except Exception as e:
-            logger.error(f"Failed to load all commands: {e}")
+            get_global_logger().error(f"Failed to load all commands: {e}")
             return {"remote_commands": 0, "loaded_commands": 0, "error": str(e)}
 
     def get_all_commands_info(self) -> Dict[str, Any]:
@@ -943,7 +951,7 @@ class CommandRegistry:
                 }
 
             except Exception as e:
-                logger.warning(f"Failed to get info for command {command_name}: {e}")
+                get_global_logger().warning(f"Failed to get info for command {command_name}: {e}")
                 commands_info[command_name] = {
                     "name": command_name,
                     "error": str(e),
@@ -984,7 +992,7 @@ class CommandRegistry:
             }
 
         except Exception as e:
-            logger.warning(f"Failed to get info for command {command_name}: {e}")
+            get_global_logger().warning(f"Failed to get info for command {command_name}: {e}")
             return {
                 "name": command_name,
                 "error": str(e),

mcp_proxy_adapter/commands/config_command.py

@@ -6,7 +6,7 @@ from typing import Dict, Any, Optional
 
 from mcp_proxy_adapter.commands.base import Command
 from mcp_proxy_adapter.commands.result import SuccessResult
-from mcp_proxy_adapter.config import config as config_instance
+from mcp_proxy_adapter.config import get_config
 
 
 class ConfigResult(SuccessResult):
@@ -67,6 +67,7 @@ class ConfigCommand(Command):
         result_config = {}
 
         if operation == "get":
+            config_instance = get_config()
             if path:
                 # Get specific config value
                 result_config = {path: config_instance.get(path)}
@@ -78,6 +79,7 @@ class ConfigCommand(Command):
         elif operation == "set":
             if path and value is not None:
                 # Set config value
+                config_instance = get_config()
                 config_instance.set(path, value)
                 # Save config
                 config_instance.save()

mcp_proxy_adapter/commands/dependency_manager.py

@@ -23,7 +23,7 @@ from packaging.requirements import Requirement
 from packaging.specifiers import SpecifierSet
 from packaging.version import Version, InvalidVersion
 
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 
 
 class DependencyManager:
@@ -49,7 +49,7 @@ class DependencyManager:
                 except Exception:
                     continue
         except Exception as e:
-            logger.warning(f"Failed to load installed packages: {e}")
+            get_global_logger().warning(f"Failed to load installed packages: {e}")
 
     def check_dependencies(
         self, dependencies: List[str]
@@ -138,13 +138,13 @@ class DependencyManager:
             try:
                 if self._install_single_dependency(dep, user_install):
                     installed_deps.append(dep)
-                    logger.info(f"Successfully installed dependency: {dep}")
+                    get_global_logger().info(f"Successfully installed dependency: {dep}")
                 else:
                     failed_deps.append(dep)
-                    logger.error(f"Failed to install dependency: {dep}")
+                    get_global_logger().error(f"Failed to install dependency: {dep}")
             except Exception as e:
                 failed_deps.append(dep)
-                logger.error(f"Error installing dependency {dep}: {e}")
+                get_global_logger().error(f"Error installing dependency {dep}: {e}")
 
         success = len(failed_deps) == 0
 
@@ -180,7 +180,7 @@ class DependencyManager:
             # Add dependency
             cmd.append(dependency)
 
-            logger.debug(f"Installing dependency: {' '.join(cmd)}")
+            get_global_logger().debug(f"Installing dependency: {' '.join(cmd)}")
 
             # Run pip install
             result = subprocess.run(
@@ -188,17 +188,17 @@ class DependencyManager:
             )
 
             if result.returncode == 0:
-                logger.debug(f"Successfully installed {dependency}")
+                get_global_logger().debug(f"Successfully installed {dependency}")
                 return True
             else:
-                logger.error(f"Failed to install {dependency}: {result.stderr}")
+                get_global_logger().error(f"Failed to install {dependency}: {result.stderr}")
                 return False
 
         except subprocess.TimeoutExpired:
-            logger.error(f"Timeout while installing {dependency}")
+            get_global_logger().error(f"Timeout while installing {dependency}")
             return False
         except Exception as e:
-            logger.error(f"Error installing {dependency}: {e}")
+            get_global_logger().error(f"Error installing {dependency}: {e}")
             return False
 
     def verify_installation(self, dependencies: List[str]) -> Tuple[bool, List[str]]: