add logs

src/infrastructure/config/dependency_container.py

@@ -67,12 +67,12 @@ class DependencyContainer:
         self._singletons: Dict[Type, Any] = {}
         self._scoped_instances: Dict[Type, Any] = {}
         self._lock = Lock()
-        
+
         # Provider factories
         self._tts_factory: Optional[TTSProviderFactory] = None
         self._stt_factory: Optional[STTProviderFactory] = None
         self._translation_factory: Optional[TranslationProviderFactory] = None
-        
+
         # Register default services
         self._register_default_services()
 
@@ -80,7 +80,7 @@ class DependencyContainer:
         """Register default service implementations."""
         # Register configuration as singleton
         self.register_singleton(AppConfig, self._config)
-        
+
         # Register provider factories as singletons
         self.register_singleton(TTSProviderFactory, self._get_tts_factory)
         self.register_singleton(STTProviderFactory, self._get_stt_factory)
@@ -104,7 +104,7 @@ class DependencyContainer:
             # If implementation is already an instance, store it directly
             if not (isinstance(implementation, type) or callable(implementation)):
                 self._singletons[service_type] = implementation
-                logger.debug(f"Registered singleton instance for {service_type.__name__}")
+                logger.info(f"Registered singleton instance for {service_type.__name__}")
                 return
 
             descriptor = ServiceDescriptor(
@@ -114,7 +114,7 @@ class DependencyContainer:
                 factory_args=factory_args
             )
             self._services[service_type] = descriptor
-            logger.debug(f"Registered singleton service: {service_type.__name__}")
+            logger.info(f"Registered singleton service: {service_type.__name__}")
 
     def register_transient(
         self,
@@ -138,7 +138,7 @@ class DependencyContainer:
                 factory_args=factory_args
             )
             self._services[service_type] = descriptor
-            logger.debug(f"Registered transient service: {service_type.__name__}")
+            logger.info(f"Registered transient service: {service_type.__name__}")
 
     def register_scoped(
         self,
@@ -162,7 +162,7 @@ class DependencyContainer:
                 factory_args=factory_args
             )
             self._services[service_type] = descriptor
-            logger.debug(f"Registered scoped service: {service_type.__name__}")
+            logger.info(f"Registered scoped service: {service_type.__name__}")
 
     def resolve(self, service_type: Type[T]) -> T:
         """
@@ -178,27 +178,43 @@ class DependencyContainer:
             ValueError: If service is not registered
             Exception: If service creation fails
         """
+        logger.info(f"Starting resolve for service: {service_type.__name__}")
+
         with self._lock:
+            logger.info(f"Acquired lock for resolving: {service_type.__name__}")
+
             # Check if already a singleton instance
             if service_type in self._singletons:
+                logger.info(f"Found existing singleton instance for: {service_type.__name__}")
                 return self._singletons[service_type]
 
             # Check if service is registered
             if service_type not in self._services:
+                logger.error(f"Service {service_type.__name__} is not registered")
                 raise ValueError(f"Service {service_type.__name__} is not registered")
 
             descriptor = self._services[service_type]
+            logger.info(f"Found service descriptor for {service_type.__name__} with lifetime: {descriptor.lifetime.value}")
 
             try:
                 if descriptor.lifetime == ServiceLifetime.SINGLETON:
-                    return self._create_singleton(service_type, descriptor)
+                    logger.info(f"Creating singleton for: {service_type.__name__}")
+                    result = self._create_singleton(service_type, descriptor)
+                    logger.info(f"Successfully created singleton for: {service_type.__name__}")
+                    return result
                 elif descriptor.lifetime == ServiceLifetime.SCOPED:
-                    return self._create_scoped(service_type, descriptor)
+                    logger.info(f"Creating scoped instance for: {service_type.__name__}")
+                    result = self._create_scoped(service_type, descriptor)
+                    logger.info(f"Successfully created scoped instance for: {service_type.__name__}")
+                    return result
                 else:  # TRANSIENT
-                    return self._create_transient(descriptor)
+                    logger.info(f"Creating transient instance for: {service_type.__name__}")
+                    result = self._create_transient(descriptor)
+                    logger.info(f"Successfully created transient instance for: {service_type.__name__}")
+                    return result
 
             except Exception as e:
