fix pr changes except call_next type

Author: suhasunni

gs/backend/api/middleware/logger_middleware.py

@@ -1,47 +1,77 @@
-from fastapi import Request, Response
-from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
-from loguru import logger
-from time import time
+from collections.abc import Sequence
+from datetime import datetime
 from sys import getsizeof
-from typing import List
+from time import time
+from typing import Final
+
+from fastapi import FastAPI, Request, Response
+from loguru import logger
+from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
+
 
-#add any endpoints we don't want logged here, e.g "/example/endpoint"
-excluded_endpoints: List[str] = []
 class LoggerMiddleware(BaseHTTPMiddleware):
     """Middleware that logs the request and response"""
 
+    def __init__(self, app: FastAPI, excluded_endpoints: Sequence[str] = ()) -> None:
+        super().__init__(app)
+        self.excluded_endpoints = excluded_endpoints
+
     async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:
+        """Logs the request and response"""
+        request_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
         start_time = time()
         response = await call_next(request)
         process_time = time() - start_time
-        
-        if request.url.path in excluded_endpoints:
+
+        if request.url.path in self.excluded_endpoints:
             return response
-        
+
         request_body = await request.body()
         request_size = getsizeof(request_body)
         # TODO: update this based on userID header name
         request_user_id = request.headers.get("user_id", "Anonymous")
         request_params = dict(request.query_params)
 
-        logger.info(f"REQUEST | Method: {request.method} | URL: {request.url.path} | User id: {request_user_id} | Params: {request_params} | Size: {request_size} bytes.")
-        
-        if response.status_code >= 500:
+        logger.info(
+            " | ".join(
+                [
+                    f"REQUEST | Method: {request.method}",
+                    f"URL: {request.url.path}",
+                    f"User id: {request_user_id}",
+                    f"Params: {request_params}",
+                    f"Time: {request_time}",
+                    f"Size: {request_size} bytes.",
+                ]
+            )
+        )
+
+        http_status_code_error_server: Final[int] = 500
+        http_status_code_error: Final[int] = 400
+
+        if response.status_code >= http_status_code_error_server:
             logger_severity = logger.critical
-        elif response.status_code >= 400:
+        elif response.status_code >= http_status_code_error:
             logger_severity = logger.error
         else:
             logger_severity = logger.info
-        
-        response_body = b''.join([chunk async for chunk in response.body_iterator])
+
+        response_body = b"".join([chunk async for chunk in response.body_iterator])
         response_size = getsizeof(response_body)
-        
-        logger_severity(f"RESPONSE | Status: {response.status_code} | Response: {response_body.decode(errors='ignore')} | Size: {response_size} bytes | Time Elasped: {process_time:.3f}.")
-        
+
+        logger_severity(
+            " | ".join(
+                [
+                    f"RESPONSE | Status: {response.status_code}",
+                    f"Response: {response_body.decode(errors='ignore')}",
+                    f"Size: {response_size} bytes",
+                    f"Time Elasped: {process_time:.3f}.",
+                ]
+            )
+        )
+
         return Response(
-            content=response_body, 
-            status_code=response.status_code, 
-            headers=dict(response.headers), 
+            content=response_body,
+            status_code=response.status_code,
+            headers=dict(response.headers),
             media_type=response.media_type,
         )
-