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

beans_logging_fastapi/__init__.py

@@ -1,4 +1,4 @@
-# -*- coding: utf-8 -*-
+# flake8: noqa
 
 from ._filters import use_http_filter
 from ._formats import http_file_format, http_file_json_format

beans_logging_fastapi/__version__.py

@@ -1,3 +1 @@
-# -*- coding: utf-8 -*-
-
-__version__ = "1.1.1"
+__version__ = "2.0.0"

beans_logging_fastapi/_async_log.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>',
-):
+    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>'
+    ),
+) -> 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>'.
+        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>'.
     """
 
-    _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)
     _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/_base.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-from typing import Dict, Any
+from typing import Any
 
 from fastapi import Request, Response
 from fastapi.concurrency import run_in_threadpool
@@ -16,16 +14,23 @@ class HttpAccessLogMiddleware(BaseHTTPMiddleware):
         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`.
+        _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'
+    _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,
@@ -42,13 +47,13 @@ class HttpAccessLogMiddleware(BaseHTTPMiddleware):
     async def dispatch(self, request: Request, call_next) -> Response:
         _logger = logger.opt(colors=True, record=True)
 
-        _http_info: Dict[str, Any] = {}
+        _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
+            _http_info: dict[str, Any] = request.state.http_info
 
-        ## Debug log:
+        # Debug log:
         if self.use_debug_log:
             _debug_msg = self.debug_format.format(**_http_info)
 
@@ -57,18 +62,18 @@ class HttpAccessLogMiddleware(BaseHTTPMiddleware):
                 _logger.debug,
                 _debug_msg,
             )
-        ## Debug log
+        # Debug log
 
-        ## Process request:
+        # Process request:
         response: Response = await call_next(request)
-        ## Response processed.
+        # 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_info: dict[str, Any] = request.state.http_info
 
-        ## Http access log:
+        # Http access log:
         _LEVEL = "INFO"
         _msg_format = self.msg_format
         if _http_info["status_code"] < 200:
@@ -92,9 +97,11 @@ class HttpAccessLogMiddleware(BaseHTTPMiddleware):
         _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
+        # Http access log
 
         return response
 
 
-__all__ = ["HttpAccessLogMiddleware"]
+__all__ = [
+    "HttpAccessLogMiddleware",
+]

beans_logging_fastapi/_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

@@ -1,18 +1,26 @@
-# -*- coding: utf-8 -*-
-
-from typing import Dict, Any
+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: dict,
-    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}',
+    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}'
+    ),
     tz: str = "localtime",
 ) -> str:
     """Http access log file format.
 
     Args:
-        record (dict): Log record as dictionary.
+        record     (Record, required): Log record as dictionary.
+        msg_format (str   , optional): Log message format.
+        tz         (str   , optional): Timezone for datetime field. Defaults to 'localtime'.
 
     Returns:
         str: Format for http access log record.
