beans-logging-fastapi 2.0.0__py3-none-any.whl → 3.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__ = "3.0.0"

beans_logging_fastapi/{_async_log.py → _async.py}

@@ -11,7 +11,7 @@ from beans_logging import logger, Logger
 async def async_log_http_error(
     request: Request,
     status_code: int,
-    msg_format: str = (
+    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>'
     ),
@@ -21,7 +21,7 @@ async def async_log_http_error(
     Args:
         request     (Request, required): Request instance.
         status_code (int    , required): HTTP status code.
-        msg_format  (str    , optional): Message format. Defaults to
+        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 = 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,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/{_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,7 +56,7 @@ 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"

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,103 @@ class ResponseHTTPInfoMiddleware(BaseHTTPMiddleware):
         return response
 
 
+class HttpAccessLogMiddleware(BaseHTTPMiddleware):
+    """Http access log middleware for FastAPI.
+
+    Inherits:
+        BaseHTTPMiddleware: Base HTTP middleware class from starlette.
+
+    Attributes:
+        _DEBUG_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}"'.
+        _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_format_str  (str ): Http access log debug message format. Defaults to
+                                    `HttpAccessLogMiddleware._DEBUG_FORMAT_STR`.
+        format_str        (str ): Http access log message format. Defaults to `HttpAccessLogMiddleware._FORMAT_STR`.
+        use_debug_log     (bool): If True, use debug log to log http access log. Defaults to True.
+    """
+
+    _DEBUG_FORMAT_STR = '<n>[{request_id}]</n> {client_host} {user_id} "<u>{method} {url_path}</u> HTTP/{http_version}"'
+    _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_format_str: str = _DEBUG_FORMAT_STR,
+        format_str: str = _FORMAT_STR,
+        use_debug_log: bool = True,
+    ):
+        super().__init__(app)
+        self.debug_format_str = debug_format_str
+        self.format_str = 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)
+
+        _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_format_str.format(**_http_info)
+
+            # _logger.debug(_debug_msg)
+            await run_in_threadpool(
+                _logger.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"
+        _format_str = self.format_str
+        if _http_info["status_code"] < 200:
+            _LEVEL = "DEBUG"
+            _format_str = f'<d>{_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"
+            _format_str = f'<w>{_format_str.replace("{status_code}", "<lvl>{status_code}</lvl>")}</w>'
+        elif (300 <= _http_info["status_code"]) and (_http_info["status_code"] < 400):
+            _LEVEL = "INFO"
+            _format_str = f'<d>{_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"
+            _format_str = _format_str.replace("{status_code}", "<r>{status_code}</r>")
+        elif 500 <= _http_info["status_code"]:
+            _LEVEL = "ERROR"
+            _format_str = (
+                f'{_format_str.replace("{status_code}", "<n>{status_code}</n>")}'
+            )
+
+        _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",
 ]

{beans_logging_fastapi-2.0.0.dist-info → beans_logging_fastapi-3.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: beans_logging_fastapi
-Version: 2.0.0
+Version: 3.0.0
 Summary: This is a middleware for FastAPI HTTP access logs. It is based on 'beans-logging' package.
 Author-email: Batkhuu Byambajav <batkhuu10@gmail.com>
 Project-URL: Homepage, https://github.com/bybatkhuu/module-fastapi-logging
@@ -22,7 +22,7 @@ Requires-Python: <4.0,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: fastapi<1.0.0,>=0.99.1
-Requires-Dist: beans-logging<8.0.0,>=7.1.0
+Requires-Dist: beans-logging<9.0.0,>=8.0.2
 Provides-Extra: test
 Requires-Dist: pytest<10.0.0,>=8.0.2; extra == "test"
 Requires-Dist: pytest-cov<8.0.0,>=5.0.0; extra == "test"
@@ -55,6 +55,7 @@ Requires-Dist: mkdocstrings[python]<2.0.0,>=0.24.3; extra == "dev"
 Requires-Dist: mike<3.0.0,>=2.1.3; extra == "dev"
 Requires-Dist: pyright<2.0.0,>=1.1.392; extra == "dev"
 Requires-Dist: pre-commit<5.0.0,>=4.0.1; extra == "dev"
+Requires-Dist: uvicorn[standard]<1.0.0,>=0.23.0; extra == "dev"
 Dynamic: license-file
 
 # FastAPI Logging (beans-logging-fastapi)
@@ -63,12 +64,15 @@ Dynamic: license-file
 [![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/bybatkhuu/module-fastapi-logging/2.build-publish.yml?logo=GitHub)](https://github.com/bybatkhuu/module-fastapi-logging/actions/workflows/2.build-publish.yml)
 [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/bybatkhuu/module-fastapi-logging?logo=GitHub&color=blue)](https://github.com/bybatkhuu/module-fastapi-logging/releases)
 
-This is a middleware for FastAPI HTTP access logs. It is based on **'beans-logging'** package.
+This is a HTTP access logging module for **FastAPI** based on **'beans-logging'** package.
 
 ## ✨ Features
 
 - **Logger** based on **'beans-logging'** package
 - **FastAPI** HTTP access logging **middleware**
+- HTTP access log as structured JSON format
+- Predefined **configuration** for HTTP access logs
+- Easy to **install** and **use**
 
 ---
 
@@ -160,28 +164,35 @@ To use `beans_logging_fastapi`:
 ```yaml
 logger:
   app_name: "fastapi-app"
+  default:
+    level:
+      base: TRACE
+  http:
+    std:
+      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'
+      err_format_str: '<n><w>[{request_id}]</w></n> {client_host} {user_id} "<u>{method} {url_path}</u> HTTP/{http_version}" <n>{status_code}</n>'
+      debug_format_str: '<n>[{request_id}]</n> {client_host} {user_id} "<u>{method} {url_path}</u> HTTP/{http_version}"'
+    file:
+      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}'
+      tz: "localtime"
+    headers:
+      has_proxy: false
+      has_cf: false
   intercept:
     mute_modules: ["uvicorn.access"]
   handlers:
-    default.all.file_handler:
+    http.access.file_handler:
       enabled: true
-    default.err.file_handler:
+      sink: "http/{app_name}.http-access.log"
+    http.err.file_handler:
       enabled: true
-    default.all.json_handler:
+      sink: "http/{app_name}.http-err.log"
+    http.access.json_handler:
       enabled: true
-    default.err.json_handler:
+      sink: "http.json/{app_name}.http-access.json.log"
+    http.err.json_handler:
       enabled: true
-  extra:
-    http_std_debug_format: '<n>[{request_id}]</n> {client_host} {user_id} "<u>{method} {url_path}</u> HTTP/{http_version}"'
-    http_std_msg_format: '<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'
-    http_file_enabled: true
-    http_file_format: '{client_host} {request_id} {user_id} [{datetime}] "{method} {url_path} HTTP/{http_version}" {status_code} {content_length} "{h_referer}" "{h_user_agent}" {response_time}'
-    http_file_tz: "localtime"
-    http_log_path: "http/{app_name}.http.access.log"
-    http_err_path: "http/{app_name}.http.err.log"
-    http_json_enabled: true
-    http_json_path: "http.json/{app_name}.http.json.access.log"
-    http_json_err_path: "http.json/{app_name}.http.json.err.log"
+      sink: "http.json/{app_name}.http-err.json.log"
 ```
 
 [**`.env`**](./examples/.env):
@@ -191,140 +202,197 @@ ENV=development
 DEBUG=true
 ```
 
-[**`logger.py`**](./examples/logger.py):
+[**`config.py`**](./examples/config.py):
 
 ```python
-from typing import TYPE_CHECKING
+import os
 
-if TYPE_CHECKING:
-    from loguru import Record
+from pydantic_settings import BaseSettings
 
-from beans_logging import Logger, LoggerLoader
-from beans_logging_fastapi import (
-    add_http_file_handler,
-    add_http_file_json_handler,
-    http_file_format,
-)
+from potato_util import io as io_utils
+from beans_logging_fastapi import LoggerConfigPM
 
-logger_loader = LoggerLoader()
-logger: Logger = logger_loader.load()
 
+_config_path = os.path.join(os.getcwd(), "configs", "logger.yml")
+_config_data = {}
+if os.path.isfile(_config_path):
+    _config_data = io_utils.read_config_file(config_path=_config_path)
 
-def _http_file_format(record: "Record") -> str:
-    _format = http_file_format(
-        record=record,
-        msg_format=logger_loader.config.extra.http_file_format,  # type: ignore
-        tz=logger_loader.config.extra.http_file_tz,  # type: ignore
-    )
-    return _format
 
+class MainConfig(BaseSettings):
+    logger: LoggerConfigPM = LoggerConfigPM()
 
-if logger_loader.config.extra.http_file_enabled:  # type: ignore
-    add_http_file_handler(
-        logger_loader=logger_loader,
-        log_path=logger_loader.config.extra.http_log_path,  # type: ignore
-        err_path=logger_loader.config.extra.http_err_path,  # type: ignore
-        formatter=_http_file_format,
-    )
 
-if logger_loader.config.extra.http_json_enabled:  # type: ignore
-    add_http_file_json_handler(
-        logger_loader=logger_loader,
-        log_path=logger_loader.config.extra.http_json_path,  # type: ignore
-        err_path=logger_loader.config.extra.http_json_err_path,  # type: ignore
-    )
+config = MainConfig(**_config_data)
 
 
 __all__ = [
-    "logger",
-    "logger_loader",
+    "MainConfig",
+    "config",
 ]
 ```
 
-[**`main.py`**](./examples/main.py):
+[**`logger.py`**](./examples/logger.py):
 
 ```python
-#!/usr/bin/env python
-
-from typing import Union
-from contextlib import asynccontextmanager
-
-import uvicorn
-from dotenv import load_dotenv
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import RedirectResponse
-
-load_dotenv()
-
-from beans_logging_fastapi import (
-    HttpAccessLogMiddleware,
-    RequestHTTPInfoMiddleware,
-    ResponseHTTPInfoMiddleware,
-)
-
-from logger import logger, logger_loader
-from __version__ import __version__
+from beans_logging_fastapi import logger
 
+__all__ = [
+    "logger",
+]
+```
 
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    logger.info("Preparing to startup...")
-    logger.success("Finished preparation to startup.")
-    logger.info(f"API version: {__version__}")
-
-    yield
-    logger.info("Praparing to shutdown...")
-    logger.success("Finished preparation to shutdown.")
-
+[**`router.py`**](./examples/router.py):
 
-app = FastAPI(lifespan=lifespan, version=__version__)
+```python
+from pydantic import validate_call
+from fastapi import FastAPI, APIRouter, HTTPException
+from fastapi.responses import RedirectResponse
 
-app.add_middleware(ResponseHTTPInfoMiddleware)
-app.add_middleware(
-    HttpAccessLogMiddleware,
-    debug_format=logger_loader.config.extra.http_std_debug_format,  # type: ignore
-    msg_format=logger_loader.config.extra.http_std_msg_format,  # type: ignore
-)
-app.add_middleware(
-    RequestHTTPInfoMiddleware, has_proxy_headers=True, has_cf_headers=True
-)
+router = APIRouter()
 
 
-@app.get("/")
+@router.get("/")
 def root():
     return {"Hello": "World"}
 
 
-@app.get("/items/{item_id}")
-def read_item(item_id: int, q: Union[str, None] = None):
+@router.get("/items/{item_id}")
+def read_item(item_id: int, q: str | None = None):
     return {"item_id": item_id, "q": q}
 
 
-@app.get("/continue", status_code=100)
+@router.get("/continue", status_code=100)
 def get_continue():
     return {}
 
 
-@app.get("/redirect")
+@router.get("/redirect")
 def redirect():
     return RedirectResponse("/")
 
 
-@app.get("/error")
+@router.get("/error")
 def error():
     raise HTTPException(status_code=500)
 
 
-if __name__ == "__main__":
+@validate_call(config={"arbitrary_types_allowed": True})
+def add_routers(app: FastAPI) -> None:
+    """Add routers to FastAPI app.
+
+    Args:
+        app (FastAPI): FastAPI app instance.
+    """
+
+    app.include_router(router)
+
+    return
+
+
+__all__ = ["add_routers"]
+```
+
+[**`bootstrap.py`**](./examples/bootstrap.py):
+
+```python
+# Standard libraries
+from typing import Any
+from collections.abc import Callable
+
+# Third-party libraries
+import uvicorn
+from uvicorn._types import ASGIApplication
+from pydantic import validate_call
+from fastapi import FastAPI
+
+from beans_logging_fastapi import add_logger
+
+# Internal modules
+from __version__ import __version__
+from config import config
+from lifespan import lifespan
+from router import add_routers
+
+
+def create_app() -> FastAPI:
+    """Create FastAPI application instance.
+
+    Returns:
+        FastAPI: FastAPI application instance.
+    """
+
+    app = FastAPI(lifespan=lifespan, version=__version__)
+
+    # Add logger before any other components:
+    add_logger(app=app, config=config.logger)
+
+    # Add any other components after logger:
+    add_routers(app=app)
+
+    return app
+
+
+@validate_call(config={"arbitrary_types_allowed": True})
+def run_server(
+    app: FastAPI | ASGIApplication | Callable[..., Any] | str = "main:app",
+) -> None:
+    """Run uvicorn server.
+
+    Args:
+        app (Union[ASGIApplication, str], optional): ASGI application instance or module path.
+    """
+
     uvicorn.run(
-        app="main:app",
-        host="0.0.0.0",
+        app=app,
+        host="0.0.0.0",  # nosec B104
         port=8000,
-        access_log=False,
+        access_log=False,  # Disable default uvicorn access log
         server_header=False,
-        proxy_headers=True,
+        proxy_headers=False,
         forwarded_allow_ips="*",
     )
+
+    return
+
+
+__all__ = [
+    "create_app",
+    "run_server",
+]
+```
+
+[**`main.py`**](./examples/main.py):
+
+```python
+#!/usr/bin/env python
+
+# Third-party libraries
+from dotenv import load_dotenv
+
+load_dotenv(override=True)
+
+# Internal modules
+from bootstrap import create_app, run_server  # noqa: E402
+from logger import logger  # noqa: E402
+
+
+app = create_app()
+
+
+def main() -> None:
+    """Main function."""
+
+    run_server(app=app)
+    return
+
+
+if __name__ == "__main__":
+    logger.info("Starting server from 'main.py'...")
+    main()
+
+
+__all__ = ["app"]
 ```
 
 Run the [**`examples`**](./examples):
@@ -340,22 +408,24 @@ uvicorn main:app --host=0.0.0.0 --port=8000
 **Output**:
 
 ```txt
-[2025-12-01 00:00:00.735 +09:00 | TRACE | beans_logging._intercept:96]: Intercepted modules: ['potato_util.io', 'concurrent', 'potato_util', 'fastapi', 'uvicorn.error', 'dotenv.main', 'potato_util._base', 'watchfiles.watcher', 'dotenv', 'potato_util.io._sync', 'asyncio', 'uvicorn', 'concurrent.futures', 'watchfiles', 'watchfiles.main']; Muted modules: ['uvicorn.access'];
-[2025-12-01 00:00:00.735 +09:00 | INFO  | uvicorn.server:84]: Started server process [13580]
-[2025-12-01 00:00:00.735 +09:00 | INFO  | uvicorn.lifespan.on:48]: Waiting for application startup.
-[2025-12-01 00:00:00.735 +09:00 | INFO  | main:25]: Preparing to startup...
-[2025-12-01 00:00:00.735 +09:00 | OK    | main:26]: Finished preparation to startup.
-[2025-12-01 00:00:00.735 +09:00 | INFO  | main:27]: API version: 0.0.0
-[2025-12-01 00:00:00.735 +09:00 | INFO  | uvicorn.lifespan.on:62]: Application startup complete.
-[2025-12-01 00:00:00.735 +09:00 | INFO  | uvicorn.server:216]: Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)
-[2025-12-01 00:00:00.736 +09:00 | DEBUG | anyio._backends._asyncio:986]: [4386400aab364895ba272f3200d2a778] 127.0.0.1 - "GET / HTTP/1.1"
-[2025-12-01 00:00:00.736 +09:00 | OK    | anyio._backends._asyncio:986]: [4386400aab364895ba272f3200d2a778] 127.0.0.1 - "GET / HTTP/1.1" 200 17B 0.9ms
-^C[2025-12-01 00:00:00.750 +09:00 | INFO  | uvicorn.server:264]: Shutting down
-[2025-12-01 00:00:00.750 +09:00 | INFO  | uvicorn.lifespan.on:67]: Waiting for application shutdown.
-[2025-12-01 00:00:00.750 +09:00 | INFO  | main:30]: Praparing to shutdown...
-[2025-12-01 00:00:00.750 +09:00 | OK    | main:31]: Finished preparation to shutdown.
-[2025-12-01 00:00:00.750 +09:00 | INFO  | uvicorn.lifespan.on:76]: Application shutdown complete.
-[2025-12-01 00:00:00.750 +09:00 | INFO  | uvicorn.server:94]: Finished server process [13580]
+[2026-01-01 12:00:00.907 +09:00 | TRACE | beans_logging.intercepters:96]: Intercepted modules: ['concurrent.futures', 'potato_util', 'watchfiles.watcher', 'potato_util.io._sync', 'concurrent', 'uvicorn', 'fastapi', 'uvicorn.error', 'dotenv.main', 'watchfiles.main', 'asyncio', 'dotenv', 'potato_util._base', 'potato_util.io', 'watchfiles']; Muted modules: ['uvicorn.access'];
+[2026-01-01 12:00:00.908 +09:00 | INFO  | uvicorn.server:84]: Started server process [64590]
+[2026-01-01 12:00:00.909 +09:00 | INFO  | uvicorn.lifespan.on:48]: Waiting for application startup.
+[2026-01-01 12:00:00.909 +09:00 | TRACE | lifespan:19]: TRACE diagnosis is ON!
+[2026-01-01 12:00:00.909 +09:00 | DEBUG | lifespan:20]: DEBUG mode is ON!
+[2026-01-01 12:00:00.909 +09:00 | INFO  | lifespan:21]: Preparing to startup...
+[2026-01-01 12:00:00.909 +09:00 | OK    | lifespan:24]: Finished preparation to startup.
+[2026-01-01 12:00:00.909 +09:00 | INFO  | lifespan:25]: Version: 0.0.0
+[2026-01-01 12:00:00.909 +09:00 | INFO  | uvicorn.lifespan.on:62]: Application startup complete.
+[2026-01-01 12:00:00.911 +09:00 | INFO  | uvicorn.server:216]: Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)
+[2026-01-01 12:00:01.582 +09:00 | DEBUG | anyio._backends._asyncio:986]: [c433596f728744aaa1cde63399dd3995] 127.0.0.1 - "GET / HTTP/1.1"
+[2026-01-01 12:00:01.586 +09:00 | OK    | anyio._backends._asyncio:986]: [c433596f728744aaa1cde63399dd3995] 127.0.0.1 - "GET / HTTP/1.1" 200 17B 3.1ms
+^C[2026-01-01 12:00:02.074 +09:00 | INFO  | uvicorn.server:264]: Shutting down
+[2026-01-01 12:00:02.177 +09:00 | INFO  | uvicorn.lifespan.on:67]: Waiting for application shutdown.
+[2026-01-01 12:00:02.178 +09:00 | INFO  | lifespan:29]: Preparing to shutdown...
+[2026-01-01 12:00:02.179 +09:00 | OK    | lifespan:31]: Finished preparation to shutdown.
+[2026-01-01 12:00:02.179 +09:00 | INFO  | uvicorn.lifespan.on:76]: Application shutdown complete.
+[2026-01-01 12:00:02.180 +09:00 | INFO  | uvicorn.server:94]: Finished server process [64590]
 ```
 
 👍
@@ -368,7 +438,7 @@ uvicorn main:app --host=0.0.0.0 --port=8000
 
 ```yaml
 logger:
-  # app_name: "app"
+  # app_name: fastapi-app
   default:
     level:
       base: INFO
@@ -381,49 +451,68 @@ logger:
       retention: 90
       encoding: utf8
     custom_serialize: false
+  http:
+    std:
+      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'
+      err_format_str: '<n><w>[{request_id}]</w></n> {client_host} {user_id} "<u>{method} {url_path}</u> HTTP/{http_version}" <n>{status_code}</n>'
+      debug_format_str: '<n>[{request_id}]</n> {client_host} {user_id} "<u>{method} {url_path}</u> HTTP/{http_version}"'
+    file:
+      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}'
+      tz: localtime
+    headers:
+      has_proxy: false
+      has_cf: false
   intercept:
     enabled: true
     only_base: false
     ignore_modules: []
     include_modules: []
