pythonLogs 4.0.2__tar.gz → 4.0.4__tar.gz

{pythonlogs-4.0.2 → pythonlogs-4.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pythonLogs
-Version: 4.0.2
+Version: 4.0.4
 Summary: High-performance Python logging library with file rotation and optimized caching for better performance
 License: MIT
 Keywords: python3,python-3,python,log,logging,logger,logutils,log-utils,pythonLogs
@@ -54,11 +54,14 @@ High-performance Python logging library with file rotation and optimized caching
   - [Timed Rotating Logger](#timed-rotating-logger)
 - [Context Manager Support](#context-manager-support)
 - [Advanced Factory Features](#advanced-factory-features)
+- [Environment Variables](#env-variables-optional--production)
 - [Memory Management](#memory-management)
+- [Flexible Configuration Options](#flexible-configuration-options)
 - [Migration Guide](#migration-guide)
-- [Performance Improvements](#performance-improvements)
-- [Environment Variables](#env-variables-optional)
 - [Development](#source-code)
+- [Run Tests and Get Coverage Report using Poe](#run-tests-and-get-coverage-report-using-poe)
+- [License](#license)
+- [Buy me a cup of coffee](#buy-me-a-cup-of-coffee)
 
 
 
@@ -264,6 +267,7 @@ logger.warning("This is a warning example")
 
 # Context Manager Support
 
+Slow, but if you want immediate, deterministic cleanup for a specific scope.\
 All logger types support context managers for automatic resource cleanup and exception safety:
 
 ## Basic Usage
@@ -333,44 +337,6 @@ assert logger1 is logger2
 clear_logger_registry()
 ```
 
-## Flexible Configuration Options
-You can use either enums (for type safety) or strings (for simplicity):
-
-```python
-from pythonLogs import LogLevel, RotateWhen, LoggerType
-
-# Option 1: Type-safe enums (recommended)
-LogLevel.DEBUG     # "DEBUG"
-LogLevel.INFO      # "INFO"  
-LogLevel.WARNING   # "WARNING"
-LogLevel.ERROR     # "ERROR"
-LogLevel.CRITICAL  # "CRITICAL"
-
-# Option 2: String values (case-insensitive)
-"debug"       # Same as LogLevel.DEBUG
-"info"        # Same as LogLevel.INFO
-"warning"     # Same as LogLevel.WARNING  
-"warn"        # Same as LogLevel.WARN (alias)
-"error"       # Same as LogLevel.ERROR
-"critical"    # Same as LogLevel.CRITICAL
-"crit"        # Same as LogLevel.CRIT (alias)
-# Also supports: "DEBUG", "Info", "Warning", etc.
-
-# RotateWhen values
-RotateWhen.MIDNIGHT   # "midnight"
-RotateWhen.HOURLY     # "H"
-RotateWhen.DAILY      # "D"
-RotateWhen.MONDAY     # "W0"
-# ... through SUNDAY  # "W6"
-# String equivalents: "midnight", "H", "D", "W0"-"W6"
-
-# LoggerType values
-LoggerType.BASIC            # "basic"
-LoggerType.SIZE_ROTATING    # "size_rotating"  
-LoggerType.TIMED_ROTATING   # "timed_rotating"
-# String equivalents: "basic", "size_rotating", "timed_rotating"
-```
-
 ## Production Setup Example
 ```python
 from pythonLogs import size_rotating_logger, timed_rotating_logger, LogLevel, RotateWhen
@@ -415,9 +381,9 @@ audit_logger.info("User admin logged in")
 ```
 
 ## Env Variables (Optional | Production)
-.env variables can be used by leaving all options blank when calling the function
-If not specified inside the .env file, it will use the dafault value
-This is a good approach for production environments, since options can be changed easily
+The .env variables file can be used by leaving all options blank when calling the function.\
+If not specified inside the .env file, it will use the dafault value.\
+This is a good approach for production environments, since options can be changed easily.
 ```python
 from pythonLogs import timed_rotating_logger
 log = timed_rotating_logger()
@@ -447,8 +413,6 @@ LOG_ROTATE_FILE_SUFIX="%Y%m%d"
 ```
 
 
-
-
 # Memory Management
 
 The library includes comprehensive memory management features to prevent memory leaks and optimize resource usage:
@@ -511,37 +475,42 @@ registered = LoggerFactory.get_registered_loggers()
 print(f"Currently registered: {list(registered.keys())}")
 ```
 
-## Thread-Safe Operations
-All memory management operations are thread-safe and can be used safely in multi-threaded applications:
+# Flexible Configuration Options
+You can use either enums (for type safety) or strings (for simplicity):
 
 ```python
-import threading
-from pythonLogs import size_rotating_logger, clear_logger_registry
-
-def worker_function(worker_id):
-    # Each thread can safely create and use loggers
-    logger = size_rotating_logger(
-        name=f"worker_{worker_id}",
-        directory="/app/logs"
-    )
-    
-    with logger as log:
-        log.info(f"Worker {worker_id} started")
-        # Automatic cleanup per thread
-
-# Create multiple threads - all operations are thread-safe
-threads = []
-for i in range(10):
-    thread = threading.Thread(target=worker_function, args=(i,))
-    threads.append(thread)
-    thread.start()
-
-# Wait for completion and clean up
-for thread in threads:
-    thread.join()
-
-# Safe to clear registry from main thread
-clear_logger_registry()
+from pythonLogs import LogLevel, RotateWhen, LoggerType
+
+# Option 1: Type-safe enums (recommended)
+LogLevel.DEBUG     # "DEBUG"
+LogLevel.INFO      # "INFO"  
+LogLevel.WARNING   # "WARNING"
+LogLevel.ERROR     # "ERROR"
+LogLevel.CRITICAL  # "CRITICAL"
+
+# Option 2: String values (case-insensitive)
+"debug"       # Same as LogLevel.DEBUG
+"info"        # Same as LogLevel.INFO
+"warning"     # Same as LogLevel.WARNING  
+"warn"        # Same as LogLevel.WARN (alias)
+"error"       # Same as LogLevel.ERROR
+"critical"    # Same as LogLevel.CRITICAL
+"crit"        # Same as LogLevel.CRIT (alias)
+# Also supports: "DEBUG", "Info", "Warning", etc.
+
+# RotateWhen values
+RotateWhen.MIDNIGHT   # "midnight"
+RotateWhen.HOURLY     # "H"
+RotateWhen.DAILY      # "D"
+RotateWhen.MONDAY     # "W0"
+# ... through SUNDAY  # "W6"
+# String equivalents: "midnight", "H", "D", "W0"-"W6"
+
+# LoggerType values
+LoggerType.BASIC            # "basic"
+LoggerType.SIZE_ROTATING    # "size_rotating"  
+LoggerType.TIMED_ROTATING   # "timed_rotating"
+# String equivalents: "basic", "size_rotating", "timed_rotating"
 ```
 
 
@@ -578,25 +547,6 @@ timed_logger = timed_rotating_logger(level=LogLevel.WARNING, name="app", directo
 - 🔧 **Cleaner API** without manual `.init()` calls
 - 📚 **Centralized configuration** through factory pattern
 
-# Performance Improvements
-
-## Benchmarks
-The factory pattern with optimizations provides significant performance improvements:
-
-| Feature | Improvement | Benefit |
-|---------|-------------|---------|
-| Logger Registry | 90%+ faster | Cached logger instances |
-| Settings Caching | ~85% faster | Reused configuration objects |
-| Directory Validation | ~75% faster | Cached permission checks |
-| Timezone Operations | ~60% faster | Cached timezone functions |
-
-## Performance Test Results
-```python
-# Create 100 loggers - Performance comparison
-# Legacy method:     ~0.045 seconds
-# Factory pattern:   ~0.004 seconds  
-# Improvement:       91% faster ⚡
-```
 
 # Source Code
 ### Build
@@ -605,7 +555,6 @@ poetry build -f wheel
 ```
 
 
-
 # Run Tests and Get Coverage Report using Poe
 ```shell
 poetry update --with test
@@ -613,13 +562,10 @@ poe test
 ```
 
 
-
 # License
 Released under the [MIT License](LICENSE)
 
 
-
-
 # Buy me a cup of coffee
 + [GitHub Sponsor](https://github.com/sponsors/ddc)
 + [ko-fi](https://ko-fi.com/ddcsta)

{pythonlogs-4.0.2 → pythonlogs-4.0.4}/README.md

@@ -24,11 +24,14 @@ High-performance Python logging library with file rotation and optimized caching
   - [Timed Rotating Logger](#timed-rotating-logger)
 - [Context Manager Support](#context-manager-support)
 - [Advanced Factory Features](#advanced-factory-features)
+- [Environment Variables](#env-variables-optional--production)
 - [Memory Management](#memory-management)
+- [Flexible Configuration Options](#flexible-configuration-options)
 - [Migration Guide](#migration-guide)
-- [Performance Improvements](#performance-improvements)
-- [Environment Variables](#env-variables-optional)
 - [Development](#source-code)
+- [Run Tests and Get Coverage Report using Poe](#run-tests-and-get-coverage-report-using-poe)
+- [License](#license)
+- [Buy me a cup of coffee](#buy-me-a-cup-of-coffee)
 
 
 
@@ -234,6 +237,7 @@ logger.warning("This is a warning example")
 
 # Context Manager Support
 
+Slow, but if you want immediate, deterministic cleanup for a specific scope.\
 All logger types support context managers for automatic resource cleanup and exception safety:
 
 ## Basic Usage
@@ -303,44 +307,6 @@ assert logger1 is logger2
 clear_logger_registry()
 ```
 
-## Flexible Configuration Options
-You can use either enums (for type safety) or strings (for simplicity):
-
-```python
-from pythonLogs import LogLevel, RotateWhen, LoggerType
-
-# Option 1: Type-safe enums (recommended)
-LogLevel.DEBUG     # "DEBUG"
-LogLevel.INFO      # "INFO"  
-LogLevel.WARNING   # "WARNING"
-LogLevel.ERROR     # "ERROR"
-LogLevel.CRITICAL  # "CRITICAL"
-
-# Option 2: String values (case-insensitive)
-"debug"       # Same as LogLevel.DEBUG
-"info"        # Same as LogLevel.INFO
-"warning"     # Same as LogLevel.WARNING  
-"warn"        # Same as LogLevel.WARN (alias)
-"error"       # Same as LogLevel.ERROR
-"critical"    # Same as LogLevel.CRITICAL
-"crit"        # Same as LogLevel.CRIT (alias)
-# Also supports: "DEBUG", "Info", "Warning", etc.
-
-# RotateWhen values
-RotateWhen.MIDNIGHT   # "midnight"
-RotateWhen.HOURLY     # "H"
-RotateWhen.DAILY      # "D"
-RotateWhen.MONDAY     # "W0"
-# ... through SUNDAY  # "W6"
-# String equivalents: "midnight", "H", "D", "W0"-"W6"
-
-# LoggerType values
-LoggerType.BASIC            # "basic"
-LoggerType.SIZE_ROTATING    # "size_rotating"  
-LoggerType.TIMED_ROTATING   # "timed_rotating"
-# String equivalents: "basic", "size_rotating", "timed_rotating"
-```
-
 ## Production Setup Example
 ```python
 from pythonLogs import size_rotating_logger, timed_rotating_logger, LogLevel, RotateWhen
@@ -385,9 +351,9 @@ audit_logger.info("User admin logged in")
 ```
 
 ## Env Variables (Optional | Production)
-.env variables can be used by leaving all options blank when calling the function
-If not specified inside the .env file, it will use the dafault value
-This is a good approach for production environments, since options can be changed easily
+The .env variables file can be used by leaving all options blank when calling the function.\
+If not specified inside the .env file, it will use the dafault value.\
+This is a good approach for production environments, since options can be changed easily.
 ```python
 from pythonLogs import timed_rotating_logger
 log = timed_rotating_logger()
@@ -417,8 +383,6 @@ LOG_ROTATE_FILE_SUFIX="%Y%m%d"
 ```
 
 
-
-
 # Memory Management
 
 The library includes comprehensive memory management features to prevent memory leaks and optimize resource usage:
@@ -481,37 +445,42 @@ registered = LoggerFactory.get_registered_loggers()
 print(f"Currently registered: {list(registered.keys())}")
 ```
 
-## Thread-Safe Operations
-All memory management operations are thread-safe and can be used safely in multi-threaded applications:
+# Flexible Configuration Options
+You can use either enums (for type safety) or strings (for simplicity):
 
 ```python
-import threading
-from pythonLogs import size_rotating_logger, clear_logger_registry
-
-def worker_function(worker_id):
-    # Each thread can safely create and use loggers
-    logger = size_rotating_logger(
-        name=f"worker_{worker_id}",
-        directory="/app/logs"
-    )
-    
-    with logger as log:
-        log.info(f"Worker {worker_id} started")
-        # Automatic cleanup per thread
-
-# Create multiple threads - all operations are thread-safe
-threads = []
-for i in range(10):
-    thread = threading.Thread(target=worker_function, args=(i,))
-    threads.append(thread)
-    thread.start()
-
-# Wait for completion and clean up
-for thread in threads:
-    thread.join()
-
-# Safe to clear registry from main thread
-clear_logger_registry()
+from pythonLogs import LogLevel, RotateWhen, LoggerType
+
+# Option 1: Type-safe enums (recommended)
+LogLevel.DEBUG     # "DEBUG"
+LogLevel.INFO      # "INFO"  
+LogLevel.WARNING   # "WARNING"
+LogLevel.ERROR     # "ERROR"
+LogLevel.CRITICAL  # "CRITICAL"
+
+# Option 2: String values (case-insensitive)
+"debug"       # Same as LogLevel.DEBUG
+"info"        # Same as LogLevel.INFO
+"warning"     # Same as LogLevel.WARNING  
+"warn"        # Same as LogLevel.WARN (alias)
+"error"       # Same as LogLevel.ERROR
+"critical"    # Same as LogLevel.CRITICAL
+"crit"        # Same as LogLevel.CRIT (alias)
+# Also supports: "DEBUG", "Info", "Warning", etc.
+
+# RotateWhen values
+RotateWhen.MIDNIGHT   # "midnight"
+RotateWhen.HOURLY     # "H"
+RotateWhen.DAILY      # "D"
+RotateWhen.MONDAY     # "W0"
+# ... through SUNDAY  # "W6"
+# String equivalents: "midnight", "H", "D", "W0"-"W6"
+
+# LoggerType values
+LoggerType.BASIC            # "basic"
+LoggerType.SIZE_ROTATING    # "size_rotating"  
+LoggerType.TIMED_ROTATING   # "timed_rotating"
+# String equivalents: "basic", "size_rotating", "timed_rotating"
 ```
 
 
@@ -548,25 +517,6 @@ timed_logger = timed_rotating_logger(level=LogLevel.WARNING, name="app", directo
 - 🔧 **Cleaner API** without manual `.init()` calls
 - 📚 **Centralized configuration** through factory pattern
 
-# Performance Improvements
-
-## Benchmarks
-The factory pattern with optimizations provides significant performance improvements:
-
-| Feature | Improvement | Benefit |
-|---------|-------------|---------|
-| Logger Registry | 90%+ faster | Cached logger instances |
-| Settings Caching | ~85% faster | Reused configuration objects |
-| Directory Validation | ~75% faster | Cached permission checks |
-| Timezone Operations | ~60% faster | Cached timezone functions |
-
-## Performance Test Results
-```python
-# Create 100 loggers - Performance comparison
-# Legacy method:     ~0.045 seconds
-# Factory pattern:   ~0.004 seconds  
-# Improvement:       91% faster ⚡
-```
 
 # Source Code
 ### Build
@@ -575,7 +525,6 @@ poetry build -f wheel
 ```
 
 
-
 # Run Tests and Get Coverage Report using Poe
 ```shell
 poetry update --with test
@@ -583,13 +532,10 @@ poe test
 ```
 
 
-
 # License
 Released under the [MIT License](LICENSE)
 
 
-
-
 # Buy me a cup of coffee
 + [GitHub Sponsor](https://github.com/sponsors/ddc)
 + [ko-fi](https://ko-fi.com/ddcsta)

{pythonlogs-4.0.2 → pythonlogs-4.0.4}/pyproject.toml

@@ -2,10 +2,9 @@
 requires = ["poetry-core>=2.0.0,<3.0.0"]
 build-backend = "poetry.core.masonry.api"
 
-
 [tool.poetry]
 name = "pythonLogs"
-version = "4.0.2"
+version = "4.0.4"
 description = "High-performance Python logging library with file rotation and optimized caching for better performance"
 license = "MIT"
 readme = "README.md"
@@ -31,51 +30,43 @@ classifiers = [
     "Natural Language :: English",
 ]
 
-
 [tool.poetry.dependencies]
 python = "^3.10"
 pydantic = "^2.11.7"
 pydantic-settings = "^2.10.1"
 python-dotenv = "^1.1.1"
 
-
 [tool.poetry.group.test.dependencies]
 coverage = "^7.9.2"
 poethepoet = "^0.36.0"
 psutil = "^7.0.0"
 pytest = "^8.4.1"
 
+[tool.poe.tasks]
+_test = "coverage run -m pytest -v"
+_coverage_report = "coverage report"
+_coverage_xml = "coverage xml"
+tests = ["_test", "_coverage_report", "_coverage_xml"]
+test = ["tests"]
 
 [tool.poetry.group.test]
 optional = true
 
-
 [tool.black]
 line-length = 120
 skip-string-normalization = true
 
-
 [tool.pytest.ini_options]
 markers = [
     "slow: marks tests as slow (deselect with '-m \"not slow\"')"
 ]
 
-
 [tool.coverage.run]
 omit = [
     "tests/*",
 ]
 
-
 [tool.coverage.report]
 exclude_lines = [
     "pragma: no cover",
 ]
-
-
-[tool.poe.tasks]
-_test = "coverage run -m pytest -v"
-_coverage_report = "coverage report"
-_coverage_xml = "coverage xml"
-tests = ["_test", "_coverage_report", "_coverage_xml"]
-test = ["tests"]

{pythonlogs-4.0.2 → pythonlogs-4.0.4}/pythonLogs/basic_log.py

@@ -1,12 +1,13 @@
 # -*- encoding: utf-8 -*-
 import logging
-import threading
 from typing import Optional
 from pythonLogs.log_utils import get_format, get_level, get_timezone_function
 from pythonLogs.memory_utils import cleanup_logger_handlers, register_logger_weakref
 from pythonLogs.settings import get_log_settings
+from pythonLogs.thread_safety import auto_thread_safe
 
 
+@auto_thread_safe(['init', '_cleanup_logger'])
 class BasicLog:
     """Basic logger with context manager support for automatic resource cleanup."""
 
@@ -27,8 +28,6 @@ class BasicLog:
         self.timezone = timezone or _settings.timezone
         self.showlocation = showlocation or _settings.show_location
         self.logger = None
-        # Instance-level lock for thread safety
-        self._lock = threading.Lock()
 
     def init(self):
         logger = logging.getLogger(self.appname)
@@ -54,8 +53,7 @@ class BasicLog:
 
     def _cleanup_logger(self, logger: logging.Logger) -> None:
         """Clean up logger resources by closing all handlers with thread safety."""
-        with self._lock:
-            cleanup_logger_handlers(logger)
+        cleanup_logger_handlers(logger)
 
     @staticmethod
     def cleanup_logger(logger: logging.Logger) -> None:

{pythonlogs-4.0.2 → pythonlogs-4.0.4}/pythonLogs/size_rotating.py

@@ -2,7 +2,6 @@
 import logging.handlers
 import os
 import re
-import threading
 from typing import Optional
 from pythonLogs.constants import MB_TO_BYTES
 from pythonLogs.log_utils import (
@@ -18,8 +17,10 @@ from pythonLogs.log_utils import (
 )
 from pythonLogs.memory_utils import cleanup_logger_handlers, register_logger_weakref
 from pythonLogs.settings import get_log_settings
+from pythonLogs.thread_safety import auto_thread_safe
 
 
+@auto_thread_safe(['init', '_cleanup_logger'])
 class SizeRotatingLog:
     """Size-based rotating logger with context manager support for automatic resource cleanup."""
     def __init__(
@@ -49,8 +50,6 @@ class SizeRotatingLog:
         self.streamhandler = streamhandler or _settings.stream_handler
         self.showlocation = showlocation or _settings.show_location
         self.logger = None
-        # Instance-level lock for thread safety
-        self._lock = threading.Lock()
 
     def init(self):
         check_filename_instance(self.filenames)
@@ -98,8 +97,7 @@ class SizeRotatingLog:
     
     def _cleanup_logger(self, logger: logging.Logger) -> None:
         """Clean up logger resources by closing all handlers with thread safety."""
-        with self._lock:
-            cleanup_logger_handlers(logger)
+        cleanup_logger_handlers(logger)
     
     @staticmethod
     def cleanup_logger(logger: logging.Logger) -> None:

pythonlogs-4.0.4/pythonLogs/thread_safety.py

@@ -0,0 +1,135 @@
+# -*- encoding: utf-8 -*-
+import functools
+import threading
+from typing import Any, Callable, Dict, TypeVar, Type
+
+F = TypeVar('F', bound=Callable[..., Any])
+
+
+class ThreadSafeMeta(type):
+    """Metaclass that automatically adds thread safety to class methods."""
+    
+    def __new__(mcs, name: str, bases: tuple, namespace: Dict[str, Any], **kwargs):
+        # Create the class first
+        cls = super().__new__(mcs, name, bases, namespace)
+        
+        # Add a class-level lock if not already present
+        if not hasattr(cls, '_lock'):
+            cls._lock = threading.RLock()
+        
+        # Get methods that should be thread-safe (exclude private/dunder methods)
+        thread_safe_methods = getattr(cls, '_thread_safe_methods', None)
+        if thread_safe_methods is None:
+            # Auto-detect public methods that modify state
+            thread_safe_methods = [
+                method_name for method_name in namespace
+                if (callable(getattr(cls, method_name, None)) and 
+                    not method_name.startswith('_') and
+                    method_name not in ['__enter__', '__exit__', '__init__'])
+            ]
+        
+        # Wrap each method with automatic locking
+        for method_name in thread_safe_methods:
+            if hasattr(cls, method_name):
+                original_method = getattr(cls, method_name)
+                if callable(original_method):
+                    wrapped_method = thread_safe(original_method)
+                    setattr(cls, method_name, wrapped_method)
+        
+        return cls
+
+
+def thread_safe(func: F) -> F:
+    """Decorator that automatically adds thread safety to methods."""
+    
+    @functools.wraps(func)
+    def wrapper(self, *args, **kwargs):
+        # Use instance lock if available, otherwise class lock
+        lock = getattr(self, '_lock', None)
+        if lock is None:
+            # Check if class has lock, if not create one
+            if not hasattr(self.__class__, '_lock'):
+                self.__class__._lock = threading.RLock()
+            lock = self.__class__._lock
+        
+        with lock:
+            return func(self, *args, **kwargs)
+    
+    return wrapper
+
+
+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()
+        
+        # Store thread-safe methods list
+        if thread_safe_methods:
+            cls._thread_safe_methods = thread_safe_methods
+        
+        # Get methods to make thread-safe
+        methods_to_wrap = thread_safe_methods or [
+            method_name for method_name in dir(cls)
+            if (callable(getattr(cls, method_name, None)) and 
+                not method_name.startswith('_') and
+                method_name not in ['__enter__', '__exit__', '__init__'])
+        ]
+        
+        # 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)
+        
+        return cls
+    
+    return decorator
+
+
+class AutoThreadSafe:
+    """Base class that provides automatic thread safety for all public methods."""
+    
+    def __init__(self):
+        if not hasattr(self, '_lock'):
+            self._lock = threading.RLock()
+    
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        
+        # Add class-level lock
+        if not hasattr(cls, '_lock'):
+            cls._lock = threading.RLock()
+        
+        # Auto-wrap public methods
+        for attr_name in dir(cls):
+            if not attr_name.startswith('_'):
+                attr = getattr(cls, attr_name)
+                if callable(attr) and not hasattr(attr, '_thread_safe_wrapped'):
+                    wrapped_attr = thread_safe(attr)
+                    wrapped_attr._thread_safe_wrapped = True
+                    setattr(cls, attr_name, wrapped_attr)
+
+
+def synchronized_method(func: F) -> F:
+    """Decorator for individual methods that need thread safety."""
+    return thread_safe(func)
+
+
+class ThreadSafeContext:
+    """Context manager for thread-safe operations."""
+    
+    def __init__(self, lock: threading.Lock):
+        self.lock = lock
+    
+    def __enter__(self):
+        self.lock.acquire()
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.lock.release()

{pythonlogs-4.0.2 → pythonlogs-4.0.4}/pythonLogs/timed_rotating.py

@@ -1,7 +1,6 @@
 # -*- encoding: utf-8 -*-
 import logging.handlers
 import os
-import threading
 from typing import Optional
 from pythonLogs.log_utils import (
     check_directory_permissions,
@@ -15,8 +14,10 @@ from pythonLogs.log_utils import (
 )
 from pythonLogs.memory_utils import cleanup_logger_handlers, register_logger_weakref
 from pythonLogs.settings import get_log_settings
+from pythonLogs.thread_safety import auto_thread_safe
 
 
+@auto_thread_safe(['init', '_cleanup_logger'])
 class TimedRotatingLog:
     """
     Time-based rotating logger with context manager support for automatic resource cleanup.
@@ -60,8 +61,6 @@ class TimedRotatingLog:
         self.showlocation = showlocation or _settings.show_location
         self.rotateatutc = rotateatutc or _settings.rotate_at_utc
         self.logger = None
-        # Instance-level lock for thread safety
-        self._lock = threading.Lock()
 
     def init(self):
         check_filename_instance(self.filenames)
@@ -107,8 +106,7 @@ class TimedRotatingLog:
 
     def _cleanup_logger(self, logger: logging.Logger) -> None:
         """Clean up logger resources by closing all handlers with thread safety."""
-        with self._lock:
-            cleanup_logger_handlers(logger)
+        cleanup_logger_handlers(logger)
 
     @staticmethod
     def cleanup_logger(logger: logging.Logger) -> None: