pythonLogs 5.0.0__tar.gz → 5.0.2__tar.gz

{pythonlogs-5.0.0 → pythonlogs-5.0.2}/PKG-INFO

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: pythonLogs
-Version: 5.0.0
+Version: 5.0.2
 Summary: High-performance Python logging library with file rotation and optimized caching for better performance
 License: MIT
+License-File: LICENSE
 Keywords: python3,python-3,python,log,logging,logger,logutils,log-utils,pythonLogs
 Author: Daniel Costa
 Author-email: danieldcsta@gmail.com
@@ -17,9 +18,10 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Dist: pydantic-settings (>=2.10.1,<3.0.0)
+Requires-Dist: pydantic-settings (==2.11.0)
 Requires-Dist: python-dotenv (>=1.1.1,<2.0.0)
 Project-URL: Homepage, https://pypi.org/project/pythonLogs
 Project-URL: Repository, https://github.com/ddc/pythonLogs

{pythonlogs-5.0.0 → pythonlogs-5.0.2}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["poetry-core>=2.0.0,<3.0.0"]
+requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "pythonLogs"
-version = "5.0.0"
+version = "5.0.2"
 description = "High-performance Python logging library with file rotation and optimized caching for better performance"
 license = "MIT"
 readme = "README.md"
@@ -39,37 +39,48 @@ optional = true
 
 [tool.poetry.dependencies]
 python = "^3.12"
-pydantic-settings = "^2.10.1"
+pydantic-settings = "2.11.0"
 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"
+poethepoet = "^0.37.0"
+psutil = "^7.1.0"
+pytest = "^8.4.2"
+pytest-cov = "^7.0.0"
 
 [tool.poe.tasks]
-_test = "coverage run -m pytest -v"
-_coverage_report = "coverage report"
-_coverage_xml = "coverage xml"
-tests = ["_test", "_coverage_report", "_coverage_xml"]
+_test = "python -m pytest -v --cov --cov-report=term --cov-report=xml --junitxml=junit.xml -o junit_family=legacy"
+tests = ["_test"]
 test = ["tests"]
 