-    mute_modules: ["uvicorn.access"]
+    mute_modules: [uvicorn.access]
   handlers:
     default.all.std_handler:
-      type: STD
+      enabled: true
+      h_type: STD
       format: "[<c>{time:YYYY-MM-DD HH:mm:ss.SSS Z}</c> | <level>{extra[level_short]:<5}</level> | <w>{name}:{line}</w>]: <level>{message}</level>"
       colorize: true
-      enabled: true
     default.all.file_handler:
-      type: FILE
-      sink: "{app_name}.all.log"
       enabled: true
+      h_type: FILE
+      sink: "{app_name}.all.log"
     default.err.file_handler:
-      type: FILE
+      enabled: true
+      h_type: FILE
       sink: "{app_name}.err.log"
       error: true
-      enabled: true
     default.all.json_handler:
-      type: FILE
-      sink: "json/{app_name}.json.all.log"
-      serialize: true
       enabled: true
+      h_type: FILE
+      sink: "json/{app_name}.all.json.log"
+      serialize: true
     default.err.json_handler:
-      type: FILE
-      sink: "json/{app_name}.json.err.log"
+      enabled: true
+      h_type: FILE
+      sink: "json/{app_name}.err.json.log"
       serialize: true
       error: true
+    http.access.file_handler:
+      enabled: true
+      h_type: FILE
+      sink: "http/{app_name}.http-access.log"
+    http.err.file_handler:
+      enabled: true
+      h_type: FILE
+      sink: "http/{app_name}.http-err.log"
+      error: true
+    http.access.json_handler:
+      enabled: true
+      h_type: FILE
+      sink: "http.json/{app_name}.http-access.json.log"
+    http.err.json_handler:
       enabled: true
