beans-logging 6.0.2__py3-none-any.whl → 7.0.0__py3-none-any.whl

beans_logging/__init__.py

@@ -1,14 +1,14 @@
-from ._base import Logger, logger, LoggerLoader
-from .schemas import LoggerConfigPM
-from ._consts import WarnEnum
+from __future__ import annotations
+
 from .__version__ import __version__
+from .config import LoggerConfigPM
+from ._core import Logger, logger, LoggerLoader
 
 
 __all__ = [
+    "__version__",
+    "LoggerConfigPM",
     "Logger",
     "logger",
     "LoggerLoader",
-    "LoggerConfigPM",
-    "WarnEnum",
-    "__version__",
 ]

beans_logging/__version__.py

@@ -1 +1 @@
-__version__ = "6.0.2"
+__version__ = "7.0.0"

beans_logging/_builder.py

@@ -0,0 +1,154 @@
+import os
+from typing import Any
+
+from pydantic import validate_call
+
+from ._constants import LogHandlerTypeEnum, LogLevelEnum
+from .schemas import LogHandlerPM
+from .config import LoggerConfigPM
+from .sinks import std_sink
+from .formats import json_formatter
+from .filters import (
+    use_all_filter,
+    use_std_filter,
+    use_file_filter,
+    use_file_err_filter,
+    use_file_json_filter,
+    use_file_json_err_filter,
+)
+from .rotators import Rotator
+
+
+@validate_call
+def build_handler(handler: LogHandlerPM, config: LoggerConfigPM) -> dict[str, Any]:
+    """Build handler config as dictionary for Loguru logger to add new handler.
+
+    Args:
+        handler (LogHandlerPM  , required): Target log handler model.
+        config  (LoggerConfigPM, required): Default main config model to fill missing values.
+
+    Raises:
+        ValueError: 'sink' attribute is empty, required for any log handler except std and file handlers!
+
+    Returns:
+        dict[str, Any]: Loguru handler config as dictionary.
+    """
+
+    _handler_dict = handler.model_dump(by_alias=True, exclude_none=True)
+
+    if _handler_dict.get("sink") is None:
+        if _handler_dict.get("type") == LogHandlerTypeEnum.STD:
+            _handler_dict["sink"] = std_sink
+        elif _handler_dict.get("type") == LogHandlerTypeEnum.FILE:
+            _logs_path: str = ""
+            if _handler_dict.get("serialize") or _handler_dict.get("custom_serialize"):
+                if _handler_dict.get("error"):
+                    _logs_path = os.path.join(
+                        config.default.file.logs_dir,
+                        config.default.file.json_.err_path,
+                    )
+                else:
+                    _logs_path = os.path.join(
+                        config.default.file.logs_dir,
+                        config.default.file.json_.log_path,
+                    )
+            else:
+                if _handler_dict.get("error"):
+                    _logs_path = os.path.join(
+                        config.default.file.logs_dir,
+                        config.default.file.plain.err_path,
+                    )
+                else:
+                    _logs_path = os.path.join(
+                        config.default.file.logs_dir,
+                        config.default.file.plain.log_path,
+                    )
+
+            if "{app_name}" in _logs_path:
+                _logs_path = _logs_path.format(app_name=config.app_name)
+
+            _handler_dict["sink"] = _logs_path
+        else:
+            raise ValueError(
+                "'sink' attribute is empty, required for any log handler except std and file handlers!"
+            )
+
+    if _handler_dict.get("level") is None:
+        if _handler_dict.get("error"):
+            _handler_dict["level"] = config.default.level.err
+        else:
+            _handler_dict["level"] = config.default.level.base
+
+    if (_handler_dict.get("custom_serialize") is None) and _handler_dict.get(
+        "serialize"
+    ):
+        _handler_dict["custom_serialize"] = config.default.custom_serialize
+
+    if _handler_dict.get("custom_serialize"):
+        _handler_dict["serialize"] = False
+        _handler_dict["format"] = json_formatter
+
+    if (_handler_dict.get("format") is None) and (not _handler_dict.get("serialize")):
+        if _handler_dict.get("type") == LogHandlerTypeEnum.STD:
+            _handler_dict["format"] = config.default.std.format_str
+        else:
+            _handler_dict["format"] = config.default.format_str
+
+    if _handler_dict.get("filter") is None:
+        if _handler_dict.get("type") == LogHandlerTypeEnum.STD:
+            _handler_dict["filter"] = use_std_filter
+        elif _handler_dict.get("type") == LogHandlerTypeEnum.FILE:
+            if _handler_dict.get("serialize") or _handler_dict.get("custom_serialize"):
+                if _handler_dict.get("error"):
+                    _handler_dict["filter"] = use_file_json_err_filter
+                else:
+                    _handler_dict["filter"] = use_file_json_filter
+            else:
+                if _handler_dict.get("error"):
+                    _handler_dict["filter"] = use_file_err_filter
+                else:
+                    _handler_dict["filter"] = use_file_filter
+        else:
+            _handler_dict["filter"] = use_all_filter
+
+    if _handler_dict.get("backtrace") is None:
+        _handler_dict["backtrace"] = True
+
+    if (_handler_dict.get("diagnose") is None) and (
+        (_handler_dict.get("level") == LogLevelEnum.TRACE)
+        or (_handler_dict.get("level") == 5)
+    ):
+        _handler_dict["diagnose"] = True
+
+    if (_handler_dict.get("colorize") is None) and (
+        _handler_dict.get("type") == LogHandlerTypeEnum.STD
+    ):
+        _handler_dict["colorize"] = config.default.std.colorize
+
+    if _handler_dict.get("type") == LogHandlerTypeEnum.FILE:
+        if _handler_dict.get("enqueue") is None:
+            _handler_dict["enqueue"] = True
+
+        if _handler_dict.get("rotation") is None:
+            _handler_dict["rotation"] = Rotator(
+                rotate_size=config.default.file.rotate_size,
+                rotate_time=config.default.file.rotate_time,
+            ).should_rotate
+
+        if _handler_dict.get("retention") is None:
+            _handler_dict["retention"] = config.default.file.retention
+
+        if _handler_dict.get("encoding") is None:
+            _handler_dict["encoding"] = config.default.file.encoding
+
+    _handler_dict.pop("type", None)
+    _handler_dict.pop("error", None)
+    _handler_dict.pop("custom_serialize", None)
+    _handler_dict.pop("enabled", None)
+
+    return _handler_dict
+
+
+__all__ = [
+    "build_handler",
+]