-[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 = [
+    "build.py",
     "tests/*",
+    "*/__init__.py",
 ]
 
 [tool.coverage.report]
 exclude_lines = [
     "pragma: no cover",
+    "def __repr__",
+    "if self.debug:",
+    "if settings.DEBUG",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if 0:",
+    "if __name__ == .__main__.:",
+    "class .*\\bProtocol\\):",
+    "@(abc\\.)?abstractmethod",
 ]
+show_missing = false
+skip_covered = false
+
+[tool.pytest.ini_options]
+markers = [
+    "slow: marks tests as slow (deselect with '-m \"not slow\"')"
+]
+
+[tool.black]
+line-length = 120
+skip-string-normalization = true

pythonlogs-5.0.2/pythonLogs/.env.example

@@ -0,0 +1,32 @@
+# pythonLogs Environment Configuration
+# Copy this file to .env and modify values as needed
+
+# Basic Logger Settings
+LOG_LEVEL=DEBUG
+LOG_TIMEZONE=UTC
+LOG_ENCODING=UTF-8
+LOG_APPNAME=app
+LOG_FILENAME=app.log
+LOG_DIRECTORY=/app/logs
+LOG_DAYS_TO_KEEP=30
+LOG_DATE_FORMAT=%Y-%m-%dT%H:%M:%S
+LOG_STREAM_HANDLER=True
+LOG_SHOW_LOCATION=False
+
+# Memory Management Settings
+LOG_MAX_LOGGERS=50
+LOG_LOGGER_TTL_SECONDS=1800
+
+# SizeRotatingLog Settings
+LOG_MAX_FILE_SIZE_MB=10
+
+# TimedRotatingLog Settings
+LOG_ROTATE_WHEN=midnight
+LOG_ROTATE_AT_UTC=True
+LOG_ROTATE_FILE_SUFIX=%Y%m%d
+
+# Available LOG_LEVEL values: DEBUG, INFO, WARNING, ERROR, CRITICAL
+# Available LOG_TIMEZONE values: UTC, localtime, or any valid timezone (e.g., America/New_York)
+# Available LOG_ROTATE_WHEN values: midnight, S, M, H, D, W0-W6, daily, hourly, weekly
+# LOG_STREAM_HANDLER: Set to True to enable console output, False to disable
+# LOG_SHOW_LOCATION: Set to True to include filename:function:line in log messages

{pythonlogs-5.0.0 → pythonlogs-5.0.2}/pythonLogs/__init__.py

@@ -1,4 +1,3 @@
-# -*- encoding: utf-8 -*-
 import logging
 from importlib.metadata import version
 from typing import Literal, NamedTuple
@@ -14,7 +13,7 @@ from pythonLogs.factory import (
     LoggerType,
     shutdown_logger,
     size_rotating_logger,
-    timed_rotating_logger
+    timed_rotating_logger,
 )
 from pythonLogs.memory_utils import (
     clear_directory_cache,
@@ -22,7 +21,7 @@ from pythonLogs.memory_utils import (
     force_garbage_collection,
     get_memory_stats,
     optimize_lru_cache_sizes,
-    set_directory_cache_limit
+    set_directory_cache_limit,
 )
 from pythonLogs.size_rotating import SizeRotatingLog
 from pythonLogs.timed_rotating import TimedRotatingLog
@@ -77,18 +76,14 @@ class VersionInfo(NamedTuple):
 
 __version__ = _version
 __version_info__: VersionInfo = VersionInfo(
-    major=__version__[0],
-    minor=__version__[1],
-    micro=__version__[2],
-    releaselevel="final",
-    serial=0
+    major=__version__[0], minor=__version__[1], micro=__version__[2], releaselevel="final", serial=0
 )
 __req_python_version__: VersionInfo = VersionInfo(
     major=_req_python_version[0],
     minor=_req_python_version[1],
     micro=_req_python_version[2],
     releaselevel="final",
-    serial=0
+    serial=0,
 )
 
 logging.getLogger(__name__).addHandler(logging.NullHandler())

{pythonlogs-5.0.0 → pythonlogs-5.0.2}/pythonLogs/basic_log.py

@@ -1,8 +1,8 @@
-# -*- encoding: utf-8 -*-
 import logging
 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.log_utils import cleanup_logger_handlers
+from pythonLogs.memory_utils import register_logger_weakref
 from pythonLogs.settings import get_log_settings
 from pythonLogs.thread_safety import auto_thread_safe
 
@@ -34,14 +34,14 @@ class BasicLog:
         logger.setLevel(self.level)
         logging.Formatter.converter = get_timezone_function(self.timezone)
         _format = get_format(self.showlocation, self.appname, self.timezone)
-        
+
         # Only add handler if logger doesn't have any handlers
         if not logger.handlers:
             handler = logging.StreamHandler()
             formatter = logging.Formatter(_format, datefmt=self.datefmt)
             handler.setFormatter(formatter)
             logger.addHandler(handler)
-        
+
         self.logger = logger
         # Register weak reference for memory tracking
         register_logger_weakref(logger)

{pythonlogs-5.0.0 → pythonlogs-5.0.2}/pythonLogs/constants.py

@@ -1,4 +1,3 @@
-# -*- encoding: utf-8 -*-
 import logging
 from enum import Enum
 
@@ -20,6 +19,7 @@ DEFAULT_TIMEZONE = "UTC"
 
 class LogLevel(str, Enum):
     """Log levels"""
+
     CRITICAL = "CRITICAL"
     CRIT = "CRIT"
     ERROR = "ERROR"
@@ -31,6 +31,7 @@ class LogLevel(str, Enum):
 
 class RotateWhen(str, Enum):
     """Rotation timing options for TimedRotatingLog"""
+
     MIDNIGHT = "midnight"
     MONDAY = "W0"
     TUESDAY = "W1"

{pythonlogs-5.0.0 → pythonlogs-5.0.2}/pythonLogs/factory.py

@@ -1,4 +1,3 @@
-# -*- encoding: utf-8 -*-
 import atexit
 import logging
 import threading
@@ -8,7 +7,8 @@ from enum import Enum
 from typing import Dict, Optional, Tuple, Union
 from pythonLogs.basic_log import BasicLog
 from pythonLogs.constants import LogLevel, RotateWhen
-from pythonLogs.memory_utils import cleanup_logger_handlers
+from pythonLogs.log_utils import cleanup_logger_handlers
+from pythonLogs.settings import get_log_settings
 from pythonLogs.size_rotating import SizeRotatingLog
 from pythonLogs.timed_rotating import TimedRotatingLog
 
@@ -16,6 +16,7 @@ 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
@@ -34,6 +35,7 @@ class LoggerConfig:
 
 class LoggerType(str, Enum):
     """Available logger types"""
+
     BASIC = "basic"
     SIZE_ROTATING = "size_rotating"
     TIMED_ROTATING = "timed_rotating"
@@ -56,12 +58,11 @@ class LoggerFactory:
     def _ensure_initialized(cls) -> None:
         """Ensure memory limits are initialized from settings on first use."""
         if not cls._initialized:
-            from pythonLogs.settings import get_log_settings
             settings = get_log_settings()
             cls._max_loggers = settings.max_loggers
             cls._logger_ttl = settings.logger_ttl_seconds
             cls._initialized = True
-            
+
         # Register atexit cleanup on first use
         if not cls._atexit_registered:
             atexit.register(cls._atexit_cleanup)
@@ -71,30 +72,30 @@ class LoggerFactory:
     def get_or_create_logger(
         cls,
         logger_type: Union[LoggerType, str],
-        name: Optional[str] = None, **kwargs,
+        name: Optional[str] = None,
+        **kwargs,
     ) -> logging.Logger:
         """
-        Get an existing logger from registry or create new one.
+        Get an existing logger from registry or create a new one.
         Loggers are cached by name for performance.
-        
+
         Args:
             logger_type: Type of logger to create
             name: Logger name (used as cache key)
             **kwargs: Additional logger configuration
-            
+
         Returns:
             Cached or newly created logger instance
         """
         # Use the default name if none provided
         if name is None:
-            from pythonLogs.settings import get_log_settings
             name = get_log_settings().appname
 
         # Thread-safe check-and-create operation
         with cls._registry_lock:
             # Initialize memory limits from settings on first use
             cls._ensure_initialized()
-            
+
             # Clean up expired loggers first
             cls._cleanup_expired_loggers()
 
@@ -156,7 +157,7 @@ class LoggerFactory:
     @classmethod
     def set_memory_limits(cls, max_loggers: int = 100, ttl_seconds: int = 3600) -> None:
         """Configure memory management limits for the logger registry at runtime.
-        
+
         Args:
             max_loggers: Maximum number of cached loggers
             ttl_seconds: Time-to-live for cached loggers in seconds
@@ -177,7 +178,7 @@ class LoggerFactory:
         except Exception:
             # Silently ignore exceptions during shutdown cleanup
             pass
-    
+
     @staticmethod
     def _cleanup_logger(logger: logging.Logger) -> None:
         """Clean up logger resources by closing all handlers."""
@@ -186,10 +187,10 @@ class LoggerFactory:
     @classmethod
     def shutdown_logger(cls, name: str) -> bool:
         """Shutdown and remove a specific logger from registry.
-        
+
         Args:
             name: Logger name to shut down
-            
+
         Returns:
             True if logger was found and shutdown, False otherwise
         """
@@ -206,24 +207,34 @@ class LoggerFactory:
         with cls._registry_lock:
             return {name: logger for name, (logger, _) in cls._logger_registry.items()}
 
+    @classmethod
+    def get_memory_limits(cls) -> dict[str, int]:
+        """Get current memory management limits.
+        
+        Returns:
+            Dictionary with current max_loggers and ttl_seconds settings
+        """
+        with cls._registry_lock:
+            return {
+                'max_loggers': cls._max_loggers,
+                'ttl_seconds': cls._logger_ttl
+            }
+
     @staticmethod
     def create_logger(
-        logger_type: Union[LoggerType, str],
-        config: Optional[LoggerConfig] = None,
-        **kwargs
+        logger_type: Union[LoggerType, str], 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)
             config: LoggerConfig object with logger parameters
             **kwargs: Individual logger parameters (for backward compatibility)
-            
+
         Returns:
             Configured logger instance
-            
+
         Raises:
             ValueError: If invalid logger_type is provided
         """
@@ -237,7 +248,7 @@ class LoggerFactory:
         # 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),
@@ -253,7 +264,7 @@ class LoggerFactory:
             when=kwargs.get('when', config.when),
             sufix=kwargs.get('sufix', config.sufix),
             rotateatutc=kwargs.get('rotateatutc', config.rotateatutc),
-            daystokeep=kwargs.get('daystokeep', config.daystokeep)
+            daystokeep=kwargs.get('daystokeep', config.daystokeep),
         )
 
         # Convert enum values to strings for logger classes
@@ -269,7 +280,8 @@ class LoggerFactory:
                     encoding=final_config.encoding,
                     datefmt=final_config.datefmt,
                     timezone=final_config.timezone,
-                    showlocation=final_config.showlocation, )
+                    showlocation=final_config.showlocation,
+                )
 
             case LoggerType.SIZE_ROTATING:
                 logger_instance = SizeRotatingLog(
@@ -283,7 +295,8 @@ class LoggerFactory:
                     datefmt=final_config.datefmt,
                     timezone=final_config.timezone,
                     streamhandler=final_config.streamhandler,
-                    showlocation=final_config.showlocation, )
+                    showlocation=final_config.showlocation,
+                )
 
             case LoggerType.TIMED_ROTATING:
                 logger_instance = TimedRotatingLog(
@@ -299,7 +312,8 @@ class LoggerFactory:
                     timezone=final_config.timezone,
                     streamhandler=final_config.streamhandler,
                     showlocation=final_config.showlocation,
-                    rotateatutc=final_config.rotateatutc, )
+                    rotateatutc=final_config.rotateatutc,
+                )
 
             case _:
                 raise ValueError(f"Unsupported logger type: {logger_type}")
@@ -315,7 +329,6 @@ class LoggerFactory:
         timezone: Optional[str] = None,
         showlocation: Optional[bool] = None,
     ) -> logging.Logger:
-
         """Convenience method for creating a basic logger"""
         return LoggerFactory.create_logger(
             LoggerType.BASIC,
@@ -324,7 +337,8 @@ class LoggerFactory:
             encoding=encoding,
             datefmt=datefmt,
             timezone=timezone,
-            showlocation=showlocation, )
+            showlocation=showlocation,
+        )
 
     @staticmethod
     def create_size_rotating_logger(
@@ -340,7 +354,6 @@ class LoggerFactory:
         streamhandler: Optional[bool] = None,
         showlocation: Optional[bool] = None,
     ) -> logging.Logger:
-
         """Convenience method for creating a size rotating logger"""
         return LoggerFactory.create_logger(
             LoggerType.SIZE_ROTATING,
@@ -354,7 +367,8 @@ class LoggerFactory:
             datefmt=datefmt,
             timezone=timezone,
             streamhandler=streamhandler,
-            showlocation=showlocation, )
+            showlocation=showlocation,
+        )
 
     @staticmethod
     def create_timed_rotating_logger(
@@ -365,14 +379,13 @@ class LoggerFactory:
         when: Optional[Union[RotateWhen, str]] = None,
         sufix: Optional[str] = None,
         daystokeep: Optional[int] = None,
-        encoding:Optional[str] = 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,
     ) -> logging.Logger:
-
         """Convenience method for creating a timed rotating logger"""
         return LoggerFactory.create_logger(
             LoggerType.TIMED_ROTATING,
@@ -388,7 +401,8 @@ class LoggerFactory:
             timezone=timezone,
             streamhandler=streamhandler,
             showlocation=showlocation,
-            rotateatutc=rotateatutc, )
+            rotateatutc=rotateatutc,
+        )
 
 
 # Convenience functions for backward compatibility and easier usage

{pythonlogs-5.0.0 → pythonlogs-5.0.2}/pythonLogs/log_utils.py

@@ -1,4 +1,3 @@
-# -*- encoding: utf-8 -*-
 import errno
 import gzip
 import logging.handlers
@@ -10,7 +9,7 @@ import time
 from datetime import datetime, timedelta, timezone as dttz
 from functools import lru_cache
 from pathlib import Path
-from typing import Callable, Set
+from typing import Callable, Optional, Set
 from zoneinfo import ZoneInfo
 from pythonLogs.constants import DEFAULT_FILE_MODE, LEVEL_MAP
 
@@ -139,7 +138,7 @@ def is_older_than_x_days(path: str, days: int) -> bool:
         raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), path)
 
     try:
-        if int(days) in (0, 1):
+        if int(days) == 0:
             cutoff_time = datetime.now()
         else:
             cutoff_time = datetime.now() - timedelta(days=int(days))
@@ -153,17 +152,21 @@ def is_older_than_x_days(path: str, days: int) -> bool:
 
 # Cache stderr timezone for better performance
 @lru_cache(maxsize=1)
-def _get_stderr_timezone():
+def get_stderr_timezone():
     timezone_name = os.getenv("LOG_TIMEZONE", "UTC")
     if timezone_name.lower() == "localtime":
         return None  # Use system local timezone
-    return ZoneInfo(timezone_name)
+    try:
+        return ZoneInfo(timezone_name)
+    except Exception:
+        # Fallback to local timezone if requested timezone is not available
+        return None
 
 
 def write_stderr(msg: str) -> None:
     """Write msg to stderr with optimized timezone handling"""
     try:
-        tz = _get_stderr_timezone()
+        tz = get_stderr_timezone()
         if tz is None:
             # Use local timezone
             dt = datetime.now()
@@ -202,12 +205,17 @@ def get_log_path(directory: str, filename: str) -> str:
 
 
 @lru_cache(maxsize=32)
-def _get_timezone_offset(timezone_: str) -> str:
-    """Cache timezone offset calculation"""
+def get_timezone_offset(timezone_: str) -> str:
+    """Cache timezone offset calculation with fallback for missing timezone data"""
     if timezone_.lower() == "localtime":
         return time.strftime("%z")
     else:
-        return datetime.now(ZoneInfo(timezone_)).strftime("%z")
+        try:
+            return datetime.now(ZoneInfo(timezone_)).strftime("%z")
+        except Exception:
+            # Fallback to localtime if the requested timezone is not available,
+            # This is common on Windows systems without full timezone data
+            return time.strftime("%z")
 
 
 def get_format(show_location: bool, name: str, timezone_: str) -> str:
@@ -221,7 +229,7 @@ def get_format(show_location: bool, name: str, timezone_: str) -> str:
     if show_location:
         _debug_fmt = "[%(filename)s:%(funcName)s:%(lineno)d]:"
 
-    utc_offset = _get_timezone_offset(timezone_)
+    utc_offset = get_timezone_offset(timezone_)
     return f"[%(asctime)s.%(msecs)03d{utc_offset}]:[%(levelname)s]:{_logger_name}{_debug_fmt}%(message)s"
 
 
@@ -235,13 +243,27 @@ def gzip_file_with_sufix(file_path: str, sufix: str) -> str | None:
     # Use pathlib for cleaner path operations
     renamed_dst = path_obj.with_name(f"{path_obj.stem}_{sufix}{path_obj.suffix}.gz")
 
-    try:
-        with open(file_path, "rb") as fin:
-            with gzip.open(renamed_dst, "wb", compresslevel=6) as fout:  # Balanced compression
-                shutil.copyfileobj(fin, fout, length=64*1024)  # type: ignore # 64KB chunks for better performance
-    except (OSError, IOError) as e:
-        write_stderr(f"Unable to gzip log file | {file_path} | {repr(e)}")
-        raise e
+    # Windows-specific retry mechanism for file locking issues
+    max_retries = 3 if sys.platform == "win32" else 1
+    retry_delay = 0.1  # 100ms delay between retries
+
+    for attempt in range(max_retries):
+        try:
+            with open(file_path, "rb") as fin:
+                with gzip.open(renamed_dst, "wb", compresslevel=6) as fout:  # Balanced compression
+                    shutil.copyfileobj(fin, fout, length=64 * 1024)  # type: ignore # 64KB chunks for better performance
+            break  # Success, exit retry loop
+        except PermissionError as e:
+            # Windows file locking issue - retry with delay
+            if attempt < max_retries - 1 and sys.platform == "win32":
+                time.sleep(retry_delay)
+                continue
+            # Final attempt failed or not Windows - treat as regular error
+            write_stderr(f"Unable to gzip log file | {file_path} | {repr(e)}")
+            raise e
+        except (OSError, IOError) as e:
+            write_stderr(f"Unable to gzip log file | {file_path} | {repr(e)}")
+            raise e
 
     try:
         path_obj.unlink()  # Use pathlib for deletion
@@ -254,13 +276,84 @@ def gzip_file_with_sufix(file_path: str, sufix: str) -> str | None:
 
 @lru_cache(maxsize=32)
 def get_timezone_function(time_zone: str) -> Callable:
-    """Get timezone function with caching for better performance"""
+    """Get timezone function with caching and fallback for missing timezone data"""
     match time_zone.lower():
         case "utc":
-            return time.gmtime
+            try:
+                # Try to create UTC timezone to verify it's available
+                ZoneInfo("UTC")
+                return time.gmtime
+            except Exception:
+                # Fallback to localtime if UTC timezone data is missing
+                return time.localtime
         case "localtime":
             return time.localtime
         case _:
-            # Cache the timezone object
-            tz = ZoneInfo(time_zone)
-            return lambda *args: datetime.now(tz=tz).timetuple()
+            try:
+                # Cache the timezone object
+                tz = ZoneInfo(time_zone)
+                return lambda *args: datetime.now(tz=tz).timetuple()
+            except Exception:
+                # Fallback to localtime if the requested timezone is not available
+                return time.localtime
+
+
+# Shared handler cleanup utility
+def cleanup_logger_handlers(logger: Optional[logging.Logger]) -> None:
+    """Clean up logger resources by closing all handlers.
+
+    This is a centralized utility to ensure consistent cleanup behavior
+    across all logger types and prevent code duplication.
+
+    Args:
+        logger: The logger to clean up (can be None)
+    """
+    if logger is None:
+        return
+
+    # Create a snapshot of handlers to avoid modification during iteration
+    handlers_to_remove = list(logger.handlers)
+    for handler in handlers_to_remove:
+        try:
+            handler.close()
+        except (OSError, ValueError):
+            # Ignore errors during cleanup to prevent cascading failures
+            pass
+        finally:
+            logger.removeHandler(handler)
+
+
+# Public API for directory cache management
+def set_directory_cache_limit(max_directories: int) -> None:
+    """Set the maximum number of directories to cache.
+
+    Args:
+        max_directories: Maximum number of directories to keep in cache
+    """
+    global _max_cached_directories
+    
+    with _directory_lock:
+        _max_cached_directories = max_directories
+        # Trim cache if it exceeds new limit
+        while len(_checked_directories) > max_directories:
+            _checked_directories.pop()
+
+
+def clear_directory_cache() -> None:
+    """Clear the directory cache to free memory."""
+    with _directory_lock:
+        _checked_directories.clear()
+
+
+def get_directory_cache_stats() -> dict:
+    """Get statistics about the directory cache.
+    
+    Returns:
+        Dict with cache statistics including size and limit
+    """
+    with _directory_lock:
+        return {
+            "cached_directories": len(_checked_directories),
+            "max_directories": _max_cached_directories,
+            "directories": list(_checked_directories)
+        }

{pythonlogs-5.0.0 → pythonlogs-5.0.2}/pythonLogs/memory_utils.py

@@ -1,34 +1,12 @@
-# -*- encoding: utf-8 -*-
 import logging
 import threading
 import weakref
 from functools import lru_cache
 from typing import Any, Dict, Optional, Set
 
+from . import log_utils
+from .log_utils import cleanup_logger_handlers
 
-# Shared handler cleanup utility
-def cleanup_logger_handlers(logger: Optional[logging.Logger]) -> None:
-    """Clean up logger resources by closing all handlers.
-    
-    This is a centralized utility to ensure consistent cleanup behavior
-    across all logger types and prevent code duplication.
-    
-    Args:
-        logger: The logger to clean up (can be None)
-    """
-    if logger is None:
-        return
-    
-    # Create a snapshot of handlers to avoid modification during iteration
-    handlers_to_remove = list(logger.handlers)
-    for handler in handlers_to_remove:
-        try:
-            handler.close()
-        except (OSError, ValueError):
-            # Ignore errors during cleanup to prevent cascading failures
-            pass
-        finally:
-            logger.removeHandler(handler)
 
 
 # Formatter cache to reduce memory usage for identical formatters
@@ -39,14 +17,14 @@ _max_formatters = 50  # Limit formatter cache size
 
 def get_cached_formatter(format_string: str, datefmt: Optional[str] = None) -> logging.Formatter:
     """Get a cached formatter or create and cache a new one.
-    
+
     This reduces memory usage by reusing formatter instances with
     identical configuration instead of creating new ones each time.
-    
+
     Args:
         format_string: The format string for the formatter
         datefmt: Optional date format string
-        
+
     Returns:
         Cached or newly created formatter instance
     """
@@ -79,23 +57,16 @@ def clear_formatter_cache() -> None:
 # Directory cache utilities with memory management
 def set_directory_cache_limit(max_directories: int) -> None:
     """Set the maximum number of directories to cache.
-    
+
     Args:
         max_directories: Maximum number of directories to keep in cache
     """
-    from . import log_utils
-    with log_utils._directory_lock:
-        log_utils._max_cached_directories = max_directories
-        # Trim cache if it exceeds new limit
-        while len(log_utils._checked_directories) > max_directories:
-            log_utils._checked_directories.pop()
+    log_utils.set_directory_cache_limit(max_directories)
 
 
 def clear_directory_cache() -> None:
     """Clear the directory cache to free memory."""
-    from . import log_utils
-    with log_utils._directory_lock:
-        log_utils._checked_directories.clear()
+    log_utils.clear_directory_cache()
 
 
 # Weak reference registry for tracking active loggers without preventing GC
