V4.0.6

Author: ddc

pythonLogs/factory.py

@@ -3,6 +3,7 @@
 import logging
 import threading
 import time
+from dataclasses import dataclass
 from enum import Enum
 from typing import Dict, Optional, Tuple, Union
 from pythonLogs.basic_log import BasicLog
@@ -12,6 +13,25 @@
 from pythonLogs.timed_rotating import TimedRotatingLog
 
 
+@dataclass
+class LoggerConfig:
+    """Configuration class to group logger parameters"""
+    level: Optional[Union[LogLevel, str]] = None
+    name: Optional[str] = None
+    directory: Optional[str] = None
+    filenames: Optional[list | tuple] = None
+    encoding: Optional[str] = None
+    datefmt: Optional[str] = None
+    timezone: Optional[str] = None
+    streamhandler: Optional[bool] = None
+    showlocation: Optional[bool] = None
+    maxmbytes: Optional[int] = None
+    when: Optional[Union[RotateWhen, str]] = None
+    sufix: Optional[str] = None
+    rotateatutc: Optional[bool] = None
+    daystokeep: Optional[int] = None
+
+
 class LoggerType(str, Enum):
     """Available logger types"""
     BASIC = "basic"
@@ -189,42 +209,17 @@ def get_registered_loggers(cls) -> dict[str, logging.Logger]:
     @staticmethod
     def create_logger(
         logger_type: Union[LoggerType, str],
-        level: Optional[Union[LogLevel, str]] = None,
-        name: Optional[str] = None,
-        directory: Optional[str] = None,
-        filenames: Optional[list | tuple] = None,
-        encoding: Optional[str] = None,
-        datefmt: Optional[str] = None,
-        timezone: Optional[str] = None,
-        streamhandler: Optional[bool] = None,
-        showlocation: Optional[bool] = None,  # Size rotating specific
-        maxmbytes: Optional[int] = None,  # Timed rotating specific
-        when: Optional[Union[RotateWhen, str]] = None,
-        sufix: Optional[str] = None,
-        rotateatutc: Optional[bool] = None,
-        # Common
-        daystokeep: Optional[int] = None,
+        config: Optional[LoggerConfig] = None,
+        **kwargs
     ) -> logging.Logger:
 
         """
         Factory method to create loggers based on type.
         
         Args:
             logger_type: Type of logger to create (LoggerType enum or string)
-            level: Log level (LogLevel enum or string: DEBUG, INFO, WARNING, ERROR, CRITICAL)
-            name: Logger name
-            directory: Log directory path
-            filenames: List/tuple of log filenames
-            encoding: File encoding
-            datefmt: Date format string
-            timezone: Timezone for timestamps
-            streamhandler: Enable console output
-            showlocation: Show file location in logs
-            maxmbytes: Max file size in MB (size rotating only)
-            when: When to rotate (RotateWhen enum or string: MIDNIGHT, HOURLY, DAILY, etc.)
-            sufix: Date suffix for rotated files (timed rotating only)
-            rotateatutc: Rotate at UTC time (timed rotating only)
-            daystokeep: Days to keep old logs
+            config: LoggerConfig object with logger parameters
+            **kwargs: Individual logger parameters (for backward compatibility)
             
         Returns:
             Configured logger instance
@@ -239,50 +234,72 @@ def create_logger(
             except ValueError:
                 raise ValueError(f"Invalid logger type: {logger_type}. Valid types: {[t.value for t in LoggerType]}")
 
+        # Merge config and kwargs (kwargs take precedence for backward compatibility)
+        if config is None:
+            config = LoggerConfig()
+        
+        # Create a new config with kwargs overriding config values
+        final_config = LoggerConfig(
+            level=kwargs.get('level', config.level),
+            name=kwargs.get('name', config.name),
+            directory=kwargs.get('directory', config.directory),
+            filenames=kwargs.get('filenames', config.filenames),
+            encoding=kwargs.get('encoding', config.encoding),
+            datefmt=kwargs.get('datefmt', config.datefmt),
+            timezone=kwargs.get('timezone', config.timezone),
+            streamhandler=kwargs.get('streamhandler', config.streamhandler),
+            showlocation=kwargs.get('showlocation', config.showlocation),
+            maxmbytes=kwargs.get('maxmbytes', config.maxmbytes),
+            when=kwargs.get('when', config.when),
+            sufix=kwargs.get('sufix', config.sufix),
+            rotateatutc=kwargs.get('rotateatutc', config.rotateatutc),
+            daystokeep=kwargs.get('daystokeep', config.daystokeep)
+        )
+
         # Convert enum values to strings for logger classes
-        level_str = level.value if isinstance(level, LogLevel) else level
-        when_str = when.value if isinstance(when, RotateWhen) else when
+        level_str = final_config.level.value if isinstance(final_config.level, LogLevel) else final_config.level
+        when_str = final_config.when.value if isinstance(final_config.when, RotateWhen) else final_config.when
 
         # Create logger based on type
         match logger_type:
             case LoggerType.BASIC:
                 logger_instance = BasicLog(
                     level=level_str,
-                    name=name,
-                    encoding=encoding,
-                    datefmt=datefmt,
-                    timezone=timezone,
-                    showlocation=showlocation, )
+                    name=final_config.name,
+                    encoding=final_config.encoding,
+                    datefmt=final_config.datefmt,
+                    timezone=final_config.timezone,
+                    showlocation=final_config.showlocation, )
 
             case LoggerType.SIZE_ROTATING:
                 logger_instance = SizeRotatingLog(
                     level=level_str,
-                    name=name,
-                    directory=directory,
-                    filenames=filenames,
-                    maxmbytes=maxmbytes,
-                    daystokeep=daystokeep,
-                    encoding=encoding,
-                    datefmt=datefmt,
-                    timezone=timezone,
-                    streamhandler=streamhandler,
-                    showlocation=showlocation, )
+                    name=final_config.name,
+                    directory=final_config.directory,
+                    filenames=final_config.filenames,
+                    maxmbytes=final_config.maxmbytes,
+                    daystokeep=final_config.daystokeep,
+                    encoding=final_config.encoding,
+                    datefmt=final_config.datefmt,
+                    timezone=final_config.timezone,
+                    streamhandler=final_config.streamhandler,
+                    showlocation=final_config.showlocation, )
 
             case LoggerType.TIMED_ROTATING:
                 logger_instance = TimedRotatingLog(
                     level=level_str,
-                    name=name,
-                    directory=directory,
-                    filenames=filenames,
+                    name=final_config.name,
+                    directory=final_config.directory,
+                    filenames=final_config.filenames,
                     when=when_str,
-                    sufix=sufix,
-                    daystokeep=daystokeep,
-                    encoding=encoding,
-                    datefmt=datefmt,
-                    timezone=timezone,
-                    streamhandler=streamhandler,
-                    showlocation=showlocation,
-                    rotateatutc=rotateatutc, )
+                    sufix=final_config.sufix,
+                    daystokeep=final_config.daystokeep,
+                    encoding=final_config.encoding,
+                    datefmt=final_config.datefmt,
+                    timezone=final_config.timezone,
+                    streamhandler=final_config.streamhandler,
+                    showlocation=final_config.showlocation,
+                    rotateatutc=final_config.rotateatutc, )
 
             case _:
                 raise ValueError(f"Unsupported logger type: {logger_type}")

pythonLogs/settings.py

@@ -11,7 +11,7 @@
     DEFAULT_ROTATE_SUFFIX,
     DEFAULT_TIMEZONE,
     LogLevel,
-    RotateWhen
+    RotateWhen,
 )
 
 

pythonLogs/thread_safety.py

@@ -1,7 +1,8 @@
 # -*- encoding: utf-8 -*-
 import functools
 import threading
-from typing import Any, Callable, Dict, TypeVar, Type
+from typing import Any, Callable, Dict, Type, TypeVar
+
 
 F = TypeVar('F', bound=Callable[..., Any])
 
@@ -68,13 +69,24 @@ def _get_wrappable_methods(cls: Type) -> list:
     ]
 
 
+def _ensure_class_has_lock(cls: Type) -> None:
+    """Ensure the class has a lock attribute."""
+    if not hasattr(cls, '_lock'):
+        cls._lock = threading.RLock()
+
+
+def _should_wrap_method(cls: Type, method_name: str, original_method: Any) -> bool:
+    """Check if a method should be wrapped with thread safety."""
+    return (hasattr(cls, method_name) and 
+            callable(original_method) and 
+            not hasattr(original_method, '_thread_safe_wrapped'))
+
+
 def auto_thread_safe(thread_safe_methods: list = None):
     """Class decorator that adds automatic thread safety to specified methods."""
 
     def decorator(cls: Type) -> Type:
-        # Add lock to class if not present
-        if not hasattr(cls, '_lock'):
-            cls._lock = threading.RLock()
+        _ensure_class_has_lock(cls)
 
         # Store thread-safe methods list
         if thread_safe_methods:
@@ -85,12 +97,11 @@ def decorator(cls: Type) -> Type:
 
         # Wrap each method
         for method_name in methods_to_wrap:
-            if hasattr(cls, method_name):
-                original_method = getattr(cls, method_name)
-                if callable(original_method) and not hasattr(original_method, '_thread_safe_wrapped'):
-                    wrapped_method = thread_safe(original_method)
-                    wrapped_method._thread_safe_wrapped = True
-                    setattr(cls, method_name, wrapped_method)
+            original_method = getattr(cls, method_name, None)
+            if _should_wrap_method(cls, method_name, original_method):
+                wrapped_method = thread_safe(original_method)
+                wrapped_method._thread_safe_wrapped = True
+                setattr(cls, method_name, wrapped_method)
 
         return cls
 
@@ -137,4 +148,4 @@ def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        self.lock.release()
+        self.lock.release()

pythonLogs/timed_rotating.py

@@ -10,7 +10,7 @@
     get_logger_and_formatter,
     get_stream_handler,
     gzip_file_with_sufix,
-    remove_old_logs,
+     remove_old_logs,
 )
 from pythonLogs.memory_utils import cleanup_logger_handlers, register_logger_weakref
 from pythonLogs.settings import get_log_settings

tests/context_management/test_context_managers.py

@@ -23,25 +23,21 @@
 class TestContextManagers:
     """Test context manager functionality for resource management."""
 
-    def setup_method(self):
+    @pytest.fixture(autouse=True)
+    def setup_temp_dir(self):
         """Set up test fixtures before each test method."""
         # Clear any existing loggers
         clear_logger_registry()
 
-        # Create temporary directory for log files
-        self.temp_dir = tempfile.mkdtemp()
-        self.log_file = "test.log"
-
-    def teardown_method(self):
-        """Clean up after each test method."""
+        # Create temporary directory for log files using context manager
+        with tempfile.TemporaryDirectory() as temp_dir:
+            self.temp_dir = temp_dir
+            self.log_file = "test.log"
+            yield
+        
         # Clear registry after each test
         clear_logger_registry()
 
-        # Clean up temporary files
-        import shutil
-        if os.path.exists(self.temp_dir):
-            shutil.rmtree(self.temp_dir, ignore_errors=True)
-
     def test_basic_log_context_manager(self):
         """Test BasicLog as context manager."""
         logger_name = "test_basic_context"

tests/context_management/test_resource_management.py

@@ -23,25 +23,21 @@
 class TestResourceManagement:
     """Test resource management functionality."""
 
-    def setup_method(self):
+    @pytest.fixture(autouse=True)
+    def setup_temp_dir(self):
         """Set up test fixtures before each test method."""
         # Clear any existing loggers
         clear_logger_registry()
 
-        # Create temporary directory for log files
-        self.temp_dir = tempfile.mkdtemp()
-        self.log_file = "resource_test.log"
-
-    def teardown_method(self):
-        """Clean up after each test method."""
+        # Create temporary directory for log files using context manager
+        with tempfile.TemporaryDirectory() as temp_dir:
+            self.temp_dir = temp_dir
+            self.log_file = "resource_test.log"
+            yield
+        
         # Clear registry after each test
         clear_logger_registry()
 
-        # Clean up temporary files
-        import shutil
-        if os.path.exists(self.temp_dir):
-            shutil.rmtree(self.temp_dir, ignore_errors=True)
-
     def test_factory_registry_cleanup(self):
         """Test that factory registry cleanup properly closes handlers."""
         logger_name = "test_registry_cleanup"
@@ -273,7 +269,9 @@ def create_and_cleanup_logger(index):
         # Create multiple threads doing concurrent operations
         num_threads = 5
         with concurrent.futures.ThreadPoolExecutor(max_workers=num_threads) as executor:
-            futures = [executor.submit(create_and_cleanup_logger, i) for i in range(num_threads)]
+            futures = []
+            for i in range(num_threads):
+                futures.append(executor.submit(create_and_cleanup_logger, i))
 
             # Wait for all to complete
             results = []