beans-logging-fastapi 2.0.0__py3-none-any.whl → 4.0.0__py3-none-any.whl

beans_logging_fastapi/__init__.py

@@ -1,31 +1,13 @@
-# flake8: noqa
+from beans_logging import logger
 
-from ._filters import use_http_filter
-from ._formats import http_file_format, http_file_json_format
-from ._handlers import add_http_file_handler, add_http_file_json_handler
-from ._middlewares import RequestHTTPInfoMiddleware, ResponseHTTPInfoMiddleware
-from ._base import HttpAccessLogMiddleware
-from ._async_log import *
 from .__version__ import __version__
+from .config import LoggerConfigPM
+from ._core import add_logger
 
 
 __all__ = [
-    "use_http_filter",
-    "http_file_format",
-    "http_file_json_format",
-    "add_http_file_handler",
-    "add_http_file_json_handler",
-    "RequestHTTPInfoMiddleware",
-    "ResponseHTTPInfoMiddleware",
-    "HttpAccessLogMiddleware",
-    "async_log_http_error",
-    "async_log_trace",
-    "async_log_debug",
-    "async_log_info",
-    "async_log_success",
-    "async_log_warning",
-    "async_log_error",
-    "async_log_critical",
-    "async_log_level",
     "__version__",
+    "logger",
+    "add_logger",
+    "LoggerConfigPM",
 ]

beans_logging_fastapi/__version__.py

@@ -1 +1 @@
-__version__ = "2.0.0"
+__version__ = "4.0.0"

beans_logging_fastapi/{_async_log.py → _async.py}