-                logger.error(f"Failed to resolve service {service_type.__name__}: {e}")
+                logger.error(f"Failed to resolve service {service_type.__name__}: {e}", exc_info=True)
                 raise
 
     def _create_singleton(self, service_type: Type[T], descriptor: ServiceDescriptor) -> T:
@@ -208,7 +224,7 @@ class DependencyContainer:
 
         instance = self._create_instance(descriptor)
         self._singletons[service_type] = instance
-        logger.debug(f"Created singleton instance for {service_type.__name__}")
+        logger.info(f"Created singleton instance for {service_type.__name__}")
         return instance
 
     def _create_scoped(self, service_type: Type[T], descriptor: ServiceDescriptor) -> T:
@@ -218,49 +234,68 @@ class DependencyContainer:
 
         instance = self._create_instance(descriptor)
         self._scoped_instances[service_type] = instance
-        logger.debug(f"Created scoped instance for {service_type.__name__}")
+        logger.info(f"Created scoped instance for {service_type.__name__}")
         return instance
 
     def _create_transient(self, descriptor: ServiceDescriptor) -> T:
         """Create new transient instance."""
         instance = self._create_instance(descriptor)
-        logger.debug(f"Created transient instance for {descriptor.service_type.__name__}")
+        logger.info(f"Created transient instance for {descriptor.service_type.__name__}")
         return instance
 
     def _create_instance(self, descriptor: ServiceDescriptor) -> T:
         """Create service instance using descriptor."""
+        logger.info(f"Creating instance for {descriptor.service_type.__name__}")
+
         implementation = descriptor.implementation
         factory_args = descriptor.factory_args
 
+        logger.info(f"Implementation type: {type(implementation)}, Factory args: {factory_args}")
+
         # If implementation is a callable (factory function)
         if callable(implementation) and not isinstance(implementation, type):
-            return implementation(**factory_args)
+            logger.info(f"Calling factory function for {descriptor.service_type.__name__}")
+            try:
+                result = implementation(**factory_args)
+                logger.info(f"Factory function completed for {descriptor.service_type.__name__}")
+                return result
+            except Exception as e:
+                logger.error(f"Factory function failed for {descriptor.service_type.__name__}: {e}", exc_info=True)
+                raise
 
         # If implementation is a class
         if isinstance(implementation, type):
-            return implementation(**factory_args)
+            logger.info(f"Instantiating class {implementation.__name__} for {descriptor.service_type.__name__}")
+            try:
+                result = implementation(**factory_args)
+                logger.info(f"Class instantiation completed for {descriptor.service_type.__name__}")
+                return result
+            except Exception as e:
+                logger.error(f"Class instantiation failed for {descriptor.service_type.__name__}: {e}", exc_info=True)
+                raise
 
+        logger.error(f"Invalid implementation type for {descriptor.service_type.__name__}: {type(implementation)}")
         raise ValueError(f"Invalid implementation type for {descriptor.service_type.__name__}")
 
     def _get_tts_factory(self) -> TTSProviderFactory:
         """Get or create TTS provider factory."""
         if self._tts_factory is None:
             self._tts_factory = TTSProviderFactory()
-            logger.debug("Created TTS provider factory")
+            logger.info("Created TTS provider factory")
         return self._tts_factory
 
     def _get_stt_factory(self) -> STTProviderFactory:
         """Get or create STT provider factory."""
         if self._stt_factory is None:
             self._stt_factory = STTProviderFactory()
-            logger.debug("Created STT provider factory")
+            logger.info("Created STT provider factory")
         return self._stt_factory
 
     def _get_translation_factory(self) -> TranslationProviderFactory:
         """Get or create translation provider factory."""
         if self._translation_factory is None:
             self._translation_factory = TranslationProviderFactory()
-            logger.debug("Created translation provider factory")
+            logger.info("Created translation provider factory")
         return self._translation_factory
 
     def get_tts_provider(self, provider_name: Optional[str] = None, **kwargs) -> ISpeechSynthesisService:
@@ -275,7 +310,7 @@ class DependencyContainer:
             ISpeechSynthesisService: TTS provider instance
         """
         factory = self.resolve(TTSProviderFactory)
-        
+
         if provider_name:
             return factory.create_provider(provider_name, **kwargs)
         else:
@@ -293,7 +328,7 @@ class DependencyContainer:
             ISpeechRecognitionService: STT provider instance
         """
         factory = self.resolve(STTProviderFactory)