@@ -105,13 +76,14 @@ _weak_ref_lock = threading.Lock()
 
 def register_logger_weakref(logger: logging.Logger) -> None:
     """Register a weak reference to a logger for memory tracking.
-    
+
     This allows monitoring active loggers without preventing garbage collection.
-    
+
     Args:
         logger: Logger to track
     """
     global _active_loggers
+
     def cleanup_callback(ref):
         with _weak_ref_lock:
             _active_loggers.discard(ref)
@@ -123,7 +95,7 @@ def register_logger_weakref(logger: logging.Logger) -> None:
 
 def get_active_logger_count() -> int:
     """Get the count of currently active loggers.
-    
+
     Returns:
         Number of active logger instances
     """
@@ -137,30 +109,33 @@ def get_active_logger_count() -> int:
 
 def get_memory_stats() -> Dict[str, Any]:
     """Get memory usage statistics for the logging system.
-    
+
     Returns:
         Dictionary containing memory usage statistics
     """
     from . import factory
-
-    with factory.LoggerFactory._registry_lock:
-        registry_size = len(factory.LoggerFactory._logger_registry)
+    
+    # Get registry stats using public API
+    registered_loggers = factory.LoggerFactory.get_registered_loggers()
+    registry_size = len(registered_loggers)
+    
+    # Get memory limits using public API
+    factory_limits = factory.LoggerFactory.get_memory_limits()
 
     with _formatter_cache_lock:
         formatter_cache_size = len(_formatter_cache)
 
-    from . import log_utils
-    with log_utils._directory_lock:
-        directory_cache_size = len(log_utils._checked_directories)
+    # Get directory cache stats using public API
+    directory_stats = log_utils.get_directory_cache_stats()
 
     return {
         'registry_size': registry_size,
         'formatter_cache_size': formatter_cache_size,
-        'directory_cache_size': directory_cache_size,
+        'directory_cache_size': directory_stats['cached_directories'],
         'active_logger_count': get_active_logger_count(),
-        'max_registry_size': factory.LoggerFactory._max_loggers,
+        'max_registry_size': factory_limits['max_loggers'],
         'max_formatter_cache': _max_formatters,
-        'max_directory_cache': log_utils._max_cached_directories,
+        'max_directory_cache': directory_stats['max_directories'],
     }
 
 
@@ -168,33 +143,32 @@ def get_memory_stats() -> Dict[str, Any]:
 def optimize_lru_cache_sizes() -> None:
     """Optimize LRU cache sizes based on typical usage patterns."""
     # Clear existing caches and reduce their sizes
-    from . import log_utils
-
+    
     # Clear and recreate timezone function cache with smaller size
     log_utils.get_timezone_function.cache_clear()
     log_utils.get_timezone_function = lru_cache(maxsize=8)(log_utils.get_timezone_function.__wrapped__)
 
-    # Clear and recreate timezone offset cache with smaller size  
-    log_utils._get_timezone_offset.cache_clear()
-    log_utils._get_timezone_offset = lru_cache(maxsize=8)(log_utils._get_timezone_offset.__wrapped__)
+    # Clear and recreate timezone offset cache with smaller size
+    log_utils.get_timezone_offset.cache_clear()
+    log_utils.get_timezone_offset = lru_cache(maxsize=8)(log_utils.get_timezone_offset.__wrapped__)
 
     # Clear and recreate stderr timezone cache with smaller size
-    log_utils._get_stderr_timezone.cache_clear()
-    log_utils._get_stderr_timezone = lru_cache(maxsize=4)(log_utils._get_stderr_timezone.__wrapped__)
+    log_utils.get_stderr_timezone.cache_clear()
+    log_utils.get_stderr_timezone = lru_cache(maxsize=4)(log_utils.get_stderr_timezone.__wrapped__)
 
 
 def force_garbage_collection() -> Dict[str, int]:
     """Force garbage collection and return collection statistics.
-    
+
     This can be useful for testing memory leaks or forcing cleanup
     in long-running applications.
-    
+
     Returns:
         Dictionary with garbage collection statistics
     """
     import gc
 
-    # Clear all our caches first
+    # Clear all our caches first using public APIs
     clear_formatter_cache()
     clear_directory_cache()
 

{pythonlogs-5.0.0 → pythonlogs-5.0.2}/pythonLogs/settings.py

@@ -1,4 +1,3 @@
-# -*- encoding: utf-8 -*-
 from functools import lru_cache
 from typing import Optional
 from dotenv import load_dotenv
@@ -27,7 +26,7 @@ class LogSettings(BaseSettings):
     encoding: Optional[str] = Field(default=DEFAULT_ENCODING)
     appname: Optional[str] = Field(default="app")
     filename: Optional[str] = Field(default="app.log")
