maleo-foundation 0.2.78__py3-none-any.whl → 0.2.80__py3-none-any.whl

maleo_foundation/managers/service.py

@@ -90,6 +90,7 @@ class MaleoClientConfiguration(BaseModel):
     url:str = Field(..., description="Client's URL")
 
 class MaleoClientConfigurations(BaseModel):
+    telemetry:MaleoClientConfiguration = Field(..., description="MaleoTelemetry client's configuration")
     metadata:MaleoClientConfiguration = Field(..., description="MaleoMetadata client's configuration")
     identity:MaleoClientConfiguration = Field(..., description="MaleoIdentity client's configuration")
     access:MaleoClientConfiguration = Field(..., description="MaleoAccess client's configuration")

maleo_foundation/middlewares/base.py

@@ -4,303 +4,432 @@ import time
 import traceback
 from collections import defaultdict
 from datetime import datetime, timedelta, timezone
+from typing import Awaitable, Callable, Optional, Sequence, Dict, List
+from uuid import UUID, uuid4
+
 from fastapi import FastAPI, Request, Response, status
 from fastapi.responses import JSONResponse
 from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
-from typing import Awaitable, Callable, Optional, Sequence
+
 from maleo_foundation.authentication import Authentication
 from maleo_foundation.enums import BaseEnums
 from maleo_foundation.client.manager import MaleoFoundationClientManager
 from maleo_foundation.models.schemas import BaseGeneralSchemas
 from maleo_foundation.models.responses import BaseResponses
-from maleo_foundation.models.transfers.general.token \
-    import MaleoFoundationTokenGeneralTransfers
-from maleo_foundation.models.transfers.parameters.token \
-    import MaleoFoundationTokenParametersTransfers
-from maleo_foundation.models.transfers.parameters.signature \
-    import MaleoFoundationSignatureParametersTransfers
+from maleo_foundation.models.transfers.general.token import MaleoFoundationTokenGeneralTransfers
+from maleo_foundation.models.transfers.parameters.token import MaleoFoundationTokenParametersTransfers
+from maleo_foundation.models.transfers.parameters.signature import MaleoFoundationSignatureParametersTransfers
 from maleo_foundation.utils.extractor import BaseExtractors
 from maleo_foundation.utils.logging import MiddlewareLogger
 
 RequestProcessor = Callable[[Request], Awaitable[Optional[Response]]]
 ResponseProcessor = Callable[[Response], Awaitable[Response]]
 
-class BaseMiddleware(BaseHTTPMiddleware):
+class RateLimiter:
+    """Thread-safe rate limiter with automatic cleanup."""
+
     def __init__(
         self,
-        app:FastAPI,
-        keys:BaseGeneralSchemas.RSAKeys,
-        logger:MiddlewareLogger,
-        maleo_foundation:MaleoFoundationClientManager,
-        allow_origins:Sequence[str] = (),
-        allow_methods:Sequence[str] = ("GET",),
-        allow_headers:Sequence[str] = (),
-        allow_credentials:bool = False,
-        limit:int = 10,
-        window:int = 1,
-        cleanup_interval:int = 60,
-        ip_timeout:int = 300
+        limit:int,
+        window:timedelta,
+        ip_timeout:timedelta,
+        cleanup_interval:timedelta
     ):
-        super().__init__(app)
-        self._keys = keys
-        self._logger = logger
-        self._maleo_foundation = maleo_foundation
-        self._allow_origins = allow_origins
-        self._allow_methods = allow_methods
-        self._allow_headers = allow_headers
-        self._allow_credentials = allow_credentials
-        self._limit = limit
-        self._window = timedelta(seconds=window)
-        self._cleanup_interval = timedelta(seconds=cleanup_interval)
-        self._ip_timeout = timedelta(seconds=ip_timeout)
-        self._requests:dict[str, list[datetime]] = defaultdict(list)
-        self._last_seen: dict[str, datetime] = {}
+        self.limit = limit
+        self.window = window
+        self.ip_timeout = ip_timeout
+        self.cleanup_interval = cleanup_interval
+        self._requests:Dict[str, List[datetime]] = defaultdict(list)
+        self._last_seen:Dict[str, datetime] = {}
         self._last_cleanup = datetime.now()