-        
+
         if provider_name:
             return factory.create_provider(provider_name)
         else:
@@ -316,7 +351,7 @@ class DependencyContainer:
             ITranslationService: Translation provider instance
         """
         factory = self.resolve(TranslationProviderFactory)
-        
+
         if provider_type:
             return factory.create_provider(provider_type, config)
         else:
@@ -328,9 +363,9 @@ class DependencyContainer:
             # Cleanup scoped instances if they have cleanup methods
             for instance in self._scoped_instances.values():
                 self._cleanup_instance(instance)
-            
+
             self._scoped_instances.clear()
-            logger.debug("Cleared scoped instances")
+            logger.info("Cleared scoped instances")
 
     def _cleanup_instance(self, instance: Any) -> None:
         """Cleanup instance if it has cleanup methods."""
@@ -342,7 +377,7 @@ class DependencyContainer:
                     method = getattr(instance, method_name)
                     if callable(method):
                         method()
-                        logger.debug(f"Called {method_name} on {type(instance).__name__}")
+                        logger.info(f"Called {method_name} on {type(instance).__name__}")
                         break
         except Exception as e:
             logger.warning(f"Failed to cleanup instance {type(instance).__name__}: {e}")
@@ -351,33 +386,33 @@ class DependencyContainer:
         """Cleanup all managed resources."""
         with self._lock:
             logger.info("Starting dependency container cleanup")
-            
+
             # Cleanup scoped instances
             self.clear_scoped_instances()
-            
+
             # Cleanup singleton instances
             for instance in self._singletons.values():
                 self._cleanup_instance(instance)
-            
+
             # Cleanup provider factories
             if self._tts_factory:
                 try:
                     self._tts_factory.cleanup_providers()
                 except Exception as e:
                     logger.warning(f"Failed to cleanup TTS factory: {e}")
-            
+
             if self._translation_factory:
                 try:
                     self._translation_factory.clear_cache()
                 except Exception as e:
                     logger.warning(f"Failed to cleanup translation factory: {e}")
-            
+
             # Clear all references
             self._singletons.clear()
             self._tts_factory = None
             self._stt_factory = None
             self._translation_factory = None
-            
+
             logger.info("Dependency container cleanup completed")
 
     def is_registered(self, service_type: Type) -> bool:
@@ -402,16 +437,16 @@ class DependencyContainer:
         """
         with self._lock:
             services_info = {}
-            
+
             # Add singleton instances
             for service_type in self._singletons.keys():
                 services_info[service_type.__name__] = "singleton (instance)"
-            
+
             # Add registered services
             for service_type, descriptor in self._services.items():
                 if service_type not in self._singletons:
                     services_info[service_type.__name__] = descriptor.lifetime.value
-            
+
             return services_info
 
     def create_scope(self) -> 'DependencyScope':
@@ -465,7 +500,7 @@ class DependencyScope:
             instance = self._parent.resolve(service_type)
 
             # If it's a scoped service, store it in this scope
-            if (service_type in self._parent._services and 
+            if (service_type in self._parent._services and
                 self._parent._services[service_type].lifetime == ServiceLifetime.SCOPED):
                 self._scoped_instances[service_type] = instance
 
@@ -500,12 +535,12 @@ def get_container() -> DependencyContainer:
         DependencyContainer: Global container instance
     """
     global _global_container
-    
+
     with _container_lock:
         if _global_container is None:
             _global_container = DependencyContainer()
             logger.info("Created global dependency container")
-        
+
         return _global_container
 
 
@@ -517,11 +552,11 @@ def set_container(container: DependencyContainer) -> None:
         container: Container instance to set as global
     """
     global _global_container
-    
+
     with _container_lock:
         if _global_container is not None:
             _global_container.cleanup()
-        
+
         _global_container = container
         logger.info("Set global dependency container")
 
@@ -529,7 +564,7 @@ def set_container(container: DependencyContainer) -> None:
 def cleanup_container() -> None:
     """Cleanup the global dependency container."""
     global _global_container
-    
+
     with _container_lock:
         if _global_container is not None:
             _global_container.cleanup()