pythonLogs 5.0.1__cp312-cp312-win_amd64.whl

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/__init__.py

@@ -0,0 +1,91 @@
+import logging
+from importlib.metadata import version
+from typing import Literal, NamedTuple
+from pythonLogs.basic_log import BasicLog
+from pythonLogs.constants import LogLevel, RotateWhen
+from pythonLogs.factory import (
+    basic_logger,
+    clear_logger_registry,
+    create_logger,
+    get_or_create_logger,
+    get_registered_loggers,
+    LoggerFactory,
+    LoggerType,
+    shutdown_logger,
+    size_rotating_logger,
+    timed_rotating_logger,
+)
+from pythonLogs.memory_utils import (
+    clear_directory_cache,
+    clear_formatter_cache,
+    force_garbage_collection,
+    get_memory_stats,
+    optimize_lru_cache_sizes,
+    set_directory_cache_limit,
+)
+from pythonLogs.size_rotating import SizeRotatingLog
+from pythonLogs.timed_rotating import TimedRotatingLog
+
+
+__all__ = (
+    "BasicLog",
+    "TimedRotatingLog",
+    "SizeRotatingLog",
+    "LoggerFactory",
+    "LoggerType",
+    "LogLevel",
+    "RotateWhen",
+    "create_logger",
+    "get_or_create_logger",
+    "basic_logger",
+    "size_rotating_logger",
+    "timed_rotating_logger",
+    "clear_logger_registry",
+    "get_registered_loggers",
+    "shutdown_logger",
+    # Memory management utilities
+    "get_memory_stats",
+    "clear_formatter_cache",
+    "clear_directory_cache",
+    "force_garbage_collection",
+    "optimize_lru_cache_sizes",
+    "set_directory_cache_limit",
+)
+
+__title__ = "pythonLogs"
+__author__ = "Daniel Costa"
+__email__ = "danieldcsta@gmail.com>"
+__license__ = "MIT"
+__copyright__ = "Copyright 2024-present ddc"
+_req_python_version = (3, 12, 0)
+
+
+try:
+    _version = tuple(int(x) for x in version(__title__).split("."))
+except ModuleNotFoundError:
+    _version = (0, 0, 0)
+
+
+class VersionInfo(NamedTuple):
+    major: int
+    minor: int
+    micro: int
+    releaselevel: Literal["alpha", "beta", "candidate", "final"]
+    serial: int
+
+
+__version__ = _version
+__version_info__: VersionInfo = VersionInfo(
+    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,
+)
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
+del logging, NamedTuple, Literal, VersionInfo, version, _version, _req_python_version

pythonLogs/basic_log.py

@@ -0,0 +1,68 @@
+import logging
+from typing import Optional
+from pythonLogs.log_utils import get_format, get_level, get_timezone_function
+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
+
+
+@auto_thread_safe(['init', '_cleanup_logger'])
+class BasicLog:
+    """Basic logger with context manager support for automatic resource cleanup."""
+
+    def __init__(
+        self,
+        level: Optional[str] = None,
+        name: Optional[str] = None,
+        encoding: Optional[str] = None,
+        datefmt: Optional[str] = None,
+        timezone: Optional[str] = None,
+        showlocation: Optional[bool] = None,
+    ):
+        _settings = get_log_settings()
+        self.level = get_level(level or _settings.level)
+        self.appname = name or _settings.appname
+        self.encoding = encoding or _settings.encoding
+        self.datefmt = datefmt or _settings.date_format
+        self.timezone = timezone or _settings.timezone
+        self.showlocation = showlocation or _settings.show_location
+        self.logger = None
+
+    def init(self):
+        logger = logging.getLogger(self.appname)
+        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)
+        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)

pythonLogs/constants.py

@@ -0,0 +1,56 @@
+import logging
+from enum import Enum
+
+# File and Directory Constants
+MB_TO_BYTES = 1024 * 1024
+DEFAULT_FILE_MODE = 0o755
+DEFAULT_BACKUP_COUNT = 30
+
+# Date Format Constants
+DEFAULT_DATE_FORMAT = "%Y-%m-%dT%H:%M:%S"
+DEFAULT_ROTATE_SUFFIX = "%Y%m%d"
+
+# Encoding Constants
+DEFAULT_ENCODING = "UTF-8"
+
+# Timezone Constants
+DEFAULT_TIMEZONE = "UTC"
+
+
+class LogLevel(str, Enum):
+    """Log levels"""
+
+    CRITICAL = "CRITICAL"
+    CRIT = "CRIT"
+    ERROR = "ERROR"
+    WARNING = "WARNING"
+    WARN = "WARN"
+    INFO = "INFO"
+    DEBUG = "DEBUG"
+
+
+class RotateWhen(str, Enum):
+    """Rotation timing options for TimedRotatingLog"""
+
+    MIDNIGHT = "midnight"
+    MONDAY = "W0"
+    TUESDAY = "W1"
+    WEDNESDAY = "W2"
+    THURSDAY = "W3"
+    FRIDAY = "W4"
+    SATURDAY = "W5"
+    SUNDAY = "W6"
+    HOURLY = "H"
+    DAILY = "D"
+
+
+# Level mapping for performance optimization
+LEVEL_MAP = {
+    LogLevel.DEBUG.value.lower(): logging.DEBUG,
+    LogLevel.WARNING.value.lower(): logging.WARNING,
+    LogLevel.WARN.value.lower(): logging.WARNING,
+    LogLevel.ERROR.value.lower(): logging.ERROR,
+    LogLevel.CRITICAL.value.lower(): logging.CRITICAL,
+    LogLevel.CRIT.value.lower(): logging.CRITICAL,
+    LogLevel.INFO.value.lower(): logging.INFO,
+}

