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

beans_logging_fastapi/{_middlewares.py → middlewares.py}

@@ -1,10 +1,10 @@
-# -*- coding: utf-8 -*-
-
 import time
 from uuid import uuid4
-from typing import Callable, Dict, Any
+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
@@ -30,11 +30,11 @@ class RequestHTTPInfoMiddleware(BaseHTTPMiddleware):
         self.has_cf_headers = has_cf_headers
 
     async def dispatch(self, request: Request, call_next: Callable) -> Response:
-        _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
 
         _http_info["request_id"] = uuid4().hex
         if "X-Request-ID" in request.headers:
@@ -42,18 +42,20 @@ class RequestHTTPInfoMiddleware(BaseHTTPMiddleware):
         elif "X-Correlation-ID" in request.headers:
             _http_info["request_id"] = request.headers.get("X-Correlation-ID")
 
-        ## Set request_id to request state:
+        # Set request_id to request state:
         request.state.request_id = _http_info["request_id"]
 
-        _http_info["client_host"] = request.client.host
+        if request.client:
+            _http_info["client_host"] = request.client.host
+
         _http_info["request_proto"] = request.url.scheme
         _http_info["request_host"] = (
             request.url.hostname if request.url.hostname else ""
         )
         if (request.url.port != 80) and (request.url.port != 443):
-            _http_info[
-                "request_host"
-            ] = f"{_http_info['request_host']}:{request.url.port}"
+            _http_info["request_host"] = (
+                f"{_http_info['request_host']}:{request.url.port}"
+            )
 
         _http_info["request_port"] = request.url.port
         _http_info["http_version"] = request.scope["http_version"]
@@ -63,7 +65,7 @@ class RequestHTTPInfoMiddleware(BaseHTTPMiddleware):
                 _http_info["client_host"] = request.headers.get("X-Real-IP")
             elif "X-Forwarded-For" in request.headers:
                 _http_info["client_host"] = request.headers.get(
-                    "X-Forwarded-For"
+                    "X-Forwarded-For", ""
                 ).split(",")[0]
                 _http_info["h_x_forwarded_for"] = request.headers.get("X-Forwarded-For")
 
@@ -77,12 +79,14 @@ class RequestHTTPInfoMiddleware(BaseHTTPMiddleware):
 
             if "X-Forwarded-Port" in request.headers:
                 try:
-                    _http_info["request_port"] = int(
-                        request.headers.get("X-Forwarded-Port")
-                    )
+                    _x_forwarded_port = request.headers.get("X-Forwarded-Port")
+                    if _x_forwarded_port:
+                        _http_info["request_port"] = int(_x_forwarded_port)
+
                 except ValueError:
                     logger.warning(
-                        f"`X-Forwarded-Port` header value '{request.headers.get('X-Forwarded-Port')}' is invalid, should be parseable to <int>!"
+                        f"`X-Forwarded-Port` header value '{request.headers.get('X-Forwarded-Port')}' is invalid, "
+                        "should be parseable to <int>!"
                     )
 
             if "Via" in request.headers:
@@ -138,7 +142,7 @@ class RequestHTTPInfoMiddleware(BaseHTTPMiddleware):
         if "}" in _http_info["url_path"]:
             _http_info["url_path"] = _http_info["url_path"].replace("}", "}}")
         if "<" in _http_info["url_path"]:
-            _http_info["url_path"] = _http_info["url_path"].replace("<", "\<")
+            _http_info["url_path"] = _http_info["url_path"].replace("<", "\\<")
         if request.url.query:
             _http_info["url_path"] = f"{request.url.path}?{request.url.query}"
 
@@ -157,7 +161,7 @@ class RequestHTTPInfoMiddleware(BaseHTTPMiddleware):
         if hasattr(request.state, "user_id"):
             _http_info["user_id"] = str(request.state.user_id)
 
-        ## Set http info to request state:
+        # Set http info to request state:
         request.state.http_info = _http_info
         response: Response = await call_next(request)
         return response
@@ -172,28 +176,30 @@ class ResponseHTTPInfoMiddleware(BaseHTTPMiddleware):
     """
 
     async def dispatch(self, request: Request, call_next: Callable) -> Response:
-        _http_info: Dict[str, Any] = {}
+        _http_info: dict[str, Any] = {}
         _start_time: int = time.perf_counter_ns()
-        ## Process request:
+        # Process request:
         response: Response = await call_next(request)
-        ## Response processed.
+        # Response processed.
         _end_time: int = time.perf_counter_ns()
         _response_time: float = round((_end_time - _start_time) / 1_000_000, 1)
 
         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["response_time"] = _response_time
         if "X-Process-Time" in response.headers:
             try:
-                _http_info["response_time"] = float(
-                    response.headers.get("X-Process-Time")
-                )
+                _x_process_time = response.headers.get("X-Process-Time")
+                if _x_process_time:
+                    _http_info["response_time"] = float(_x_process_time)
+
             except ValueError:
                 logger.warning(
-                    f"`X-Process-Time` header value '{response.headers.get('X-Process-Time')}' is invalid, should be parseable to <float>!"
+                    f"`X-Process-Time` header value '{response.headers.get('X-Process-Time')}' is invalid, "
+                    "should be parseable to <float>!"
                 )
         else:
             response.headers["X-Process-Time"] = str(_http_info["response_time"])
@@ -208,16 +214,117 @@ class ResponseHTTPInfoMiddleware(BaseHTTPMiddleware):
         _http_info["content_length"] = 0
         if "Content-Length" in response.headers:
             try:
-                _http_info["content_length"] = int(
-                    response.headers.get("Content-Length")
-                )
+                _content_length = response.headers.get("Content-Length")
+                if _content_length:
+                    _http_info["content_length"] = int(_content_length)
+
             except ValueError:
                 logger.warning(
-                    f"`Content-Length` header value '{response.headers.get('Content-Length')}' is invalid, should be parseable to <int>!"
+                    f"`Content-Length` header value '{response.headers.get('Content-Length')}' is invalid, "
+                    "should be parseable to <int>!"
                 )
 
         request.state.http_info = _http_info
         return response
 
 
-__all__ = ["RequestHTTPInfoMiddleware", "ResponseHTTPInfoMiddleware"]
+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",
+]