-    directory: Optional[str] = Field(default="/app/logs")
+    directory: Optional[str] = Field(default="./logs")
     days_to_keep: Optional[int] = Field(default=DEFAULT_BACKUP_COUNT)
     date_format: Optional[str] = Field(default=DEFAULT_DATE_FORMAT)
     stream_handler: Optional[bool] = Field(default=True)

{pythonlogs-5.0.0 → pythonlogs-5.0.2}/pythonLogs/size_rotating.py

@@ -1,12 +1,13 @@
-# -*- encoding: utf-8 -*-
 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,
@@ -15,7 +16,7 @@ from pythonLogs.log_utils import (
     remove_old_logs,
     write_stderr,
 )
-from pythonLogs.memory_utils import cleanup_logger_handlers, register_logger_weakref
+from pythonLogs.memory_utils import register_logger_weakref
 from pythonLogs.settings import get_log_settings
 from pythonLogs.thread_safety import auto_thread_safe
 
@@ -23,6 +24,7 @@ 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,
@@ -83,22 +85,22 @@ class SizeRotatingLog:
         # 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)."""
@@ -124,7 +126,6 @@ class GZipRotatorSize:
         max_num = 0
         try:
             # Use pathlib for better performance with large directories
-            from pathlib import Path
             dir_path = Path(directory)
             for file_path in dir_path.iterdir():
                 if file_path.is_file():

{pythonlogs-5.0.0 → pythonlogs-5.0.2}/pythonLogs/thread_safety.py

@@ -1,4 +1,3 @@
-# -*- encoding: utf-8 -*-
 import functools
 import threading
 from typing import Any, Callable, Dict, Type, TypeVar
@@ -9,26 +8,29 @@ 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__'])
+                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):
@@ -36,13 +38,13 @@ class ThreadSafeMeta(type):
                 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
@@ -52,20 +54,23 @@ def thread_safe(func: F) -> F:
             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__'])
+        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__']
+        )
     ]
 
 
@@ -77,24 +82,24 @@ def _ensure_class_has_lock(cls: Type) -> None:
 
 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'))
+    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)
@@ -102,26 +107,26 @@ def auto_thread_safe(thread_safe_methods: list = None):
                 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('_'):
@@ -139,13 +144,13 @@ def synchronized_method(func: F) -> F:
 
 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-5.0.0 → pythonlogs-5.0.2}/pythonLogs/timed_rotating.py

@@ -1,18 +1,18 @@
-# -*- encoding: utf-8 -*-
 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,
+    remove_old_logs,
 )
-from pythonLogs.memory_utils import cleanup_logger_handlers, register_logger_weakref
+from pythonLogs.memory_utils import register_logger_weakref
 from pythonLogs.settings import get_log_settings
 from pythonLogs.thread_safety import auto_thread_safe
 
@@ -21,7 +21,7 @@ from pythonLogs.thread_safety import auto_thread_safe
 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
@@ -40,11 +40,11 @@ class TimedRotatingLog:
         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,
+        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)
@@ -77,7 +77,8 @@ class TimedRotatingLog:
                 encoding=self.encoding,
                 when=self.when,
                 utc=self.rotateatutc,
-                backupCount=self.daystokeep, )
+                backupCount=self.daystokeep,
+            )
             file_handler.suffix = self.sufix
             file_handler.rotator = GZipRotatorTimed(self.directory, self.daystokeep)
             file_handler.setFormatter(formatter)

pythonlogs-5.0.0/pythonLogs/.env.example

@@ -1,20 +0,0 @@
-LOG_LEVEL=DEBUG
-LOG_TIMEZONE=UTC
-LOG_ENCODING=UTF-8
-LOG_APPNAME=app
-LOG_FILENAME=app.log
-LOG_DIRECTORY=/app/logs
-LOG_DAYS_TO_KEEP=30
-LOG_DATE_FORMAT=%Y-%m-%dT%H:%M:%S
-LOG_STREAM_HANDLER=True
-LOG_SHOW_LOCATION=False
-LOG_MAX_LOGGERS=50
-LOG_LOGGER_TTL_SECONDS=1800
-
-# SizeRotatingLog
-LOG_MAX_FILE_SIZE_MB=10
-
-# TimedRotatingLog
-LOG_ROTATE_WHEN=midnight
-LOG_ROTATE_AT_UTC=True
-LOG_ROTATE_FILE_SUFIX="%Y%m%d"