ragl.factory logging update

Author: andrewschenck

ragl/factory.py

@@ -141,12 +141,12 @@ def register_cls(cls, config_cls: type[RaglConfig], factory) -> None:
         _LOG.info('Registering factory class %s', cls.__name__)
         if not issubclass(config_cls, RaglConfig):
             msg = 'config_cls must be a subclass of RaglConfig'
-            _LOG.critical(msg)
+            _LOG.error(msg)
             raise TypeError(msg)
 
         if not issubclass(factory, AbstractFactory):
             msg = 'cls must be a subclass of AbstractFactory'
-            _LOG.critical(msg)
+            _LOG.error(msg)
             raise TypeError(msg)
 
         cls._factory_map[config_cls] = factory
@@ -195,26 +195,28 @@ def __call__(self, *args, **kwargs) -> Any:
             ConfigurationError:
                 When no factory found for configuration type.
         """
-        _LOG.debug('Calling factory %s with args: %s, kwargs: %s',)
         if self.__class__.__name__ not in self.can_call_abstract__call__:
             msg = f'{self.__class__.__name__} cannot be called directly'
-            _LOG.critical(msg)
+            _LOG.error(msg)
             raise TypeError(msg)
 
         try:
             config = kwargs['config']
         except KeyError as e:
             msg = 'config must be provided'
-            _LOG.critical(msg)
+            _LOG.error(msg)
             raise ConfigurationError(msg) from e
 
         try:
             factory_cls = self._factory_map[type(config)]
         except KeyError as e:
             msg = f'No factory found for configuration type: {e}'
-            _LOG.critical(msg)
+            _LOG.error(msg)
             raise ConfigurationError(msg) from e
 
+        _LOG.debug('Calling factory %s with args: %s, kwargs: %s',
+                   self.__class__.__name__, args, kwargs)
+
         factory = factory_cls()
         return factory(*args, **kwargs)
 
@@ -306,15 +308,17 @@ class is not available.
             config = kwargs['config']
         except KeyError as e:
             msg = 'config parameter must be provided'
-            _LOG.critical(msg)
+            _LOG.error(msg)
             raise ConfigurationError(msg) from e
         try:
             # pylint: disable=import-outside-toplevel
+            _LOG.info('Importing SentenceTransformerEmbedder')
             from ragl.embed.sentencetransformer import SentenceTransformerEmbedder  # noqa: E501
+            _LOG.info('Creating SentenceTransformerEmbedder instance')
             return SentenceTransformerEmbedder(config=config)
         except ImportError as e:
             msg = 'SentenceTransformerEmbedder not available'
-            _LOG.critical(msg)
+            _LOG.error(msg)
             raise ConfigurationError(msg) from e
 
 
@@ -355,27 +359,28 @@ def __call__(self, *args, **kwargs) -> Any:
                 Keyword arguments containing 'config', 'dimensions',
                 and 'index_name'.
         """
-        _LOG.debug('Calling RedisVectorStore %s with args: %s, kwargs: %s',)
         try:
             config = kwargs['config']
             dimensions = kwargs['dimensions']
             index_name = kwargs['index_name']
         except KeyError as e:
             msg = 'config, dimensions, and index_name must be provided'
-            _LOG.critical(msg)
+            _LOG.error(msg)
             raise ConfigurationError(msg) from e
 
         try:
             # pylint: disable=import-outside-toplevel
+            _LOG.info('Importing RedisVectorStore')
             from ragl.store.redis import RedisVectorStore
+            _LOG.info('Creating RedisVectorStore instance')
             return RedisVectorStore(
                 redis_config=config,
                 dimensions=dimensions,
                 index_name=index_name,
             )
         except ImportError as e:
             msg = 'RedisVectorStore not available'
-            _LOG.critical(msg)
+            _LOG.error(msg)
             raise ConfigurationError(msg) from e
 
 

tests/functional/ragl/test_factory.py

@@ -462,19 +462,19 @@ def test_debug_logging_in_call(self):
                           record.levelname == 'DEBUG']
         self.assertTrue(len(debug_messages) > 0)
 
-    def test_critical_logging_on_error(self):
-        """Test critical logging when errors occur."""
+    def test_error_logging_on_error(self):
+        """Test logging when errors occur."""
         factory = EmbedderFactory()
 
-        with self.assertLogs('ragl.factory', level='CRITICAL') as log:
+        with self.assertLogs('ragl.factory', level='ERROR') as log:
             try:
                 factory()  # Missing config
             except ConfigurationError:
                 pass
 
         # Verify critical messages are logged
         critical_messages = [record.levelname for record in log.records if
-                             record.levelname == 'CRITICAL']
+                             record.levelname == 'ERROR']
         self.assertTrue(len(critical_messages) > 0)