@@ -11,17 +11,17 @@ from beans_logging import logger, Logger
 async def async_log_http_error(
     request: Request,
     status_code: int,
-    msg_format: str = (
-        '<n><w>[{request_id}]</w></n> {client_host} {user_id} "<u>{method} {url_path}</u> '
-        'HTTP/{http_version}" <n>{status_code}</n>'
+    msg_format_str: str = (
+        '<n><w>[{request_id}]</w></n> {client_host} {user_id} "<u>{method} {url_path}</u>'
+        ' HTTP/{http_version}" <n>{status_code}</n>'
     ),
 ) -> None:
     """Log HTTP error for unhandled Exception.
 
     Args:
-        request     (Request, required): Request instance.
-        status_code (int    , required): HTTP status code.
-        msg_format  (str    , optional): Message format. Defaults to
+        request        (Request, required): Request instance.
+        status_code    (int    , required): HTTP status code.
+        msg_format_str (str    , optional): Message format. Defaults to
             '<n><w>[{request_id}]</w></n> {client_host} {user_id} "<u>{method} {url_path}</u> HTTP/{http_version}"
                 <n>{status_code}</n>'.
     """
@@ -33,7 +33,7 @@ async def async_log_http_error(
         _http_info: dict[str, Any] = request.state.http_info
     _http_info["status_code"] = status_code
 
-    _msg = msg_format.format(**_http_info)
+    _msg = msg_format_str.format(**_http_info)
     _logger: Logger = logger.opt(colors=True, record=True).bind(http_info=_http_info)
     await run_in_threadpool(_logger.error, _msg)
     return

beans_logging_fastapi/_core.py

@@ -0,0 +1,93 @@
+from typing import TYPE_CHECKING
+
+from pydantic import validate_call
+from fastapi import FastAPI
+
+if TYPE_CHECKING:
+    from loguru import Logger
+else:
+    from loguru._logger import Logger
+
+from beans_logging import LoggerLoader
+
+from .constants import (
+    HTTP_ACCESS_STD_HANDLER_NAME,
+    HTTP_ACCESS_FILE_HANDLER_NAME,
+    HTTP_ERR_FILE_HANDLER_NAME,
+    HTTP_ACCESS_JSON_HANDLER_NAME,
+    HTTP_ERR_JSON_HANDLER_NAME,
+)
+from .config import LoggerConfigPM
+from .filters import http_std_filter, http_all_file_filter
+from .formats import http_file_format, http_json_format
+from .middlewares import (
+    HttpAccessLogMiddleware,
+    RequestHTTPInfoMiddleware,
+    ResponseHTTPInfoMiddleware,
+)
+
+
+@validate_call(config={"arbitrary_types_allowed": True})
+def add_logger(
+    app: FastAPI,
+    config: LoggerConfigPM,
+    has_proxy_headers: bool | None = None,
+    has_cf_headers: bool | None = None,
+) -> "Logger":
+    """Add and initialize logger middlewares and handlers to FastAPI application.
+
+    Args:
+        app               (FastAPI       , required): FastAPI application instance.
+        config            (LoggerConfigPM, required): Logger configuration model.
+        has_proxy_headers (bool | None   , optional): Whether to use proxy headers. Defaults to None.
+        has_cf_headers    (bool | None   , optional): Whether to use Cloudflare headers. Defaults to None.
+
+    Returns:
+        Logger: Initialized Logger instance.
+    """
+
+    logger_loader = LoggerLoader(config=config)
+
+    if has_proxy_headers is None:
+        has_proxy_headers = config.http.headers.has_proxy
+
+    if has_cf_headers is None:
+        has_cf_headers = config.http.headers.has_cf
+
+    app.add_middleware(ResponseHTTPInfoMiddleware)
+    app.add_middleware(
+        HttpAccessLogMiddleware,
+        debug_msg_format_str=config.http.std.debug_msg_format_str,
+        msg_format_str=config.http.std.msg_format_str,
+    )
+    app.add_middleware(
+        RequestHTTPInfoMiddleware,
+        has_proxy_headers=has_proxy_headers,
+        has_cf_headers=has_cf_headers,
+    )
+
+    for _name, _handler in logger_loader.config.handlers.items():
+        if _name == HTTP_ACCESS_STD_HANDLER_NAME:
+            _handler.filter_ = http_std_filter
+        elif (_name == HTTP_ACCESS_FILE_HANDLER_NAME) or (
+            _name == HTTP_ERR_FILE_HANDLER_NAME
+        ):
+            _handler.filter_ = http_all_file_filter
+            _handler.format_ = lambda record: http_file_format(
+                record=record,
+                format_str=config.http.file.format_str,
+                tz=config.http.file.tz,
+            )
+        elif (_name == HTTP_ACCESS_JSON_HANDLER_NAME) or (
+            _name == HTTP_ERR_JSON_HANDLER_NAME
+        ):
+            _handler.filter_ = http_all_file_filter
+            _handler.format_ = http_json_format
+
+    logger: Logger = logger_loader.load()
+    return logger
+
+
+__all__ = [
+    "add_logger",
+]

beans_logging_fastapi/config.py

@@ -0,0 +1,177 @@
+from typing import Any
+
+import potato_util as utils
+from pydantic import Field, field_validator
+
+from beans_logging.constants import LogHandlerTypeEnum, DEFAULT_HANDLER_NAMES
+from beans_logging.schemas import LogHandlerPM
+from beans_logging.config import (
+    get_default_handlers as get_base_handlers,
+    ExtraBaseModel,
+    InterceptConfigPM,
+    LoggerConfigPM as BaseLoggerConfigPM,
+)
+
+from .constants import (
+    HTTP_ACCESS_STD_HANDLER_NAME,
+    HTTP_ACCESS_FILE_HANDLER_NAME,
+    HTTP_ERR_FILE_HANDLER_NAME,
+    HTTP_ACCESS_JSON_HANDLER_NAME,
+    HTTP_ERR_JSON_HANDLER_NAME,
+)
+
+
+def get_default_handlers() -> dict[str, LogHandlerPM]:
+    """Get fastapi default log handlers.
+
+    Returns:
+        dict[str, LogHandlerPM]: Default handlers as dictionary.
+    """
+
+    _base_handlers = get_base_handlers()
+    for _name, _handler in _base_handlers.items():
+        if _name in DEFAULT_HANDLER_NAMES:
+            _handler.enabled = True
+
+    _http_handlers: dict[str, LogHandlerPM] = {
+        HTTP_ACCESS_STD_HANDLER_NAME: LogHandlerPM(
+            h_type=LogHandlerTypeEnum.STD,
+            format_=(
+                "[<c>{time:YYYY-MM-DD HH:mm:ss.SSS Z}</c> | <level>{extra[level_short]:<5}</level> ]:"
+                " <level>{message}</level>"
+            ),
+            colorize=True,
+        ),
+        HTTP_ACCESS_FILE_HANDLER_NAME: LogHandlerPM(
+            h_type=LogHandlerTypeEnum.FILE,
+            sink="http/{app_name}.http-access.log",
+        ),
+        HTTP_ERR_FILE_HANDLER_NAME: LogHandlerPM(
+            h_type=LogHandlerTypeEnum.FILE,
+            sink="http/{app_name}.http-err.log",
+            error=True,
+        ),
+        HTTP_ACCESS_JSON_HANDLER_NAME: LogHandlerPM(
+            h_type=LogHandlerTypeEnum.FILE,
+            sink="http.json/{app_name}.http-access.json.log",
+        ),
+        HTTP_ERR_JSON_HANDLER_NAME: LogHandlerPM(
+            h_type=LogHandlerTypeEnum.FILE,
+            sink="http.json/{app_name}.http-err.json.log",
+            error=True,
+        ),
+    }
+
+    _default_handlers = {**_base_handlers, **_http_handlers}
+    return _default_handlers
+
+
+def get_default_intercept() -> InterceptConfigPM:
+    _default_intercept = InterceptConfigPM(mute_modules=["uvicorn.access"])
+    return _default_intercept
+
+
+class StdConfigPM(ExtraBaseModel):
+    msg_format_str: str = Field(
+        default=(
+            '<n><w>[{request_id}]</w></n> {client_host} {user_id} "<u>{method} {url_path}</u> HTTP/{http_version}"'
+            " {status_code} {content_length}B {response_time}ms"
+        ),
+        min_length=8,
+        max_length=512,
+    )
+    err_msg_format_str: str = Field(
+        default=(
+            '<n><w>[{request_id}]</w></n> {client_host} {user_id} "<u>{method} {url_path}</u> HTTP/{http_version}"'
+            " <n>{status_code}</n>"
+        ),
+        min_length=8,
+        max_length=512,
+    )
+    debug_msg_format_str: str = Field(
+        default='<n>[{request_id}]</n> {client_host} {user_id} "<u>{method} {url_path}</u> HTTP/{http_version}"',
+        min_length=8,
+        max_length=512,
+    )
+
+
+class FileConfigPM(ExtraBaseModel):
+    format_str: str = Field(
+        default=(
+            '{client_host} {request_id} {user_id} [{datetime}] "{method} {url_path} HTTP/{http_version}"'
+            ' {status_code} {content_length} "{h_referer}" "{h_user_agent}" {response_time}'
+        ),
+        min_length=8,
+        max_length=512,
+    )
+    tz: str = Field(default="localtime", min_length=2, max_length=64)
+
+
+class HeadersConfigPM(ExtraBaseModel):
+    has_proxy: bool = Field(default=False)
+    has_cf: bool = Field(default=False)
+
+
+class HttpConfigPM(ExtraBaseModel):
+    std: StdConfigPM = Field(default_factory=StdConfigPM)
+    file: FileConfigPM = Field(default_factory=FileConfigPM)
+    headers: HeadersConfigPM = Field(default_factory=HeadersConfigPM)
+
+
+class LoggerConfigPM(BaseLoggerConfigPM):
+    http: HttpConfigPM = Field(default_factory=HttpConfigPM)
+    intercept: InterceptConfigPM = Field(default_factory=get_default_intercept)
+    handlers: dict[str, LogHandlerPM] = Field(default_factory=get_default_handlers)
+
+    @field_validator("handlers", mode="before")
+    @classmethod
+    def _check_handlers(cls, val: Any) -> dict[str, LogHandlerPM]:
+
+        _default_handlers = get_default_handlers()
+
+        if not val:
+            val = _default_handlers
+            return val
+
+        if not isinstance(val, dict):
+            raise TypeError(
+                f"'handlers' attribute type {type(val).__name__} is invalid, must be a dict of <LogHandlerPM> or dict!"
+            )
+
+        for _key, _handler in val.items():
+            if not isinstance(_handler, (LogHandlerPM, dict)):
+                raise TypeError(
+                    f"'handlers' attribute's '{_key}' key -> value type {type(_handler).__name__} is invalid, must be "
+                    f"<LogHandlerPM> or dict!"
+                )
+
+            if isinstance(_handler, LogHandlerPM):
+                val[_key] = _handler.model_dump(
+                    by_alias=True, exclude_unset=True, exclude_none=True
+                )
+
+        _default_dict = {
+            _key: _handler.model_dump(
+                by_alias=True, exclude_unset=True, exclude_none=True
+            )
+            for _key, _handler in _default_handlers.items()
+        }
+
+        if _default_dict != val:
+            val = utils.deep_merge(_default_dict, val)
+
+        for _key, _handler in val.items():
+            val[_key] = LogHandlerPM(**_handler)
+
+        return val
+
+
+__all__ = [
+    "LoggerConfigPM",
+    "HttpConfigPM",
+    "StdConfigPM",
+    "FileConfigPM",
+    "HeadersConfigPM",
+    "get_default_intercept",
+    "get_default_handlers",
+]

beans_logging_fastapi/constants.py

@@ -0,0 +1,23 @@
+HTTP_ACCESS_STD_HANDLER_NAME = "http_access_std_handler"
+HTTP_ACCESS_FILE_HANDLER_NAME = "http_access_file_handler"
+HTTP_ERR_FILE_HANDLER_NAME = "http_err_file_handler"
+HTTP_ACCESS_JSON_HANDLER_NAME = "http_access_json_handler"
+HTTP_ERR_JSON_HANDLER_NAME = "http_err_json_handler"
+
+HTTP_HANDLER_NAMES = [
+    HTTP_ACCESS_STD_HANDLER_NAME,
+    HTTP_ACCESS_FILE_HANDLER_NAME,
+    HTTP_ERR_FILE_HANDLER_NAME,
+    HTTP_ACCESS_JSON_HANDLER_NAME,
+    HTTP_ERR_JSON_HANDLER_NAME,
+]
+
+
+__all__ = [
+    "HTTP_ACCESS_STD_HANDLER_NAME",
+    "HTTP_ACCESS_FILE_HANDLER_NAME",
+    "HTTP_ERR_FILE_HANDLER_NAME",
+    "HTTP_ACCESS_JSON_HANDLER_NAME",
+    "HTTP_ERR_JSON_HANDLER_NAME",
+    "HTTP_HANDLER_NAMES",
+]

beans_logging_fastapi/filters.py

@@ -0,0 +1,72 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from loguru import Record
+
+from beans_logging.filters import all_handlers_filter
+
+from .constants import HTTP_ACCESS_STD_HANDLER_NAME
+
+
+def http_filter(record: "Record") -> bool:
+    """Filter message only for http access log handler by checking 'http_info' key in extra.
+
+    Args:
+        record (Record, required): Log record as dictionary.
+
+    Returns:
+        bool: True if record has 'http_info' key in extra, False otherwise.
+    """
+
+    if not all_handlers_filter(record):
+        return False
+
+    if "http_info" not in record["extra"]:
+        return False
+
+    return True
+
+
+def http_std_filter(record: "Record") -> bool:
+    """Filter message only for http std log handler.
+
+    Args:
+        record (Record, required): Log record as dictionary.
+
+    Returns:
+        bool: True if record does not have 'disable_{HTTP_ACCESS_STD_HANDLER_NAME}' key in extra, False otherwise.
+    """
+
+    if not http_filter(record):
+        return False
+
+    if record["extra"].get(f"disable_{HTTP_ACCESS_STD_HANDLER_NAME}", False):
+        return False
+
+    return True
+
+
+def http_all_file_filter(record: "Record") -> bool:
+    """Filter message only for http file log handler.
+
+    Args:
+        record (Record, required): Log record as dictionary.
+
+    Returns:
+        bool: True if record does not have 'disable_http_all_file_handlers' key in extra, False otherwise.
+    """
+
+    if not http_filter(record):
+        return False
+
+    if record["extra"].get("disable_http_all_file_handlers", False):
+        return False
+
+    return True
+
+
+__all__ = [
+    "http_filter",
+    "http_std_filter",
+    "http_all_file_filter",
+]

beans_logging_fastapi/{_formats.py → formats.py}

@@ -9,9 +9,9 @@ if TYPE_CHECKING:
 
 def http_file_format(
     record: "Record",
-    msg_format: str = (
-        '{client_host} {request_id} {user_id} [{datetime}] "{method} {url_path} HTTP/{http_version}" '
-        '{status_code} {content_length} "{h_referer}" "{h_user_agent}" {response_time}'
+    format_str: str = (
+        '{client_host} {request_id} {user_id} [{datetime}] "{method} {url_path} HTTP/{http_version}"'
+        ' {status_code} {content_length} "{h_referer}" "{h_user_agent}" {response_time}'
     ),
     tz: str = "localtime",
 ) -> str:
@@ -19,7 +19,7 @@ def http_file_format(
 
     Args:
         record     (Record, required): Log record as dictionary.
-        msg_format (str   , optional): Log message format.
+        format_str (str   , optional): Log message format.
         tz         (str   , optional): Timezone for datetime field. Defaults to 'localtime'.
 
     Returns:
@@ -56,13 +56,13 @@ def http_file_format(
         _http_info["response_time"] = 0
 
     record["extra"]["http_info"] = _http_info
-    _msg = msg_format.format(**_http_info)
+    _msg = format_str.format(**_http_info)
 
     record["extra"]["http_message"] = _msg
     return "{extra[http_message]}\n"
 
 
-def http_file_json_format(record: "Record") -> str:
+def http_json_format(record: "Record") -> str:
     """Http access json log file format.
 
     Args:
@@ -91,5 +91,5 @@ def http_file_json_format(record: "Record") -> str:
 
 __all__ = [
     "http_file_format",
-    "http_file_json_format",
+    "http_json_format",
 ]

beans_logging_fastapi/{_middlewares.py → middlewares.py}

@@ -4,6 +4,7 @@ from typing import Any
 from collections.abc import Callable
 
 from fastapi import Request, Response
+from fastapi.concurrency import run_in_threadpool
 from starlette.middleware.base import BaseHTTPMiddleware
 
 from beans_logging import logger
@@ -227,7 +228,115 @@ class ResponseHTTPInfoMiddleware(BaseHTTPMiddleware):
         return response
 
 
+class HttpAccessLogMiddleware(BaseHTTPMiddleware):
+    """Http access log middleware for FastAPI.
+
+    Inherits:
+        BaseHTTPMiddleware: Base HTTP middleware class from starlette.
+
+    Attributes:
+        _DEBUG_MSG_FORMAT_STR (str ): Default http access log debug message format. Defaults to
+            '<n>[{request_id}]</n> {client_host} {user_id} "<u>{method} {url_path}</u> HTTP/{http_version}"'.
+        _MSG_FORMAT_STR       (str ): Default http access log message format. Defaults to
+            '<n><w>[{request_id}]</w></n> {client_host} {user_id} "<u>{method} {url_path}</u> HTTP/{http_version}"
+                {status_code} {content_length}B {response_time}ms'.
+
+        debug_msg_format_str  (str ): Http access log debug message format.
+                                        Defaults to `HttpAccessLogMiddleware._DEBUG_MSG_FORMAT_STR`.
+        msg_format_str        (str ): Http access log message format.
+                                        Defaults to `HttpAccessLogMiddleware._MSG_FORMAT_STR`.
+        use_debug_log         (bool): If True, use debug log to log http access log. Defaults to True.
+    """
+
+    _DEBUG_MSG_FORMAT_STR = (
+        '<n>[{request_id}]</n> {client_host} {user_id} "<u>{method} {url_path}</u>'
+        ' HTTP/{http_version}"'
+    )
+    _MSG_FORMAT_STR = (
+        '<n><w>[{request_id}]</w></n> {client_host} {user_id} "<u>{method} {url_path}</u> HTTP/{http_version}"'
+        " {status_code} {content_length}B {response_time}ms"
+    )
+
+    def __init__(
+        self,
+        app,
+        debug_msg_format_str: str = _DEBUG_MSG_FORMAT_STR,
+        msg_format_str: str = _MSG_FORMAT_STR,
+        use_debug_log: bool = True,
+    ):
+        super().__init__(app)
+        self.debug_msg_format_str = debug_msg_format_str
+        self.msg_format_str = msg_format_str
+        self.use_debug_log = use_debug_log
+
+    async def dispatch(self, request: Request, call_next) -> Response:
+        _logger = logger.opt(colors=True, record=True).bind(
+            disable_all_std_handler=True
+        )
+
+        _http_info: dict[str, Any] = {}
+        if hasattr(request.state, "http_info") and isinstance(
+            request.state.http_info, dict
+        ):
+            _http_info: dict[str, Any] = request.state.http_info
+
+        # Debug log:
+        if self.use_debug_log:
+            _debug_msg = self.debug_msg_format_str.format(**_http_info)
+
+            # _logger.bind(
+            #     http_info=_http_info, disable_http_all_file_handlers=True
+            # ).debug(_debug_msg)
+            await run_in_threadpool(
+                _logger.bind(
+                    http_info=_http_info, disable_http_all_file_handlers=True
+                ).debug,
+                _debug_msg,
+            )
+        # Debug log
+
+        # Process request:
+        response: Response = await call_next(request)
+        # Response processed.
+
+        if hasattr(request.state, "http_info") and isinstance(
+            request.state.http_info, dict
+        ):
+            _http_info: dict[str, Any] = request.state.http_info
+
+        # Http access log:
+        _LEVEL = "INFO"
+        _msg_format_str = self.msg_format_str
+        if _http_info["status_code"] < 200:
+            _LEVEL = "DEBUG"
+            _msg_format_str = f'<d>{_msg_format_str.replace("{status_code}", "<n><b><k>{status_code}</k></b></n>")}</d>'
+        elif (200 <= _http_info["status_code"]) and (_http_info["status_code"] < 300):
+            _LEVEL = "SUCCESS"
+            _msg_format_str = f'<w>{_msg_format_str.replace("{status_code}", "<lvl>{status_code}</lvl>")}</w>'
+        elif (300 <= _http_info["status_code"]) and (_http_info["status_code"] < 400):
+            _LEVEL = "INFO"
+            _msg_format_str = f'<d>{_msg_format_str.replace("{status_code}", "<n><b><c>{status_code}</c></b></n>")}</d>'
+        elif (400 <= _http_info["status_code"]) and (_http_info["status_code"] < 500):
+            _LEVEL = "WARNING"
+            _msg_format_str = _msg_format_str.replace(
+                "{status_code}", "<r>{status_code}</r>"
+            )
+        elif 500 <= _http_info["status_code"]:
+            _LEVEL = "ERROR"
+            _msg_format_str = (
+                f'{_msg_format_str.replace("{status_code}", "<n>{status_code}</n>")}'
+            )
+
+        _msg = _msg_format_str.format(**_http_info)
+        # _logger.bind(http_info=_http_info).log(_LEVEL, _msg)
+        await run_in_threadpool(_logger.bind(http_info=_http_info).log, _LEVEL, _msg)
+        # Http access log
+
+        return response
+
+
 __all__ = [
     "RequestHTTPInfoMiddleware",
     "ResponseHTTPInfoMiddleware",
+    "HttpAccessLogMiddleware",
 ]