refactor: use optimized should_log checks

Author: Lancetnik

microbootstrap/middlewares/fastapi.py

@@ -6,23 +6,23 @@
 from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
 
 from microbootstrap.instruments.logging_instrument import fill_log_message
+from .utils import optimize_exclude_paths
 
 
 def build_fastapi_logging_middleware(
     exclude_endpoints: typing.Iterable[str],
 ) -> type[BaseHTTPMiddleware]:
+    endpoints_to_ignore: typing.Collection[str] = optimize_exclude_paths(exclude_endpoints)
+
     class FastAPILoggingMiddleware(BaseHTTPMiddleware):
         async def dispatch(
             self,
             request: fastapi.Request,
             call_next: RequestResponseEndpoint,
         ) -> fastapi.Response:
             request_path: typing.Final = request.url.path.removesuffix("/")
-            should_log: typing.Final = not any(
-                exclude_endpoint == request_path for exclude_endpoint in exclude_endpoints
-            )
 
-            if not should_log:
+            if request_path in endpoints_to_ignore:
                 return await call_next(request)
 
             start_time: typing.Final = time.perf_counter_ns()

microbootstrap/middlewares/litestar.py

@@ -8,11 +8,14 @@
 from litestar.status_codes import HTTP_500_INTERNAL_SERVER_ERROR
 
 from microbootstrap.instruments.logging_instrument import fill_log_message
+from .utils import optimize_exclude_paths
 
 
 def build_litestar_logging_middleware(
     exclude_endpoints: typing.Iterable[str],
 ) -> type[MiddlewareProtocol]:
+    endpoints_to_ignore: typing.Collection[str] = optimize_exclude_paths(exclude_endpoints)
+
     class LitestarLoggingMiddleware(MiddlewareProtocol):
         def __init__(self, app: litestar.types.ASGIApp) -> None:
             self.app = app
@@ -26,9 +29,8 @@ async def __call__(
             request: typing.Final[litestar.Request] = litestar.Request(request_scope)  # type: ignore[type-arg]
 
             request_path = request.url.path.removesuffix("/")
-            should_log: typing.Final = not any(one_endpoint == request_path for one_endpoint in exclude_endpoints)
 
-            if not should_log:
+            if request_path in endpoints_to_ignore:
                 await self.app(request_scope, receive, send_function)
                 return
 

microbootstrap/middlewares/utils.py

@@ -0,0 +1,15 @@
+import typing
+
+
+def optimize_exclude_paths(
+    exclude_endpoints: typing.Iterable[str],
+) -> typing.Collection[str]:
+    # `in` operator is faster for tuples than for lists
+    endpoints_to_ignore: typing.Collection[str] = tuple(exclude_endpoints)
+
+    # 10 is just an empirical value, based of measuring the performance
+    # iterating over a tuple of <10 elements is faster than hashing
+    if len(endpoints_to_ignore) >= 10:  # noqa: PLR2004
+        endpoints_to_ignore = set(endpoints_to_ignore)
+
+    return endpoints_to_ignore