+      h_type: FILE
+      sink: "http.json/{app_name}.http-err.json.log"
+      error: true
   extra:
-    http_std_debug_format: '<n>[{request_id}]</n> {client_host} {user_id} "<u>{method} {url_path}</u> HTTP/{http_version}"'
-    http_std_msg_format: '<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'
-    http_file_enabled: true
-    http_file_format: '{client_host} {request_id} {user_id} [{datetime}] "{method} {url_path} HTTP/{http_version}" {status_code} {content_length} "{h_referer}" "{h_user_agent}" {response_time}'
-    http_file_tz: "localtime"
-    http_log_path: "http/{app_name}.http.access.log"
-    http_err_path: "http/{app_name}.http.err.log"
-    http_json_enabled: true
-    http_json_path: "http.json/{app_name}.http.json.access.log"
-    http_json_err_path: "http.json/{app_name}.http.json.err.log"
 ```
 
 ### 🌎 Environment Variables
@@ -475,7 +564,7 @@ To build the documentation, run the following command:
 pip install -r ./requirements/requirements.docs.txt
 
 # Serve documentation locally (for development):
-mkdocs serve -a 0.0.0.0:8000
+mkdocs serve -a 0.0.0.0:8000 --livereload
 # Or use the docs script:
 ./scripts/docs.sh
 

beans_logging_fastapi-3.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+beans_logging_fastapi/__init__.py,sha256=5nnhUvYdtaMSZ1t549nhYfxOzcKsC4YPx8nEqJWfZYw,225
+beans_logging_fastapi/__version__.py,sha256=EPmgXOdWKks5S__ZMH7Nu6xpAeVrZpfxaFy4pykuyeI,22
+beans_logging_fastapi/_async.py,sha256=IcoQPeBfZwPLt-WBJBpc7g5pELh6plf7VYUel2KyM_c,3478
+beans_logging_fastapi/_core.py,sha256=NUpQGvuLw5YlRNTvssBo4aqrE0lia4nhL1aDahZXncU,2744
+beans_logging_fastapi/config.py,sha256=gt9Kh0-MOZdf0LMGV5gbyYucoTkF8He5QceUP-9vS8U,5298
+beans_logging_fastapi/constants.py,sha256=pRsgi1pqkEDMKmSWDQeK72TSXiuVkJaEMTOUeB82E5A,382
+beans_logging_fastapi/filters.py,sha256=hBhHqCWJr7c2CA7uDAje8R8x9RtpCcBHZSC6xuXLYDs,622
+beans_logging_fastapi/formats.py,sha256=ENfCB54ftUZZFj5J9kKCsdCkeqzStG3l0_9vLBLi8Oc,2600
+beans_logging_fastapi/middlewares.py,sha256=ToUS4jPUPcZHTr_d7DWLjfBI-E9FrspasRqkc4Gyg2M,13676
+beans_logging_fastapi-3.0.0.dist-info/licenses/LICENSE.txt,sha256=CUTK-r0BWIg1r0bBiemAcMhakgV0N7HuRhw6rQ-A9A4,1074
+beans_logging_fastapi-3.0.0.dist-info/METADATA,sha256=iL3NjWvF6KMVxaO7RytgEMuGxMoWAQBlyXqF0lsaBdM,17344
+beans_logging_fastapi-3.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+beans_logging_fastapi-3.0.0.dist-info/top_level.txt,sha256=PXoqVo9HGfyd81gDi3D2mXMYPM9JKITL0ycFftJxlhw,22
+beans_logging_fastapi-3.0.0.dist-info/RECORD,,

{beans_logging_fastapi-2.0.0.dist-info → beans_logging_fastapi-3.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

beans_logging_fastapi/_base.py

@@ -1,107 +0,0 @@
-from typing import Any
-
-from fastapi import Request, Response
-from fastapi.concurrency import run_in_threadpool
-from starlette.middleware.base import BaseHTTPMiddleware
-
-from beans_logging import logger
-
-
-class HttpAccessLogMiddleware(BaseHTTPMiddleware):
-    """Http access log middleware for FastAPI.
-
-    Inherits:
-        BaseHTTPMiddleware: Base HTTP middleware class from starlette.
-
-    Attributes:
-        _DEBUG_FORMAT     (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 ): 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_format      (str ): Http access log debug message format. Defaults to
-                                    `HttpAccessLogMiddleware._DEBUG_FORMAT`.
-        msg_format        (str ): Http access log message format. Defaults to `HttpAccessLogMiddleware._MSG_FORMAT`.
-        use_debug_log     (bool): If True, use debug log to log http access log. Defaults to True.
-    """
-
-    _DEBUG_FORMAT = '<n>[{request_id}]</n> {client_host} {user_id} "<u>{method} {url_path}</u> HTTP/{http_version}"'
-    _MSG_FORMAT = (
-        '<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_format: str = _DEBUG_FORMAT,
-        msg_format: str = _MSG_FORMAT,
-        use_debug_log: bool = True,
-    ):
-        super().__init__(app)
-        self.debug_format = debug_format
-        self.msg_format = msg_format
-        self.use_debug_log = use_debug_log
-
-    async def dispatch(self, request: Request, call_next) -> Response:
-        _logger = logger.opt(colors=True, record=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_format.format(**_http_info)
-
-            # _logger.debug(_debug_msg)
-            await run_in_threadpool(
-                _logger.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 = self.msg_format
-        if _http_info["status_code"] < 200:
-            _LEVEL = "DEBUG"
-            _msg_format = f'<d>{_msg_format.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 = f'<w>{_msg_format.replace("{status_code}", "<lvl>{status_code}</lvl>")}</w>'
-        elif (300 <= _http_info["status_code"]) and (_http_info["status_code"] < 400):
-            _LEVEL = "INFO"
-            _msg_format = f'<d>{_msg_format.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 = _msg_format.replace("{status_code}", "<r>{status_code}</r>")
-        elif 500 <= _http_info["status_code"]:
-            _LEVEL = "ERROR"
-            _msg_format = (
-                f'{_msg_format.replace("{status_code}", "<n>{status_code}</n>")}'
-            )
-
-        _msg = _msg_format.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__ = [
-    "HttpAccessLogMiddleware",
-]

beans_logging_fastapi/_handlers.py

@@ -1,96 +0,0 @@
-from collections.abc import Callable
-
-from pydantic import validate_call
-
-from beans_logging import LoggerLoader
-
-from ._filters import use_http_filter
-from ._formats import http_file_format, http_file_json_format
-
-
-@validate_call(config={"arbitrary_types_allowed": True})
-def add_http_file_handler(
-    logger_loader: LoggerLoader,
-    log_path: str = "http/{app_name}.http.access.log",
-    err_path: str = "http/{app_name}.http.err.log",
-    formatter: Callable | str = http_file_format,
-) -> None:
-    """Add http access log file and error file handler.
-
-    Args:
-        logger_loader (LoggerLoader,         required): LoggerLoader instance.
-        log_path      (str,                  optional): Log file path. Defaults to "http/{app_name}.http.access.log".
-        err_path      (str,                  optional): Error log file path. Defaults to "http/{app_name}.http.err.log".
-        formatter     (Union[Callable, str], optional): Log formatter. Defaults to `http_file_format` function.
-    """
-
-    logger_loader.add_handler(
-        name="default.http.access.file_handler",
-        handler={
-            "type": "FILE",
-            "sink": log_path,
-            "filter": use_http_filter,
-            "format": formatter,
-        },
-    )
-
-    logger_loader.add_handler(
-        name="default.http.err.file_handler",
-        handler={
-            "type": "FILE",
-            "sink": err_path,
-            "filter": use_http_filter,
-            "format": formatter,
-            "error": True,
-        },
-    )
-
-    return
-
-
-@validate_call(config={"arbitrary_types_allowed": True})
-def add_http_file_json_handler(
-    logger_loader: LoggerLoader,
-    log_path: str = "http.json/{app_name}.http.json.access.log",
-    err_path: str = "http.json/{app_name}.http.json.err.log",
-    formatter: Callable | str = http_file_json_format,
-) -> None:
-    """Add http access json log file and json error file handler.
-
-    Args:
-        logger_loader (LoggerLoader,         required): LoggerLoader instance.
-        log_path      (str,                  optional): Json log file path. Defaults to
-                                                            "http.json/{app_name}.http.json.access.log".
-        err_path      (str,                  optional): Json error log file path. Defaults to
-                                                            "http.json/{app_name}.http.json.err.log".
-        formatter     (Union[Callable, str], optional): Log formatter. Defaults to `http_file_json_format` function.
-    """
-
-    logger_loader.add_handler(
-        name="default.http.access.json_handler",
-        handler={
-            "type": "FILE",
-            "sink": log_path,
-            "filter": use_http_filter,
-            "format": formatter,
-        },
-    )
-
-    logger_loader.add_handler(
-        name="default.http.err.json_handler",
-        handler={
-            "type": "FILE",
-            "sink": err_path,
-            "filter": use_http_filter,
-            "format": formatter,
-            "error": True,
-        },
-    )
-
-    return
-
-
-__all__ = [
-    "add_http_file_handler",
-    "add_http_file_json_handler",
-]

beans_logging_fastapi-2.0.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-beans_logging_fastapi/__init__.py,sha256=hTuW6GTdPinZ1qamna7N0RsElfVJnkkOI0iLnMbQ7B8,865
-beans_logging_fastapi/__version__.py,sha256=_7OlQdbVkK4jad0CLdpI0grT-zEAb-qgFmH5mFzDXiA,22
-beans_logging_fastapi/_async_log.py,sha256=01VJ1cnzacDlIjiScm0hubhkj0xkeU5pBB_0fPJS-5w,3478
-beans_logging_fastapi/_base.py,sha256=mRAUxEBYU00IrE4QgaYDqrUxHhCiKp3cEzVNy2bDsM0,4259
-beans_logging_fastapi/_filters.py,sha256=hBhHqCWJr7c2CA7uDAje8R8x9RtpCcBHZSC6xuXLYDs,622
-beans_logging_fastapi/_formats.py,sha256=J5tu9QwU6jCNZvMt7y5WpfcM862GLvgGHGfvjh5k2T4,2600
-beans_logging_fastapi/_handlers.py,sha256=_v4VigZM2j1kphUPViKp21DiwR3CB1mM6MXz_NUAE7c,3128
-beans_logging_fastapi/_middlewares.py,sha256=gcx8NrgWv1OMFln4nvnaPgY6Np92Nv6OTMJf97EcH08,9558
-beans_logging_fastapi-2.0.0.dist-info/licenses/LICENSE.txt,sha256=CUTK-r0BWIg1r0bBiemAcMhakgV0N7HuRhw6rQ-A9A4,1074
-beans_logging_fastapi-2.0.0.dist-info/METADATA,sha256=aM3l5OHfrFiy1RYGOYHmOMl7fG0iTGmgXd1tV1F6oLQ,16031
-beans_logging_fastapi-2.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-beans_logging_fastapi-2.0.0.dist-info/top_level.txt,sha256=PXoqVo9HGfyd81gDi3D2mXMYPM9JKITL0ycFftJxlhw,22
-beans_logging_fastapi-2.0.0.dist-info/RECORD,,