beans-logging-fastapi 1.1.1__py3-none-any.whl → 3.0.0__py3-none-any.whl

beans_logging_fastapi/__init__.py

@@ -1,31 +1,13 @@
-# -*- coding: utf-8 -*-
+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,3 +1 @@
-# -*- coding: utf-8 -*-
-
-__version__ = "1.1.1"
+__version__ = "3.0.0"

beans_logging_fastapi/{_async_log.py → _async.py}

@@ -1,42 +1,46 @@
-# -*- coding: utf-8 -*-
+from typing import Any
 
-from typing import Dict, Any
-
-from pydantic import validate_arguments
+from pydantic import validate_call
 from fastapi import Request
 from fastapi.concurrency import run_in_threadpool
 
 from beans_logging import logger, Logger
 
 
-@validate_arguments(config=dict(arbitrary_types_allowed=True))
+@validate_call(config={"arbitrary_types_allowed": True})
 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>',
-):
+    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 '<n><w>[{request_id}]</w></n> {client_host} {user_id} "<u>{method} {url_path}</u> HTTP/{http_version}" <n>{status_code}</n>'.
+        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>'.
     """
 
-    _http_info: Dict[str, Any] = {"request_id": request.state.request_id}
+    _http_info: dict[str, Any] = {"request_id": request.state.request_id}
     if hasattr(request.state, "http_info") and isinstance(
         request.state.http_info, dict
     ):
-        _http_info: Dict[str, Any] = request.state.http_info
+        _http_info: dict[str, Any] = request.state.http_info
     _http_info["status_code"] = status_code
 
-    _msg = msg_format.format(**_http_info)
+    _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
 
 
-@validate_arguments
-async def async_log_trace(message: str):
+@validate_call
+async def async_log_trace(message: str) -> None:
     """Log trace message.
 
     Args:
@@ -44,10 +48,11 @@ async def async_log_trace(message: str):
     """
 
     await run_in_threadpool(logger.trace, message)
+    return
 
 
-@validate_arguments
-async def async_log_debug(message: str):
+@validate_call
+async def async_log_debug(message: str) -> None:
     """Log debug message.
 
     Args:
@@ -55,10 +60,11 @@ async def async_log_debug(message: str):
     """
 
     await run_in_threadpool(logger.debug, message)
+    return
 
 
-@validate_arguments
-async def async_log_info(message: str):
+@validate_call
+async def async_log_info(message: str) -> None:
     """Log info message.
 
     Args:
@@ -66,10 +72,11 @@ async def async_log_info(message: str):
     """
 
     await run_in_threadpool(logger.info, message)
+    return
 
 
-@validate_arguments
-async def async_log_success(message: str):
+@validate_call
+async def async_log_success(message: str) -> None:
     """Log success message.
 
     Args:
@@ -77,10 +84,11 @@ async def async_log_success(message: str):
     """
 
     await run_in_threadpool(logger.success, message)
+    return
 
 
-@validate_arguments
-async def async_log_warning(message: str):
+@validate_call
+async def async_log_warning(message: str) -> None:
     """Log warning message.
 
     Args:
@@ -88,10 +96,11 @@ async def async_log_warning(message: str):
     """
 
     await run_in_threadpool(logger.warning, message)
+    return
 
 
-@validate_arguments
-async def async_log_error(message: str):
+@validate_call
+async def async_log_error(message: str) -> None:
     """Log error message.
 
     Args:
@@ -99,10 +108,11 @@ async def async_log_error(message: str):
     """
 
     await run_in_threadpool(logger.error, message)
+    return
 
 
-@validate_arguments
-async def async_log_critical(message: str):
+@validate_call
+async def async_log_critical(message: str) -> None:
     """Log critical message.
 
     Args:
@@ -110,10 +120,11 @@ async def async_log_critical(message: str):
     """
 
     await run_in_threadpool(logger.critical, message)
+    return
 
 
-@validate_arguments
-async def async_log_level(level: str, message: str):
+@validate_call
+async def async_log_level(level: str, message: str) -> None:
     """Log level message.
 
     Args:
