Logging Configurator

class LoggingConfigurator:
    """To create a default logger"""

    def __init__(
        self,
        config: dict[str, Any] | None = None,
        fmt: str = FORMAT,
        handlers: list[dict[str, Any]] | None = None,
        level: str | int = logging.INFO,
        stream: str = "stdout",
        logger_name: str = "root",
    ) -> None:
        """Initialize the LoggingConfigurator.

        Parameters
        ----------
        config
            The logging configuration dictionary, by default None
        fmt
            The logging format, by default FORMAT
        handlers
            The list of logging handlers, by default None
        level
            The logging level, by default logging.INFO
        stream
            The logging stream, by default "stdout"
        logger_name
            The name of the logger, by default 'root'
        """
        if not fmt:
            fmt = FORMAT
        if not stream:
            stream = "stdout"
        if not level:
            level = logging.INFO
        if not handlers:
            handlers = []

        logging_level = (
            getattr(logging, level.upper())
            if isinstance(level, str)
            else level
        )

        default_config: dict[str, Any] = {
            "version": 1,
            "formatters": {"default": {"format": fmt}},
            "handlers": {
                "console": {
                    "class": "logging.StreamHandler",
                    "level": logging_level,
                    "formatter": "default",
                    "stream": f"ext://sys.{stream}",
                }
            },
            logger_name: {"level": level, "handlers": ["console"]},
        }

        for ix, handler in enumerate(handlers):
            handler_name = f"handler_{ix}"
            handler_obj = LoggingHandlerFactory.parse(handler)
            default_config["handlers"].update({handler_name: handler_obj})

            default_config[logger_name]["handlers"].append(handler_name)

            handler_level = getattr(logging, handler_obj["level"])
            if handler_level < logging_level:
                logging_level = handler_level
                default_config[logger_name]["level"] = logging_level

        if config:
            dictConfig(config)
        else:
            dictConfig(default_config)

class GunicornLogger(glogging.Logger):
    """This class overrides the default gunicorn logger."""

    def setup(self, cfg: Any):
        """Set the FORMAT on the gunicorn logging handler.

        Parameters
        ----------
        cfg
            The gunicorn glogging configuration
        """
        super().setup(cfg)  # type: ignore

        self._set_handler(  # type: ignore
            log=self.error_log,
            output=cfg.errorlog,
            fmt=logging.Formatter(fmt=FORMAT),
        )