beans_logging/_constants.py

@@ -0,0 +1,30 @@
+from enum import Enum
+
+
+class LogHandlerTypeEnum(str, Enum):
+    STD = "STD"
+    FILE = "FILE"
+    SOCKET = "SOCKET"
+    HTTP = "HTTP"
+    SYSLOG = "SYSLOG"
+    QUEUE = "QUEUE"
+    MEMORY = "MEMORY"
+    NULL = "NULL"
+    CUSTOM = "CUSTOM"
+    UNKNOWN = "UNKNOWN"
+
+
+class LogLevelEnum(str, Enum):
+    TRACE = "TRACE"
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    SUCCESS = "SUCCESS"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+
+__all__ = [
+    "LogHandlerTypeEnum",
+    "LogLevelEnum",
+]

beans_logging/_core.py

@@ -0,0 +1,295 @@
+# Standard libraries
+import os
+import copy
+import uuid
+from pathlib import Path
+from typing import Any, TYPE_CHECKING
+
+# Third-party libraries
+import potato_util as utils
+
+if TYPE_CHECKING:
+    from loguru import Logger
+else:
+    from loguru._logger import Logger
+from loguru import logger
+from pydantic import validate_call
+from potato_util import io as io_utils
+
+# Internal modules
+from .schemas import LogHandlerPM, LoguruHandlerPM
+from .config import LoggerConfigPM
+from ._builder import build_handler
+from ._intercept import init_intercepter
+
+
+class LoggerLoader:
+    """LoggerLoader class for setting up loguru logger.
+
+    Attributes:
+        _CONFIG_PATH (str): Default config file path. Default is '${PWD}/configs/logger.yml'.
+
+        handlers_map (dict[str, int]): Map of handler names to their IDs. Default is {'default.loguru_handler': 0}.
+        config       (LoggerConfigPM): Main logger configuration model. Default is LoggerConfigPM().
+        config_path  (str           ): Path to logger configuration file. Default is _CONFIG_PATH.
+
+    Methods:
+        load()             : Load logger handlers based on logger config.
+        _load_config_file(): Load logger config from file.
+        update_config()    : Update current logger config with new config values.
+        remove_handler()   : Remove handler from logger.
+        add_handler()      : Add handler to logger.
+    """
+
+    _CONFIG_PATH = os.path.join(os.getcwd(), "configs", "logger.yml")
+
+    @validate_call
+    def __init__(
+        self,
+        config: LoggerConfigPM | dict[str, Any] | None = None,
+        config_path: str = _CONFIG_PATH,
+        auto_load: bool = False,
+        **kwargs,
+    ) -> None:
+
+        self.handlers_map = {"default.loguru_handler": 0}
+        if not config:
+            config = LoggerConfigPM()
+
+        self.config = config
+        if kwargs:
+            self.update_config(config=kwargs)
+
+        self.config_path = config_path
+
+        if auto_load:
+            self.load()
+
+    @validate_call
+    def load(self, load_config_file: bool = True) -> "Logger":
+        """Load logger handlers based on logger config.
+
+        Args:
+            load_config_file (bool, optional): Whether to load config from file before loading handlers.
+                                                    Default is True.
+
+        Returns:
+            Logger: Main loguru logger instance.
+        """
+
+        self.remove_handler()
+        if load_config_file:
+            self._load_config_file()
+
+        for _key, _handler in self.config.handlers.items():
+            self.add_handler(name=_key, handler=_handler)
+
+        init_intercepter(config=self.config)
+        return logger
+
+    def _load_config_file(self) -> None:
+        """Load logger config from file."""
+
+        if self.config_path and os.path.isfile(self.config_path):
+            _config_data = io_utils.read_config_file(config_path=self.config_path)
+            if _config_data and ("logger" in _config_data):
+                _config_data = _config_data.get("logger", {})
+                if _config_data:
+                    self.update_config(config=_config_data)
+
+        return
+
+    @validate_call
+    def update_config(self, config: dict[str, Any]) -> None:
+        """Update current logger config with new config values.
+
+        Args:
+            config (dict[str, Any], required): New config values to update current logger config.
+        """
+
+        _config_dict = self.config.model_dump()
+        _merged_dict = utils.deep_merge(_config_dict, config)
+        try:
+            self.config = LoggerConfigPM(**_merged_dict)
+        except Exception:
+            logger.critical(
+                "Failed to load `config` argument into <class 'LoggerConfigPM'>."
+            )
+            raise
+
+        return
+
+    @validate_call
+    def remove_handler(self, handler: str | int | None = None) -> None:
+        """Remove handler from logger.
+
+        Args:
+            handler (str | int | None, optional): Handler name or ID to remove from logger.
+                                                    Default is None, which removes all handlers.
+
+        Raises:
+            ValueError: If handler name or ID is not found in handlers map.
+        """
+
+        if handler:
+            if isinstance(handler, str):
+                if handler in self.handlers_map:
+                    _handler_id = self.handlers_map.get(handler)
+                    logger.remove(_handler_id)
+                    self.handlers_map.pop(handler)
+                else:
+                    raise ValueError(
+                        f"Not found handler name '{handler}' in handlers map!"
+                    )
+
+            elif isinstance(handler, int):
+                if handler in self.handlers_map.values():
+                    logger.remove(handler)
+                    for _handler_name, _handler_id in list(self.handlers_map.items()):
+                        if handler == _handler_id:
+                            self.handlers_map.pop(_handler_name)
+                            break
+                else:
+                    raise ValueError(
+                        f"Not found handler ID '{handler}' in handlers map!"
+                    )
+        else:
+            logger.remove()
+            self.handlers_map.clear()
+
+        return
+
+    @validate_call
+    def add_handler(
+        self,
+        handler: LogHandlerPM | LoguruHandlerPM | dict[str, Any],
+        name: str | None = None,
+    ) -> int | None:
+        """Add handler to logger.
+
+        Args:
+            handler (LogHandlerPM | LoguruHandlerPM | dict[str, Any], required): Handler model or dictionary to add to
+                                                                                    logger.
+            name    (str | None                                     , optional): Handler name. Default is None.
+
+        Returns:
+            int | None: Handler ID if added successfully, otherwise None.
+        """
+
+        _handler_id: int | None = None
+        try:
+            if isinstance(handler, dict):
+                handler = LogHandlerPM(**handler)
+            elif isinstance(handler, LoguruHandlerPM):
+                handler = LogHandlerPM(
+                    **handler.model_dump(exclude_unset=True, exclude_none=True)
+                )
+
+            if handler.enabled:
+                _handler_dict = build_handler(handler=handler, config=self.config)
+                _sink = _handler_dict.get("sink")
+                if isinstance(_sink, (str, Path)):
+                    _logs_dir = os.path.dirname(_sink)
+                    if _logs_dir:
+                        io_utils.create_dir(create_dir=_logs_dir)
+
+                _handler_id = logger.add(**_handler_dict)
+                if not name:
+                    name = f"log_handler.{uuid.uuid4().hex}"
+
+                self.handlers_map[name] = _handler_id
+
+        except Exception:
+            logger.critical("Failed to add custom log handler to logger!")
+            raise
+
+        return _handler_id
+
+    # ATTRIBUTES
+    # handlers_map
+    @property
+    def handlers_map(self) -> dict[str, int]:
+        try:
+            return self.__handlers_map
+        except AttributeError:
+            raise AttributeError("`handlers_map` attribute is not set!")
+
+    @handlers_map.setter
+    def handlers_map(self, handlers_map: dict[str, int]) -> None:
+        if not isinstance(handlers_map, dict):
+            raise TypeError(
+                f"`handlers_map` attribute type {type(handlers_map)} is invalid, must be <dict>!."
+            )
+
+        self.__handlers_map = copy.deepcopy(handlers_map)
+        return
+
+    # handlers_map
+
+    # config
+    @property
+    def config(self) -> LoggerConfigPM:
+        try:
+            return self.__config
+        except AttributeError:
+            self.__config = LoggerConfigPM()
+
+        return self.__config
+
+    @config.setter
+    def config(self, config: LoggerConfigPM | dict[str, Any]) -> None:
+        if (not isinstance(config, LoggerConfigPM)) and (not isinstance(config, dict)):
+            raise TypeError(
+                f"`config` attribute type {type(config)} is invalid, must be a <class 'LoggerConfigPM'> or <dict>!"
+            )
+
+        if isinstance(config, dict):
+            config = LoggerConfigPM(**config)
+        elif isinstance(config, LoggerConfigPM):
+            config = config.model_copy(deep=True)
+
+        self.__config = config
+        return
+
+    # config
+
+    # config_path
+    @property
+    def config_path(self) -> str:
+        try:
+            return self.__config_path
+        except AttributeError:
+            self.__config_path = LoggerLoader._CONFIG_PATH
+
+        return self.__config_path
+
+    @config_path.setter
+    def config_path(self, config_path: str) -> None:
+        if not isinstance(config_path, str):
+            raise TypeError(
+                f"`config_path` attribute type {type(config_path)} is invalid, must be a <str>!"
+            )
+
+        config_path = config_path.strip()
+        if config_path == "":
+            raise ValueError("`config_path` attribute value is empty!")
+
+        if (
+            (not config_path.lower().endswith((".yml", ".yaml")))
+            and (not config_path.lower().endswith(".json"))
+            and (not config_path.lower().endswith(".toml"))
+        ):
+            raise ValueError(
+                f"`config_path` attribute value '{config_path}' is invalid, "
+                f"file must be '.yml', '.yaml', '.json' or '.toml' format!"
+            )
+
+        self.__config_path = config_path
+
+    # config_path
+    # ATTRIBUTES
+
+
+__all__ = [
+    "LoggerLoader",
+]

