pythonLogs 5.0.2__cp313-cp313-macosx_15_0_arm64.whl

pythonLogs/size_rotating.py

@@ -0,0 +1,137 @@
+import logging.handlers
+import os
+import re
+from pathlib import Path
+from typing import Optional
+from pythonLogs.constants import MB_TO_BYTES
+from pythonLogs.log_utils import (
+    check_directory_permissions,
+    check_filename_instance,
+    cleanup_logger_handlers,
+    get_level,
+    get_log_path,
+    get_logger_and_formatter,
+    get_stream_handler,
+    gzip_file_with_sufix,
+    remove_old_logs,
+    write_stderr,
+)
+from pythonLogs.memory_utils import 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__(
+        self,
+        level: Optional[str] = None,
+        name: Optional[str] = None,
+        directory: Optional[str] = None,
+        filenames: Optional[list | tuple] = None,
+        maxmbytes: Optional[int] = None,
+        daystokeep: Optional[int] = None,
+        encoding: Optional[str] = None,
+        datefmt: Optional[str] = None,
+        timezone: Optional[str] = None,
+        streamhandler: Optional[bool] = None,
+        showlocation: Optional[bool] = None,
+    ):
+        _settings = get_log_settings()
+        self.level = get_level(level or _settings.level)
+        self.appname = name or _settings.appname
+        self.directory = directory or _settings.directory
+        self.filenames = filenames or (_settings.filename,)
+        self.maxmbytes = maxmbytes or _settings.max_file_size_mb
+        self.daystokeep = daystokeep or _settings.days_to_keep
+        self.encoding = encoding or _settings.encoding
+        self.datefmt = datefmt or _settings.date_format
+        self.timezone = timezone or _settings.timezone
+        self.streamhandler = streamhandler or _settings.stream_handler
+        self.showlocation = showlocation or _settings.show_location
+        self.logger = None
+
+    def init(self):
+        check_filename_instance(self.filenames)
+        check_directory_permissions(self.directory)
+
+        logger, formatter = get_logger_and_formatter(self.appname, self.datefmt, self.showlocation, self.timezone)
+        logger.setLevel(self.level)
+
+        for file in self.filenames:
+            log_file_path = get_log_path(self.directory, file)
+
+            file_handler = logging.handlers.RotatingFileHandler(
+                filename=log_file_path,
+                mode="a",
+                maxBytes=self.maxmbytes * MB_TO_BYTES,
+                backupCount=self.daystokeep,
+                encoding=self.encoding,
+                delay=False,
+                errors=None,
+            )
+            file_handler.rotator = GZipRotatorSize(self.directory, self.daystokeep)
+            file_handler.setFormatter(formatter)
+            file_handler.setLevel(self.level)
+            logger.addHandler(file_handler)
+
+        if self.streamhandler:
+            stream_hdlr = get_stream_handler(self.level, formatter)
+            logger.addHandler(stream_hdlr)
+
+        self.logger = logger
+        # Register weak reference for memory tracking
+        register_logger_weakref(logger)
+        return logger
+
+    def __enter__(self):
+        """Context manager entry."""
+        if not hasattr(self, 'logger') or self.logger is None:
+            self.init()
+        return self.logger
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit with automatic cleanup."""
+        if hasattr(self, 'logger'):
+            self._cleanup_logger(self.logger)
+
+    def _cleanup_logger(self, logger: logging.Logger) -> None:
+        """Clean up logger resources by closing all handlers with thread safety."""
+        cleanup_logger_handlers(logger)
+
+    @staticmethod
+    def cleanup_logger(logger: logging.Logger) -> None:
+        """Static method for cleaning up logger resources (backward compatibility)."""
+        cleanup_logger_handlers(logger)
+
+
+class GZipRotatorSize:
+    def __init__(self, dir_logs: str, daystokeep: int):
+        self.directory = dir_logs
+        self.daystokeep = daystokeep
+
+    def __call__(self, source: str, dest: str) -> None:
+        remove_old_logs(self.directory, self.daystokeep)
+        if os.path.isfile(source) and os.stat(source).st_size > 0:
+            source_filename, _ = os.path.basename(source).split(".")
+            new_file_number = self._get_new_file_number(self.directory, source_filename)
+            if os.path.isfile(source):
+                gzip_file_with_sufix(source, str(new_file_number))
+
+    @staticmethod
+    def _get_new_file_number(directory: str, source_filename: str) -> int:
+        pattern = re.compile(rf"{re.escape(source_filename)}_(\d+)\.log\.gz$")
+        max_num = 0
+        try:
+            # Use pathlib for better performance with large directories
+            dir_path = Path(directory)
+            for file_path in dir_path.iterdir():
+                if file_path.is_file():
+                    match = pattern.match(file_path.name)
+                    if match:
+                        max_num = max(max_num, int(match.group(1)))
+        except OSError as e:
+            write_stderr(f"Unable to get previous gz log file number | {repr(e)}")
+        return max_num + 1

pythonLogs/thread_safety.py

@@ -0,0 +1,156 @@
+import functools
+import threading
+from typing import Any, Callable, Dict, Type, TypeVar
+
+
+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 _get_wrappable_methods(cls: Type) -> list:
+    """Helper function to get methods that should be made thread-safe."""
+    return [
+        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__']
+        )
+    ]
+
+
+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:
+        _ensure_class_has_lock(cls)
+
+        # 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 _get_wrappable_methods(cls)
+
+        # Wrap each method
+        for method_name in methods_to_wrap:
+            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
+
+    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/timed_rotating.py

@@ -0,0 +1,126 @@
+import logging.handlers
+import os
+from typing import Optional
+from pythonLogs.log_utils import (
+    check_directory_permissions,
+    check_filename_instance,
+    cleanup_logger_handlers,
+    get_level,
+    get_log_path,
+    get_logger_and_formatter,
+    get_stream_handler,
+    gzip_file_with_sufix,
+    remove_old_logs,
+)
+from pythonLogs.memory_utils import 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.
+
+    Current 'rotating_when' events supported for TimedRotatingLogs:
+    Use RotateWhen enum values:
+        RotateWhen.MIDNIGHT - roll over at midnight
+        RotateWhen.MONDAY through RotateWhen.SUNDAY - roll over on specific days
+        RotateWhen.HOURLY - roll over every hour
+        RotateWhen.DAILY - roll over daily
+    """
+
+    def __init__(
+        self,
+        level: Optional[str] = None,
+        name: Optional[str] = None,
+        directory: Optional[str] = None,
+        filenames: Optional[list | tuple] = None,
+        when: Optional[str] = None,
+        sufix: Optional[str] = None,
+        daystokeep: Optional[int] = None,
+        encoding: Optional[str] = None,
+        datefmt: Optional[str] = None,
+        timezone: Optional[str] = None,
+        streamhandler: Optional[bool] = None,
+        showlocation: Optional[bool] = None,
+        rotateatutc: Optional[bool] = None,
+    ):
+        _settings = get_log_settings()
+        self.level = get_level(level or _settings.level)
+        self.appname = name or _settings.appname
+        self.directory = directory or _settings.directory
+        self.filenames = filenames or (_settings.filename,)
+        self.when = when or _settings.rotate_when
+        self.sufix = sufix or _settings.rotate_file_sufix
+        self.daystokeep = daystokeep or _settings.days_to_keep
+        self.encoding = encoding or _settings.encoding
+        self.datefmt = datefmt or _settings.date_format
+        self.timezone = timezone or _settings.timezone
+        self.streamhandler = streamhandler or _settings.stream_handler
+        self.showlocation = showlocation or _settings.show_location
+        self.rotateatutc = rotateatutc or _settings.rotate_at_utc
+        self.logger = None
+
+    def init(self):
+        check_filename_instance(self.filenames)
+        check_directory_permissions(self.directory)
+
+        logger, formatter = get_logger_and_formatter(self.appname, self.datefmt, self.showlocation, self.timezone)
+        logger.setLevel(self.level)
+
+        for file in self.filenames:
+            log_file_path = get_log_path(self.directory, file)
+
+            file_handler = logging.handlers.TimedRotatingFileHandler(
+                filename=log_file_path,
+                encoding=self.encoding,
+                when=self.when,
+                utc=self.rotateatutc,
+                backupCount=self.daystokeep,
+            )
+            file_handler.suffix = self.sufix
+            file_handler.rotator = GZipRotatorTimed(self.directory, self.daystokeep)
+            file_handler.setFormatter(formatter)
+            file_handler.setLevel(self.level)
+            logger.addHandler(file_handler)
+
+        if self.streamhandler:
+            stream_hdlr = get_stream_handler(self.level, formatter)
+            logger.addHandler(stream_hdlr)
+
+        self.logger = logger
+        # Register weak reference for memory tracking
+        register_logger_weakref(logger)
+        return logger
+
+    def __enter__(self):
+        """Context manager entry."""
+        if not hasattr(self, 'logger') or self.logger is None:
+            self.init()
+        return self.logger
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit with automatic cleanup."""
+        if hasattr(self, 'logger'):
+            self._cleanup_logger(self.logger)
+
+    def _cleanup_logger(self, logger: logging.Logger) -> None:
+        """Clean up logger resources by closing all handlers with thread safety."""
+        cleanup_logger_handlers(logger)
+
+    @staticmethod
+    def cleanup_logger(logger: logging.Logger) -> None:
+        """Static method for cleaning up logger resources (backward compatibility)."""
+        cleanup_logger_handlers(logger)
+
+
+class GZipRotatorTimed:
+    def __init__(self, dir_logs: str, days_to_keep: int):
+        self.dir = dir_logs
+        self.days_to_keep = days_to_keep
+
+    def __call__(self, source: str, dest: str) -> None:
+        remove_old_logs(self.dir, self.days_to_keep)
+        sufix = os.path.splitext(dest)[1].replace(".", "")
+        gzip_file_with_sufix(source, sufix)