pythonLogs/factory.py

@@ -0,0 +1,446 @@
+import atexit
+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
+from pythonLogs.constants import LogLevel, RotateWhen
+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
+
+
+@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"
+    SIZE_ROTATING = "size_rotating"
+    TIMED_ROTATING = "timed_rotating"
+
+
+class LoggerFactory:
+    """Factory for creating different types of loggers with optimized instantiation and memory management"""
+
+    # Logger registry for reusing loggers by name with timestamp tracking
+    _logger_registry: Dict[str, Tuple[logging.Logger, float]] = {}
+    # Thread lock for registry access
+    _registry_lock = threading.RLock()
+    # Memory optimization settings
+    _max_loggers = 100  # Maximum number of cached loggers
+    _logger_ttl = 3600  # Logger TTL in seconds (1 hour)
+    _initialized = False  # Flag to track if memory limits have been initialized
+    _atexit_registered = False  # Flag to track if atexit cleanup is registered
+
+    @classmethod
+    def _ensure_initialized(cls) -> None:
+        """Ensure memory limits are initialized from settings on first use."""
+        if not cls._initialized:
+            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)
+            cls._atexit_registered = True
+
+    @classmethod
+    def get_or_create_logger(
+        cls,
+        logger_type: Union[LoggerType, str],
+        name: Optional[str] = None,
+        **kwargs,
+    ) -> logging.Logger:
+        """
+        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:
+            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()
+
+            # Check if logger already exists in the registry
+            if name in cls._logger_registry:
+                logger, _ = cls._logger_registry[name]
+                # Update timestamp for LRU tracking
+                cls._logger_registry[name] = (logger, time.time())
+                return logger
+
+            # Ensure registry size limit
+            cls._enforce_size_limit()
+
+            # Create a new logger and cache it with timestamp
+            logger = cls.create_logger(logger_type, name=name, **kwargs)
+            cls._logger_registry[name] = (logger, time.time())
+            return logger
+
+    @classmethod
+    def clear_registry(cls) -> None:
+        """Clear the logger registry with proper resource cleanup."""
+        with cls._registry_lock:
+            for logger, _ in cls._logger_registry.values():
+                cls._cleanup_logger(logger)
+            cls._logger_registry.clear()
+
+    @classmethod
+    def _cleanup_expired_loggers(cls) -> None:
+        """Remove expired loggers from registry based on TTL."""
+        current_time = time.time()
+        expired_keys = []
+
+        for name, (logger, timestamp) in cls._logger_registry.items():
+            if current_time - timestamp > cls._logger_ttl:
+                expired_keys.append(name)
+                cls._cleanup_logger(logger)
+
+        for key in expired_keys:
+            cls._logger_registry.pop(key, None)
+
+    @classmethod
+    def _enforce_size_limit(cls) -> None:
+        """Enforce maximum registry size by removing the oldest entries (LRU eviction)."""
+        if cls._max_loggers <= 0:
+            # Special case: if max_loggers is 0 or negative, clear all
+            cls.clear_registry()
+            return
+
+        if len(cls._logger_registry) >= cls._max_loggers:
+            # Sort by timestamp (oldest first) and remove the oldest entries
+            sorted_entries = sorted(cls._logger_registry.items(), key=lambda x: x[1][1])
+            entries_to_remove = len(sorted_entries) - cls._max_loggers + 1
+
+            for i in range(min(entries_to_remove, len(sorted_entries))):
+                name, (logger, _) = sorted_entries[i]
+                cls._cleanup_logger(logger)
+                cls._logger_registry.pop(name, None)
+
+    @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
+        """
+        with cls._registry_lock:
+            cls._max_loggers = max_loggers
+            cls._logger_ttl = ttl_seconds
+            cls._initialized = True  # Mark as manually configured
+            # Clean up immediately with new settings
+            cls._cleanup_expired_loggers()
+            cls._enforce_size_limit()
+
+    @classmethod
+    def _atexit_cleanup(cls) -> None:
+        """Cleanup function registered with atexit to ensure proper resource cleanup."""
+        try:
+            cls.clear_registry()
+        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."""
+        cleanup_logger_handlers(logger)
+
+    @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
+        """
+        with cls._registry_lock:
+            if name in cls._logger_registry:
+                logger, _ = cls._logger_registry.pop(name)
+                cls._cleanup_logger(logger)
+                return True
+            return False
+
+    @classmethod
+    def get_registered_loggers(cls) -> dict[str, logging.Logger]:
+        """Get all registered loggers. Returns a copy of the registry."""
+        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
+    ) -> 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
+        """
+        # Convert string to enum if needed
+        if isinstance(logger_type, str):
+            try:
+                logger_type = LoggerType(logger_type.lower())
+            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 = 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=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=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=final_config.name,
+                    directory=final_config.directory,
+                    filenames=final_config.filenames,
+                    when=when_str,
+                    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}")
+
+        return logger_instance.init()
+
+    @staticmethod
+    def create_basic_logger(
+        level: Optional[Union[LogLevel, str]] = None,
+        name: Optional[str] = None,
+        encoding: Optional[str] = None,
+        datefmt: Optional[str] = None,
+        timezone: Optional[str] = None,
+        showlocation: Optional[bool] = None,
+    ) -> logging.Logger:
+        """Convenience method for creating a basic logger"""
+        return LoggerFactory.create_logger(
+            LoggerType.BASIC,
+            level=level,
+            name=name,
+            encoding=encoding,
+            datefmt=datefmt,
+            timezone=timezone,
+            showlocation=showlocation,
+        )
+
+    @staticmethod
+    def create_size_rotating_logger(
+        level: Optional[Union[LogLevel, 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,
+    ) -> logging.Logger:
+        """Convenience method for creating a size rotating logger"""
+        return LoggerFactory.create_logger(
+            LoggerType.SIZE_ROTATING,
+            level=level,
+            name=name,
+            directory=directory,
+            filenames=filenames,
+            maxmbytes=maxmbytes,
+            daystokeep=daystokeep,
+            encoding=encoding,
+            datefmt=datefmt,
+            timezone=timezone,
+            streamhandler=streamhandler,
+            showlocation=showlocation,
+        )
+
+    @staticmethod
+    def create_timed_rotating_logger(
+        level: Optional[Union[LogLevel, str]] = None,
+        name: Optional[str] = None,
+        directory: Optional[str] = None,
+        filenames: Optional[list | tuple] = None,
+        when: Optional[Union[RotateWhen, 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,
+    ) -> logging.Logger:
+        """Convenience method for creating a timed rotating logger"""
+        return LoggerFactory.create_logger(
+            LoggerType.TIMED_ROTATING,
+            level=level,
+            name=name,
+            directory=directory,
+            filenames=filenames,
+            when=when,
+            sufix=sufix,
+            daystokeep=daystokeep,
+            encoding=encoding,
+            datefmt=datefmt,
+            timezone=timezone,
+            streamhandler=streamhandler,
+            showlocation=showlocation,
+            rotateatutc=rotateatutc,
+        )
+
+
+# Convenience functions for backward compatibility and easier usage
+def create_logger(logger_type: Union[LoggerType, str], **kwargs) -> logging.Logger:
+    """Convenience function to create a logger using the factory"""
+    return LoggerFactory.create_logger(logger_type, **kwargs)
+
+
+def get_or_create_logger(logger_type: Union[LoggerType, str], **kwargs) -> logging.Logger:
+    """Convenience function to get cached or create a logger using the factory"""
+    return LoggerFactory.get_or_create_logger(logger_type, **kwargs)
+
+
+def basic_logger(**kwargs) -> logging.Logger:
+    """Convenience function to create a basic logger"""
+    return LoggerFactory.create_basic_logger(**kwargs)
+
+
+def size_rotating_logger(**kwargs) -> logging.Logger:
+    """Convenience function to create a size rotating logger"""
+    return LoggerFactory.create_size_rotating_logger(**kwargs)
+
+
+def timed_rotating_logger(**kwargs) -> logging.Logger:
+    """Convenience function to create a timed rotating logger"""
+    return LoggerFactory.create_timed_rotating_logger(**kwargs)
+
+
+def clear_logger_registry() -> None:
+    """Convenience function to clear the logger registry with proper cleanup"""
+    LoggerFactory.clear_registry()
+
+
+def shutdown_logger(name: str) -> bool:
+    """Convenience function to shut down a specific logger"""
+    return LoggerFactory.shutdown_logger(name)
+
+
+def get_registered_loggers() -> dict[str, logging.Logger]:
+    """Convenience function to get all registered loggers"""
+    return LoggerFactory.get_registered_loggers()