beans_logging/_intercept.py

@@ -0,0 +1,106 @@
+import inspect
+import logging
+from logging import LogRecord, Handler
+
+from loguru import logger
+from pydantic import validate_call
+
+from .config import LoggerConfigPM
+
+
+class InterceptHandler(Handler):
+    """A handler class that intercepts logs from standard logging and redirects them to loguru logger.
+
+    Inherits:
+        Handler: Handler class from standard logging.
+
+    Overrides:
+        emit(): Handle intercepted log record.
+    """
+
+    def emit(self, record: LogRecord) -> None:
+        """Handle intercepted log record.
+
+        Args:
+            record (LogRecord, required): Log needs to be handled.
+        """
+
+        # Get corresponding Loguru level if it exists.
+        try:
+            _level: str | int = logger.level(record.levelname).name
+        except ValueError:
+            _level = record.levelno
+
+        # Find caller from where originated the logged message.
+        _frame, _depth = inspect.currentframe(), 0
+        while _frame and (_depth == 0 or _frame.f_code.co_filename == logging.__file__):
+            _frame = _frame.f_back
+            _depth += 1
+
+        logger.opt(depth=_depth, exception=record.exc_info).log(
+            _level, record.getMessage()
+        )
+
+        return
+
+
+@validate_call
+def init_intercepter(config: LoggerConfigPM) -> None:
+    """Initialize log interceptor based on provided config.
+
+    Args:
+        config (LoggerConfigPM, required): Main logger config model to use intercepter settings.
+    """
+
+    _intercept_handler = InterceptHandler()
+
+    # Intercepting all logs from standard (root logger) logging:
+    logging.basicConfig(handlers=[_intercept_handler], level=0, force=True)
+
+    _intercepted_modules = set()
+    _muted_modules = set()
+
+    if config.intercept.enabled:
+        for _module_name in list(logging.root.manager.loggerDict.keys()):
+            if config.intercept.only_base:
+                _module_name = _module_name.split(".")[0]
+
+            if (_module_name not in _intercepted_modules) and (
+                _module_name not in config.intercept.ignore_modules
+            ):
+                _logger = logging.getLogger(_module_name)
+                _logger.handlers = [_intercept_handler]
+                _logger.propagate = False
+                _intercepted_modules.add(_module_name)
+
+    for _include_module_name in config.intercept.include_modules:
+        _logger = logging.getLogger(_include_module_name)
+        _logger.handlers = [_intercept_handler]
+        # _logger.propagate = False
+
+        if _include_module_name not in _intercepted_modules:
+            _intercepted_modules.add(_include_module_name)
+
+    for _mute_module_name in config.intercept.mute_modules:
+        _logger = logging.getLogger(_mute_module_name)
+        _logger.handlers = []
+        _logger.propagate = False
+        _logger.disabled = True
+
+        if _mute_module_name in _intercepted_modules:
+            _intercepted_modules.remove(_mute_module_name)
+
+        if _mute_module_name not in _muted_modules:
+            _muted_modules.add(_mute_module_name)
+
+    logger.trace(
+        f"Intercepted modules: {list(_intercepted_modules)}; Muted modules: {list(_muted_modules)};"
+    )
+
+    return
+
+
+__all__ = [
+    "InterceptHandler",
+    "init_intercepter",
+]

beans_logging/auto.py

@@ -1,24 +1,15 @@
 # flake8: noqa
 
-import os
-
 from . import *
 
-logger_loader: LoggerLoader | None = None
-_DISABLE_DEFAULT_LOGGER = (
-    str(os.getenv("BEANS_LOGGING_DISABLE_DEFAULT")).strip().lower()
-)
-if (_DISABLE_DEFAULT_LOGGER != "true") and (_DISABLE_DEFAULT_LOGGER != "1"):
-    logger_loader: LoggerLoader = LoggerLoader()
-    logger: Logger = logger_loader.load()
+logger_loader: LoggerLoader = LoggerLoader(auto_load=True)
 
 
 __all__ = [
+    "__version__",
+    "LoggerConfigPM",
     "Logger",
     "logger",
     "LoggerLoader",
     "logger_loader",
-    "LoggerConfigPM",
-    "WarnEnum",
-    "__version__",
 ]