@@ -21,43 +29,44 @@ def http_file_format(
     if "http_info" not in record["extra"]:
         return ""
 
-    if "http_message" not in record:
-        _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"))
+    if "http_message" in record["extra"]:
+        del record["extra"]["http_message"]
 
-                _dt = _dt.astimezone(ZoneInfo(tz))
+    _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"))
 
-            _http_info["datetime"] = _dt.isoformat(timespec="milliseconds")
+            _dt = _dt.astimezone(ZoneInfo(tz))
 
-        if "content_length" not in _http_info:
-            _http_info["content_length"] = 0
+        _http_info["datetime"] = _dt.isoformat(timespec="milliseconds")
 
-        if "h_referer" not in _http_info:
-            _http_info["h_referer"] = "-"
+    if "content_length" not in _http_info:
+        _http_info["content_length"] = 0
 
-        if "h_user_agent" not in _http_info:
-            _http_info["h_user_agent"] = "-"
+    if "h_referer" not in _http_info:
+        _http_info["h_referer"] = "-"
 
-        if "response_time" not in _http_info:
-            _http_info["response_time"] = 0
+    if "h_user_agent" not in _http_info:
+        _http_info["h_user_agent"] = "-"
 
-        record["extra"]["http_info"] = _http_info
+    if "response_time" not in _http_info:
+        _http_info["response_time"] = 0
 
-        _msg = msg_format.format(**_http_info)
-        record["http_message"] = _msg
+    record["extra"]["http_info"] = _http_info
+    _msg = msg_format.format(**_http_info)
 
-    return "{http_message}\n"
+    record["extra"]["http_message"] = _msg
+    return "{extra[http_message]}\n"
 
 
-def http_file_json_format(record: dict) -> str:
+def http_file_json_format(record: "Record") -> str:
     """Http access json log file format.
 
     Args:
-        record (dict): Log record as dictionary.
+        record (Record, required): Log record as dictionary.
 
     Returns:
         str: Format for http access json log record.
@@ -66,12 +75,21 @@ def http_file_json_format(record: dict) -> str:
     if "http_info" not in record["extra"]:
         return ""
 
-    _http_info: Dict[str, Any] = record["extra"]["http_info"]
-    if "datetime" not in _http_info:
-        _http_info["datetime"] = record["time"].isoformat(timespec="milliseconds")
-        record["extra"]["http_info"] = _http_info
+    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_info]}\n"
+    return "{extra[http_serialized]}\n"
 
 
-__all__ = ["http_file_format", "http_file_json_format"]
+__all__ = [
+    "http_file_format",
+    "http_file_json_format",
+]

beans_logging_fastapi/_handlers.py

@@ -1,13 +1,6 @@
-# -*- coding: utf-8 -*-
+from collections.abc import Callable
 
-from typing import Union, Callable
-
-import pydantic
-
-if "2.0.0" <= pydantic.__version__:
-    from pydantic import validate_call
-else:
-    from pydantic import validate_arguments as validate_call
+from pydantic import validate_call
 
 from beans_logging import LoggerLoader
 
@@ -15,13 +8,13 @@ from ._filters import use_http_filter
 from ._formats import http_file_format, http_file_json_format
 
 
-@validate_call(config=dict(arbitrary_types_allowed=True))
+@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: Union[Callable, str] = http_file_format,
-):
+    formatter: Callable | str = http_file_format,
+) -> None:
     """Add http access log file and error file handler.
 
     Args:
@@ -31,52 +24,73 @@ def add_http_file_handler(
         formatter     (Union[Callable, str], optional): Log formatter. Defaults to `http_file_format` function.
     """
 
-    logger_loader.add_custom_handler(
-        handler_name="FILE.HTTP",
-        sink=log_path,
-        filter=use_http_filter,
-        format=formatter,
+    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_custom_handler(
-        handler_name="FILE.HTTP_ERR",
-        sink=err_path,
-        level="WARNING",
-        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=dict(arbitrary_types_allowed=True))
+
+@validate_call(config={"arbitrary_types_allowed": True})
 def add_http_file_json_handler(
     logger_loader: LoggerLoader,
-    log_path: str = "json.http/{app_name}.json.http.access.log",
-    err_path: str = "json.http/{app_name}.json.http.err.log",
-    formatter: Union[Callable, str] = http_file_json_format,
-):
+    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}.json.http.access.log".
-        err_path      (str,                  optional): Json error log file path. Defaults to "http.json/{app_name}.json.http.err.log".
+        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_custom_handler(
-        handler_name="FILE.JSON.HTTP",
-        sink=log_path,
-        filter=use_http_filter,
-        format=formatter,
+    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_custom_handler(
-        handler_name="FILE.JSON.HTTP_ERR",
-        sink=err_path,
-        level="WARNING",
-        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"]
+__all__ = [
+    "add_http_file_handler",
+    "add_http_file_json_handler",
+]