@@ -122,6 +133,7 @@ async def async_log_level(level: str, message: str):
     """
 
     await run_in_threadpool(logger.log, level, message)
+    return
 
 
 __all__ = [

beans_logging_fastapi/_core.py

@@ -0,0 +1,90 @@
+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_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 use_http_filter
+from .formats import http_file_format, http_file_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_format_str=config.http.std.debug_format_str,
+        format_str=config.http.std.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_FILE_HANDLER_NAME) or (
+            _name == HTTP_ERR_FILE_HANDLER_NAME
+        ):
+            _handler.filter_ = use_http_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_ = use_http_filter
+            _handler.format_ = http_file_json_format
+
+    logger: Logger = logger_loader.load()
+    return logger
+
+
+__all__ = [
+    "add_logger",
+]

beans_logging_fastapi/config.py

@@ -0,0 +1,168 @@
+from typing import Any
+
+import potato_util as utils
+from pydantic import Field, field_validator
+
+from beans_logging.constants import LogHandlerTypeEnum
+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_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.startswith("default"):
+            _handler.enabled = True
+
+    _http_handlers: dict[str, LogHandlerPM] = {
+        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):
+    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_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_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,12 @@
+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"
+
+
+__all__ = [
+    "HTTP_ACCESS_FILE_HANDLER_NAME",
+    "HTTP_ERR_FILE_HANDLER_NAME",
+    "HTTP_ACCESS_JSON_HANDLER_NAME",
+    "HTTP_ERR_JSON_HANDLER_NAME",
+]

beans_logging_fastapi/{_filters.py → filters.py}

@@ -1,13 +1,16 @@
-# -*- coding: utf-8 -*-
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from loguru import Record
 
 from beans_logging.filters import use_all_filter
 
 
-def use_http_filter(record: dict) -> bool:
+def use_http_filter(record: "Record") -> bool:
     """Filter message only for http access log handler by checking 'http_info' key in extra.
 
     Args:
-        record (dict): Log record as dictionary.
+        record (Record, required): Log record as dictionary.
 
     Returns:
         bool: True if record has 'http_info' key in extra, False otherwise.
@@ -22,4 +25,6 @@ def use_http_filter(record: dict) -> bool:
     return True
 
 
-__all__ = ["use_http_filter"]
+__all__ = [
+    "use_http_filter",
+]

beans_logging_fastapi/formats.py

@@ -0,0 +1,95 @@
+import json
+from typing import Any
+from zoneinfo import ZoneInfo
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from loguru import Record
+
+
+def http_file_format(
+    record: "Record",
+    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:
+    """Http access log file format.
+
+    Args:
+        record     (Record, required): Log record as dictionary.
+        format_str (str   , optional): Log message format.
+        tz         (str   , optional): Timezone for datetime field. Defaults to 'localtime'.
+
+    Returns:
+        str: Format for http access log record.
+    """
+
+    if "http_info" not in record["extra"]:
+        return ""
+
+    if "http_message" in record["extra"]:
+        del record["extra"]["http_message"]
+
+    _http_info: dict[str, Any] = record["extra"]["http_info"]
+    if "datetime" not in _http_info:
+        _dt = record["time"]
+        if tz != "localtime":
+            if not _dt.tzinfo:
+                _dt = _dt.replace(tzinfo=ZoneInfo("UTC"))
+
+            _dt = _dt.astimezone(ZoneInfo(tz))
+
+        _http_info["datetime"] = _dt.isoformat(timespec="milliseconds")
+
+    if "content_length" not in _http_info:
+        _http_info["content_length"] = 0
+
+    if "h_referer" not in _http_info:
+        _http_info["h_referer"] = "-"
+
+    if "h_user_agent" not in _http_info:
+        _http_info["h_user_agent"] = "-"
+
+    if "response_time" not in _http_info:
+        _http_info["response_time"] = 0
+
+    record["extra"]["http_info"] = _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:
+    """Http access json log file format.
+
+    Args:
+        record (Record, required): Log record as dictionary.
+
+    Returns:
+        str: Format for http access json log record.
+    """
+
+    if "http_info" not in record["extra"]:
+        return ""
+
+    if "datetime" not in record["extra"]["http_info"]:
+        record["extra"]["http_info"]["datetime"] = record["time"].isoformat(
+            timespec="milliseconds"
+        )
+
+    if "http_serialized" in record["extra"]:
+        del record["extra"]["http_serialized"]
+
+    _http_info = record["extra"]["http_info"]
+    record["extra"]["http_serialized"] = json.dumps(_http_info)
+
+    return "{extra[http_serialized]}\n"
+
+
+__all__ = [
+    "http_file_format",
+    "http_file_json_format",
+]