-        self._lock = threading.RLock()  #* Use RLock for thread safety
-
-    def _cleanup_old_data(self) -> None:
-        """
-        Periodically clean up old request data to prevent memory growth.
-        Removes:
-        1. IPs with empty request lists
-        2. IPs that haven't been seen in ip_timeout period
-        """
-        now = datetime.now()
-        if now - self._last_cleanup > self._cleanup_interval:
-            with self._lock:
-                #* Remove inactive IPs (not seen recently) and empty lists
-                inactive_ips = []
-                for ip in list(self._requests.keys()):
-                    #* Remove IPs with empty timestamp lists
-                    if not self._requests[ip]:
-                        inactive_ips.append(ip)
-                        continue
-                        
-                    #* Remove IPs that haven't been active recently
-                    last_active = self._last_seen.get(ip, datetime.min)
-                    if now - last_active > self._ip_timeout:
-                        inactive_ips.append(ip)
-                
-                #* Remove the inactive IPs
-                for ip in inactive_ips:
-                    if ip in self._requests:
-                        del self._requests[ip]
-                    if ip in self._last_seen:
-                        del self._last_seen[ip]
-                
-                # Update last cleanup time
-                self._last_cleanup = now
-                self._logger.debug(f"Cleaned up request cache. Removed {len(inactive_ips)} inactive IPs. Current tracked IPs: {len(self._requests)}")
-
-    def _check_rate_limit(
+        self._lock = threading.RLock()
+
+    def is_rate_limited(
         self,
         client_ip:str
     ) -> bool:
-        """Check if the client has exceeded their rate limit"""
+        """Check if client IP is rate limited and record the request."""
         with self._lock:
-            now = datetime.now() #* Define current timestamp
-            self._last_seen[client_ip] = now #* Update last seen timestamp for this IP
+            now = datetime.now()
+            self._last_seen[client_ip] = now
 
-            #* Filter requests within the window
+            # Remove old requests outside the window
             self._requests[client_ip] = [
                 timestamp for timestamp in self._requests[client_ip]
-                if now - timestamp <= self._window
+                if now - timestamp <= self.window
             ]
 
-            #* Check if the request count exceeds the limit
-            if len(self._requests[client_ip]) >= self._limit:
+            # Check rate limit
+            if len(self._requests[client_ip]) >= self.limit:
                 return True
 
-            #* Add the current request timestamp
+            # Record this request
             self._requests[client_ip].append(now)
             return False
 
-    def _add_response_headers(
+    def cleanup_old_data(
+        self,
+        logger:MiddlewareLogger
+    ) -> None:
+        """Clean up old request data to prevent memory growth."""
+        now = datetime.now()
+        if now - self._last_cleanup <= self.cleanup_interval:
+            return
+
+        with self._lock:
+            inactive_ips = []
+
+            for ip in list(self._requests.keys()):
+                # Remove IPs with empty request lists
+                if not self._requests[ip]:
+                    inactive_ips.append(ip)
+                    continue
+
+                # Remove IPs that haven't been active recently
+                last_active = self._last_seen.get(ip, datetime.min)
+                if now - last_active > self.ip_timeout:
+                    inactive_ips.append(ip)
+
+            # Clean up inactive IPs
+            for ip in inactive_ips:
+                self._requests.pop(ip, None)
+                self._last_seen.pop(ip, None)
+
+            self._last_cleanup = now
+            logger.debug(
+                f"Cleaned up request cache. Removed {len(inactive_ips)} inactive IPs. "
+                f"Current tracked IPs: {len(self._requests)}"
+            )
+
+
+class ResponseBuilder:
+    """Handles response building and header management."""
+
+    def __init__(
+        self,
+        keys:BaseGeneralSchemas.RSAKeys,
+        maleo_foundation:MaleoFoundationClientManager
+    ):
+        self.keys = keys
+        self.maleo_foundation = maleo_foundation
+
+    def add_response_headers(
         self,
         request:Request,
         authentication:Authentication,
         response:Response,
         request_timestamp:datetime,
         response_timestamp:datetime,
-        process_time:int
+        process_time:float,
+        request_id:UUID
     ) -> Response:
-        response.headers["X-Process-Time"] = str(process_time) #* Add Process Time Header
-        response.headers["X-Request-Timestamp"] = request_timestamp.isoformat() #* Add request timestamp header
-        response.headers["X-Response-Timestamp"] = response_timestamp.isoformat() #* Define and add response timestamp header
-        #* Generate signature header
-        message = f"{request.method}|{request.url.path}|{request_timestamp.isoformat()}|{response_timestamp.isoformat()}|{str(process_time)}"
-        sign_parameters = (
-            MaleoFoundationSignatureParametersTransfers
-            .Sign(key=self._keys.private, password=self._keys.password, message=message)
+        """Add custom headers to response."""
+        # Basic headers
+        response.headers["X-Request-ID"] = str(request_id)
+        response.headers["X-Process-Time"] = str(process_time)
+        response.headers["X-Request-Timestamp"] = request_timestamp.isoformat()
+        response.headers["X-Response-Timestamp"] = response_timestamp.isoformat()
+
+        # Add signature header
+        self._add_signature_header(request, response, request_timestamp, response_timestamp, process_time, request_id)
+
+        # Add new authorization header if needed
+        self._add_new_authorization_header(request, authentication, response)
+
+        return response
+
+    def _add_signature_header(
+        self,
+        request:Request,
+        response:Response,
+        request_timestamp:datetime,
+        response_timestamp:datetime,
+        process_time:float,
+        request_id:UUID
+    ) -> None:
+        """Generate and add signature header."""
+        message = (
+            f"{request.method}|{request.url.path}|{request_timestamp.isoformat()}|"
+            f"{response_timestamp.isoformat()}|{str(process_time)}|{str(request_id)}"
         )
-        sign_result = self._maleo_foundation.services.signature.sign(parameters=sign_parameters)
+
+        sign_parameters = MaleoFoundationSignatureParametersTransfers.Sign(
+            key=self.keys.private,
+            password=self.keys.password,
+            message=message
+        )
+
+        sign_result = self.maleo_foundation.services.signature.sign(parameters=sign_parameters)
         if sign_result.success:
             response.headers["X-Signature"] = sign_result.data.signature
-        if (authentication.user.is_authenticated
+
+    def _add_new_authorization_header(
+        self,
+        request:Request,
+        authentication:Authentication,
+        response:Response
+    ) -> None:
+        """Add new authorization header for refresh tokens."""
+        if not self._should_regenerate_auth(request, authentication, response):
+            return
+
+        payload = MaleoFoundationTokenGeneralTransfers.BaseEncodePayload.model_validate(
+            authentication.credentials.token.payload.model_dump()
+        )
+
+        parameters = MaleoFoundationTokenParametersTransfers.Encode(
+            key=self.keys.private,
+            password=self.keys.password,
+            payload=payload
+        )
+
+        result = self.maleo_foundation.services.token.encode(parameters=parameters)
+        if result.success:
+            response.headers["X-New-Authorization"] = result.data.token
+
+    def _should_regenerate_auth(
+        self,
+        request:Request,
+        authentication:Authentication,
+        response:Response
+    ) -> bool:
+        """Check if authorization should be regenerated."""
+        return (
+            authentication.user.is_authenticated
             and authentication.credentials.token.type == BaseEnums.TokenType.REFRESH
-            and (response.status_code >= 200 and response.status_code < 300)
+            and 200 <= response.status_code < 300
             and "logout" not in request.url.path
-        ):
-            #* Regenerate new authorization
-            payload = (
-                MaleoFoundationTokenGeneralTransfers
-                .BaseEncodePayload
-                .model_validate(authentication.credentials.token.payload.model_dump())
-            )
-            parameters = (
-                MaleoFoundationTokenParametersTransfers
-                .Encode(key=self._keys.private, password=self._keys.password, payload=payload)
-            )
-            result = self._maleo_foundation.services.token.encode(parameters=parameters)
-            if result.success:
-                response.headers["X-New-Authorization"] = result.data.token
-        return response
+        )
+
+
+class RequestLogger:
+    """Handles request/response logging."""
+
+    def __init__(
+        self,
+        logger:MiddlewareLogger
+    ):
+        self.logger = logger
 
-    def _build_response(
+    def log_request_response(
         self,
         request:Request,
         authentication:Authentication,
-        authentication_info:str,
         response:Response,
-        request_timestamp:datetime,
-        response_timestamp:datetime,
-        process_time:int,
-        log_level:str = "info",
-        client_ip:str = "unknown"
-    ) -> Response:
-        response = self._add_response_headers(
-            request,
-            authentication,
-            response,
-            request_timestamp,
-            response_timestamp,
-            process_time
-        )
-        log_func = getattr(self._logger, log_level)
+        client_ip:str,
+        request_id:UUID,
+        log_level:str = "info"
+    ) -> None:
+        """Log request and response details."""
+        authentication_info = self._get_authentication_info(authentication)
+
+        log_func = getattr(self.logger, log_level)
         log_func(
-            f"Request {authentication_info} | IP: {client_ip} | Host: {request.client.host} | Port: {request.client.port} | Method: {request.method} | URL: {request.url.path} | "
+            f"Request | ID: {request_id} {authentication_info} | IP: {client_ip} | "
+            f"Host: {request.client.host} | Port: {request.client.port} | "
+            f"Method: {request.method} | URL: {request.url.path} | "
             f"Headers: {dict(request.headers)} - Response | Status: {response.status_code}"
         )
-        return response
-
-    def _handle_exception(
+    
+    def log_exception(
         self,
         request:Request,
         authentication:Authentication,
-        authentication_info:str,
-        error,
-        request_timestamp:datetime,
-        response_timestamp:datetime,
-        process_time:int,
-        client_ip:str = "unknown"
-    ):
-        traceback_str = traceback.format_exc().split("\n")
+        error:Exception,
+        client_ip:str,
+        request_id:UUID
+    ) -> None:
+        """Log exception details."""
+        authentication_info = self._get_authentication_info(authentication)
+
         error_details = {
+            "request_id": str(request_id),
             "error": str(error),
-            "traceback": traceback_str,
+            "traceback": traceback.format_exc().split("\n"),
             "client_ip": client_ip,
             "method": request.method,
             "url": request.url.path,
             "headers": dict(request.headers),
         }
 
-        response = JSONResponse(
-            content=BaseResponses.ServerError().model_dump(),
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        self.logger.error(
+            f"Request | ID: {request_id} {authentication_info} | IP: {client_ip} | "
+            f"Host: {request.client.host} | Port: {request.client.port} | "
+            f"Method: {request.method} | URL: {request.url.path} | "
+            f"Headers: {dict(request.headers)} - Response | Status: 500 | "
+            f"Exception:\n{json.dumps(error_details, indent=4)}"
         )
 
-        self._logger.error(
-            f"Request {authentication_info} | IP: {client_ip} | Host: {request.client.host} | Port: {request.client.port} | Method: {request.method} | URL: {request.url.path} | "
-            f"Headers: {dict(request.headers)} - Response | Status: 500 | Exception:\n{json.dumps(error_details, indent=4)}"
-        )
+    def _get_authentication_info(self, authentication:Authentication) -> str:
+        """Get authentication info string."""
+        if not authentication.user.is_authenticated:
+            return "| Unauthenticated"
 
-        return self._add_response_headers(
-            request,
-            authentication,
-            response,
-            request_timestamp,
-            response_timestamp,
-            process_time
+        return (
+            f"| Token type: {authentication.credentials.token.type} | "
+            f"Username: {authentication.user.display_name} | "
+            f"Email: {authentication.user.identity}"
         )
 
-    async def _request_processor(self, request:Request) -> Optional[Response]:
-        return None
 
-    async def dispatch(self, request:Request, call_next:RequestResponseEndpoint):
-        self._cleanup_old_data() #* Run periodic cleanup
-        request_timestamp = datetime.now(tz=timezone.utc) #* Record the request timestamp
-        start_time = time.perf_counter() #* Record the start time
-        client_ip = BaseExtractors.extract_client_ip(request) #* Get request IP with improved extraction
-        authentication = Authentication(
-            credentials=request.auth,
-            user=request.user
+class BaseMiddleware(BaseHTTPMiddleware):
+    """Base middleware with rate limiting, logging, and response enhancement."""
+
+    def __init__(
+        self,
+        app:FastAPI,
+        keys:BaseGeneralSchemas.RSAKeys,
+        logger:MiddlewareLogger,
+        maleo_foundation:MaleoFoundationClientManager,
+        allow_origins:Sequence[str] = (),
+        allow_methods:Sequence[str] = ("GET",),
+        allow_headers:Sequence[str] = (),
+        allow_credentials:bool = False,
+        limit:int = 10,
+        window:int = 1,
+        cleanup_interval:int = 60,
+        ip_timeout:int = 300
+    ):
+        super().__init__(app)
+
+        # Core components
+        self.rate_limiter = RateLimiter(
+            limit=limit,
+            window=timedelta(seconds=window),
+            ip_timeout=timedelta(seconds=ip_timeout),
+            cleanup_interval=timedelta(seconds=cleanup_interval)
         )
-        if not authentication.user.is_authenticated:
-            authentication_info = "| Unauthenticated"
-        else:
-            authentication_info = f"| Token type: {authentication.credentials.token.type} | Username: {authentication.user.display_name} | Email:{authentication.user.identity}"
+        self.response_builder = ResponseBuilder(keys, maleo_foundation)
+        self.request_logger = RequestLogger(logger)
+
+        # CORS settings (if needed)
+        self.cors_config = {
+            'allow_origins': allow_origins,
+            'allow_methods': allow_methods,
+            'allow_headers': allow_headers,
+            'allow_credentials': allow_credentials,
+        }
+
+    async def dispatch(self, request:Request, call_next:RequestResponseEndpoint) -> Response:
+        """Main middleware dispatch method."""
+        # Generate unique request ID
+        request_id = uuid4()
+        request.state.request_id = request_id
+
+        # Setup
+        self.rate_limiter.cleanup_old_data(self.request_logger.logger)
+        request_timestamp = datetime.now(tz=timezone.utc)
+        request.state.request_timestamp = request_timestamp
+        start_time = time.perf_counter()
+        client_ip = BaseExtractors.extract_client_ip(request)
+        authentication = Authentication(credentials=request.auth, user=request.user)
 
         try:
-            #* 1. Rate limit check
-            if self._check_rate_limit(client_ip):
-                return self._build_response(
-                    request=request,
-                    authentication=authentication,
-                    authentication_info=authentication_info,
-                    response=JSONResponse(
-                        content=BaseResponses.RateLimitExceeded().model_dump(),
-                        status_code=status.HTTP_429_TOO_MANY_REQUESTS,
-                    ),
-                    request_timestamp=request_timestamp,
-                    response_timestamp=datetime.now(tz=timezone.utc),
-                    process_time=time.perf_counter() - start_time,
-                    log_level="warning",
-                    client_ip=client_ip,
+            # Rate limiting check
+            if self.rate_limiter.is_rate_limited(client_ip):
+                return self._create_rate_limit_response(
+                    request, authentication, client_ip, request_timestamp, start_time, request_id
                 )
 
-            #* 2. Optional preprocessing
+            # Optional preprocessing
             pre_response = await self._request_processor(request)
             if pre_response is not None:
-                return self._build_response(
-                    request=request,
-                    authentication=authentication,
-                    authentication_info=authentication_info,
-                    response=pre_response,
-                    request_timestamp=request_timestamp,
-                    response_timestamp=datetime.now(tz=timezone.utc),
-                    process_time=time.perf_counter() - start_time,
-                    log_level="info",
-                    client_ip=client_ip,
+                return self._build_final_response(
+                    request, authentication, pre_response, client_ip,
+                    request_timestamp, start_time, request_id
                 )
 
-            #* 3. Main handler
+            # Main request processing
             response = await call_next(request)
-            response = self._build_response(
-                request=request,
-                authentication=authentication,
-                authentication_info=authentication_info,
-                response=response,
-                request_timestamp=request_timestamp,
-                response_timestamp=datetime.now(tz=timezone.utc),
-                process_time=time.perf_counter() - start_time,
-                log_level="info",
-                client_ip=client_ip,
+            return self._build_final_response(
+                request, authentication, response, client_ip,
+                request_timestamp, start_time, request_id
             )
 
-            return response
-
         except Exception as e:
             return self._handle_exception(
-                request=request,
-                authentication=authentication,
-                authentication_info=authentication_info,
-                error=e,
-                request_timestamp=request_timestamp,
-                response_timestamp=datetime.now(tz=timezone.utc),
-                process_time=time.perf_counter() - start_time,
-                client_ip=client_ip
+                request, authentication, e, client_ip, request_timestamp, start_time, request_id
             )
 
+    async def _request_processor(self, request:Request) -> Optional[Response]:
+        """Override this method for custom request preprocessing."""
+        return None
+
+    def _create_rate_limit_response(
+        self,
+        request:Request,
+        authentication:Authentication,
+        client_ip:str,
+        request_timestamp:datetime,
+        start_time:float,
+        request_id:UUID
+    ) -> Response:
+        """Create rate limit exceeded response."""
+        response = JSONResponse(
+            content=BaseResponses.RateLimitExceeded().model_dump(),
+            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+        )
+        
+        return self._build_final_response(
+            request, authentication, response, client_ip,
+            request_timestamp, start_time, request_id, log_level="warning"
+        )
+
+    def _build_final_response(
+        self,
+        request:Request,
+        authentication:Authentication,
+        response:Response,
+        client_ip:str,
+        request_timestamp:datetime,
+        start_time:float,
+        request_id:UUID,
+        log_level:str = "info"
+    ) -> Response:
+        """Build final response with headers and logging."""
+        response_timestamp = datetime.now(tz=timezone.utc)
+        process_time = time.perf_counter() - start_time
+        
+        # Add headers
+        response = self.response_builder.add_response_headers(
+            request, authentication, response, request_timestamp, response_timestamp, process_time, request_id
+        )
+
+        # Log request/response
+        self.request_logger.log_request_response(
+            request, authentication, response, client_ip, request_id, log_level
+        )
+
+        return response
+
+    def _handle_exception(
+        self,
+        request:Request,
+        authentication:Authentication,
+        error:Exception,
+        client_ip:str,
+        request_timestamp:datetime,
+        start_time:float,
+        request_id:UUID
+    ) -> Response:
+        """Handle exceptions and create error response."""
+        response_timestamp = datetime.now(tz=timezone.utc)
+        process_time = time.perf_counter() - start_time
+        
+        response = JSONResponse(
+            content=BaseResponses.ServerError().model_dump(),
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        )
+
+        # Log exception
+        self.request_logger.log_exception(request, authentication, error, client_ip, request_id)
+        
+        # Add headers
+        return self.response_builder.add_response_headers(
+            request, authentication, response, request_timestamp, response_timestamp, process_time, request_id
+        )
+
+
 def add_base_middleware(
     app:FastAPI,
     keys:BaseGeneralSchemas.RSAKeys,
@@ -316,39 +445,35 @@ def add_base_middleware(
     ip_timeout:int = 300
 ) -> None:
     """
-    Adds Base middleware to the FastAPI application.
+    Add Base middleware to the FastAPI application.
 
     Args:
-        app: FastAPI
-            The FastAPI application instance to which the middleware will be added.
-
-        logger: Logger
-            The middleware logger to be used.
-
-        limit: int
-            Request count limit in a specific window of time
-
-        window: int
-            Time window for rate limiting (in seconds).
-
-        cleanup_interval: int
-            How often to clean up old IP data (in seconds).
-
-        ip_timeout: int
-            How long to keep an IP in memory after its last activity (in seconds).
-            Default is 300 seconds (5 minutes).
-
-    Returns:
-        None: The function modifies the FastAPI app by adding Base middleware.
-
-    Note:
-        FastAPI applies middleware in reverse order of registration, so this middleware
-        will execute after any middleware added subsequently.
+        app:FastAPI application instance
+        keys:RSA keys for signing and token generation
+        logger:Middleware logger instance
+        maleo_foundation:Client manager for foundation services
+        allow_origins:CORS allowed origins
+        allow_methods:CORS allowed methods
+        allow_headers:CORS allowed headers
+        allow_credentials:CORS allow credentials flag
+        limit:Request count limit per window
+        window:Time window for rate limiting (seconds)
+        cleanup_interval:Cleanup interval for old IP data (seconds)
+        ip_timeout:IP timeout after last activity (seconds)
 
     Example:
-    ```python
-    add_base_middleware(app=app, limit=10, window=1, cleanup_interval=60, ip_timeout=300)
-    ```
+        ```python
+        add_base_middleware(
+            app=app,
+            keys=rsa_keys,
+            logger=middleware_logger,
+            maleo_foundation=client_manager,
+            limit=10,
+            window=1,
+            cleanup_interval=60,
+            ip_timeout=300
+        )
+        ```
     """
     app.add_middleware(
         BaseMiddleware,

{maleo_foundation-0.2.78.dist-info → maleo_foundation-0.2.80.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo_foundation
-Version: 0.2.78
+Version: 0.2.80
 Summary: Foundation package for Maleo
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: MIT

{maleo_foundation-0.2.78.dist-info → maleo_foundation-0.2.80.dist-info}/RECORD

@@ -34,7 +34,7 @@ maleo_foundation/expanded_types/encryption/rsa.py,sha256=Esf_H8nMz2kOLAWa3M7dlD-
 maleo_foundation/managers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maleo_foundation/managers/db.py,sha256=cpY1IOiUytT9XXYtzS0E9OSYOuB7jBKo0XHe__uI1Jg,5340
 maleo_foundation/managers/middleware.py,sha256=77wRCC_CWc22nSDL-UJanO3rXmSB7wLzaAIXEFjXq6M,4249
-maleo_foundation/managers/service.py,sha256=_0eme0NQMsf_8UlLmrLkD9OzHrLbrKjMYUNGYcA0EPI,19179
+maleo_foundation/managers/service.py,sha256=n2ubW5NoeBBju0t0fLSWa0FxeZMLzmoRcimuCIobgzk,19284
 maleo_foundation/managers/cache/__init__.py,sha256=CeY0oof2bVl_v5WS-FKXNwn2gf3xrEMfUsHK9cHo59s,471
 maleo_foundation/managers/cache/base.py,sha256=YyPjde4KTsp2IHV6NdFMysa0ev-1GX1rtX-0jQPuIBU,837
 maleo_foundation/managers/cache/redis.py,sha256=xLa8QfXdNtghs0eBxIqc04H3XTYmxLEzrqJZAFCigvM,1150
@@ -47,7 +47,7 @@ maleo_foundation/managers/client/google/parameter.py,sha256=Lnj7mQgxWQpsQwbmDRK5
 maleo_foundation/managers/client/google/secret.py,sha256=Ski1CHYeA8vjSk2Oc2Pf4CfFrzT_RcA6NEZwza7gM7Y,4464
 maleo_foundation/managers/client/google/storage.py,sha256=Hq79cVreWR2AGwUzpD57NzziZjqxj__TqYIBRy-A9A0,5340
 maleo_foundation/middlewares/authentication.py,sha256=UL6kL65SvqrzemlIDopoO9N1C05eWlYMHVR2tiRsVEA,4821
-maleo_foundation/middlewares/base.py,sha256=fLctfwzfWlGSPFnSiqbV-9wDhlG2SLA1DAs-hXk0diU,14600
+maleo_foundation/middlewares/base.py,sha256=R-N8rxUaPt7_mvK6DI8y8Jal8GfzuD7Yyx3VLp9_tQA,17097
 maleo_foundation/middlewares/cors.py,sha256=9uvBvY2N6Vxa9RP_YtESxcWo6Doi6uS0lzAG9iLY7Uc,2288
 maleo_foundation/models/__init__.py,sha256=AaKehO7c1HyKhoTGRmNHDddSeBXkW-_YNrpOGBu8Ms8,246
 maleo_foundation/models/responses.py,sha256=nE5qThK-WgcYB-9J4wHzJltMA3PLmWbMI-dkxAxAdII,5631
@@ -118,7 +118,7 @@ maleo_foundation/utils/loaders/credential/__init__.py,sha256=qopTKvcMVoTFwyRijeg
 maleo_foundation/utils/loaders/credential/google.py,sha256=HUcuHD4tXHPt0eHInlFYxA_MDrGSOtbenpd0PX156OM,1255
 maleo_foundation/utils/loaders/key/__init__.py,sha256=hVygcC2ImHc_aVrSrOmyedR8tMUZokWUKCKOSh5ctbo,106
 maleo_foundation/utils/loaders/key/rsa.py,sha256=gDhyX6iTFtHiluuhFCozaZ3pOLKU2Y9TlrNMK_GVyGU,3796
-maleo_foundation-0.2.78.dist-info/METADATA,sha256=ClqJ8m73PDVT6xirjl0uPeyFm_r93Lk9Lkm1DyfoLOY,3598
-maleo_foundation-0.2.78.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-maleo_foundation-0.2.78.dist-info/top_level.txt,sha256=_iBos3F_bhEOdjOnzeiEYSrCucasc810xXtLBXI8cQc,17
-maleo_foundation-0.2.78.dist-info/RECORD,,
+maleo_foundation-0.2.80.dist-info/METADATA,sha256=dRNIGvejuDcdeeazla9MoD2p0H1LGUATumhyh2XTB00,3598
+maleo_foundation-0.2.80.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+maleo_foundation-0.2.80.dist-info/top_level.txt,sha256=_iBos3F_bhEOdjOnzeiEYSrCucasc810xXtLBXI8cQc,17
+maleo_foundation-0.2.80.dist-info/RECORD,,