apitally 0.19.1__py3-none-any.whl → 0.20.1__py3-none-any.whl

apitally/blacksheep.py

@@ -1,5 +1,6 @@
 import time
 from typing import Any, Awaitable, Callable, Dict, List, Optional, Tuple, Union
+from warnings import warn
 
 from blacksheep import Application, Headers, Request, Response
 from blacksheep.server.openapi.v3 import Info, OpenAPIHandler, Operation
@@ -12,21 +13,51 @@ from apitally.client.request_logging import (
     MAX_BODY_SIZE,
     RequestLogger,
     RequestLoggingConfig,
+    RequestLoggingKwargs,
 )
 from apitally.common import get_versions, parse_int
 
 
-__all__ = ["use_apitally", "ApitallyMiddleware", "ApitallyConsumer", "RequestLoggingConfig"]
+try:
+    from typing import Unpack
+except ImportError:
+    from typing_extensions import Unpack
+
+
+__all__ = ["use_apitally", "ApitallyConsumer", "RequestLoggingConfig"]
 
 
 def use_apitally(
     app: Application,
     client_id: str,
     env: str = "dev",
-    request_logging_config: Optional[RequestLoggingConfig] = None,
     app_version: Optional[str] = None,
+    consumer_callback: Optional[Callable[[Request], Union[str, ApitallyConsumer, None]]] = None,
     identify_consumer_callback: Optional[Callable[[Request], Union[str, ApitallyConsumer, None]]] = None,
+    request_logging_config: Optional[RequestLoggingConfig] = None,
+    **kwargs: Unpack[RequestLoggingKwargs],
 ) -> None:
+    """
+    Use the Apitally middleware for BlackSheep applications.
+
+    For more information, see:
+    - Setup guide: https://docs.apitally.io/frameworks/blacksheep
+    - Reference: https://docs.apitally.io/reference/python
+    """
+
+    if identify_consumer_callback is not None:
+        warn(
+            "The 'identify_consumer_callback' parameter is deprecated, use 'consumer_callback' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+    if request_logging_config is not None:
+        warn(
+            "The 'request_logging_config' parameter is deprecated, use keyword arguments instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
     original_get_match = app.router.get_match
 
     def _wrapped_router_get_match(request: Request) -> Optional[RouteMatch]:
@@ -37,13 +68,16 @@ def use_apitally(
 
     app.router.get_match = _wrapped_router_get_match  # type: ignore[assignment,method-assign]
 
+    if kwargs and request_logging_config is None:
+        request_logging_config = RequestLoggingConfig.from_kwargs(kwargs)
+
     middleware = ApitallyMiddleware(
         app,
         client_id,
         env=env,
         request_logging_config=request_logging_config,
         app_version=app_version,
-        identify_consumer_callback=identify_consumer_callback,
+        consumer_callback=consumer_callback or identify_consumer_callback,
     )
     app.middlewares.append(middleware)
 
@@ -56,11 +90,11 @@ class ApitallyMiddleware:
         env: str = "dev",
         request_logging_config: Optional[RequestLoggingConfig] = None,
         app_version: Optional[str] = None,
-        identify_consumer_callback: Optional[Callable[[Request], Union[str, ApitallyConsumer, None]]] = None,
+        consumer_callback: Optional[Callable[[Request], Union[str, ApitallyConsumer, None]]] = None,
     ) -> None:
         self.app = app
         self.app_version = app_version
-        self.identify_consumer_callback = identify_consumer_callback
+        self.consumer_callback = consumer_callback
         self.client = ApitallyClient(
             client_id=client_id,
             env=env,
@@ -88,13 +122,13 @@ class ApitallyMiddleware:
         identity = request.user or request.identity or None
         if identity is not None and identity.has_claim("apitally_consumer"):
             return ApitallyConsumer.from_string_or_object(identity.get("apitally_consumer"))
-        if self.identify_consumer_callback is not None:
-            consumer = self.identify_consumer_callback(request)
+        if self.consumer_callback is not None:
+            consumer = self.consumer_callback(request)
             return ApitallyConsumer.from_string_or_object(consumer)
         return None
 
     async def __call__(self, request: Request, handler: Callable[[Request], Awaitable[Response]]) -> Response:
-        if not self.client.enabled:
+        if not self.client.enabled or request.method.upper() == "OPTIONS":
             return await handler(request)
 
         timestamp = time.time()
@@ -154,7 +188,7 @@ class ApitallyMiddleware:
                         if response_size is None or response_size < 0:
                             response_size = len(response_body)
 
-            if route_pattern and request.method.upper() != "OPTIONS":
+            if route_pattern:
                 self.client.request_counter.add_request(
                     consumer=consumer_identifier,
                     method=request.method.upper(),
@@ -217,7 +251,7 @@ def _get_startup_data(app: Application, app_version: Optional[str] = None) -> Di
 def _get_paths(app: Application) -> List[Dict[str, str]]:
     openapi = OpenAPIHandler(info=Info(title="", version=""))
     paths = []
-    methods = ("get", "put", "post", "delete", "options", "head", "patch", "trace")
+    methods = ("get", "put", "post", "delete", "patch")
     for path, path_item in openapi.get_paths(app).items():
         for method in methods:
             operation: Operation = getattr(path_item, method, None)

apitally/client/request_logging.py

@@ -118,28 +118,25 @@ class RequestLogItem(TypedDict):
     exception: NotRequired[ExceptionDict]
 
 
+class RequestLoggingKwargs(TypedDict, total=False):
+    enable_request_logging: bool
+    log_query_params: bool
+    log_request_headers: bool
+    log_request_body: bool
+    log_response_headers: bool
+    log_response_body: bool
+    log_exception: bool
+    mask_query_params: List[str]
+    mask_headers: List[str]
+    mask_body_fields: List[str]
+    mask_request_body_callback: Optional[Callable[[RequestDict], Optional[bytes]]]
+    mask_response_body_callback: Optional[Callable[[RequestDict, ResponseDict], Optional[bytes]]]
+    exclude_paths: List[str]
+    exclude_callback: Optional[Callable[[RequestDict, ResponseDict], bool]]
+
+
 @dataclass
 class RequestLoggingConfig:
-    """
-    Configuration for request logging.
-
-    Attributes:
-        enabled: Whether request logging is enabled
-        log_query_params: Whether to log query parameter values
-        log_request_headers: Whether to log request header values
-        log_request_body: Whether to log the request body (only if JSON or plain text)
-        log_response_headers: Whether to log response header values
-        log_response_body: Whether to log the response body (only if JSON or plain text)
-        log_exception: Whether to log unhandled exceptions in case of server errors
-        mask_query_params: Query parameter names to mask in logs. Expects regular expressions.
-        mask_headers: Header names to mask in logs. Expects regular expressions.
-        mask_body_fields: Body fields to mask in logs. Expects regular expressions.
-        mask_request_body_callback: Callback to mask the request body. Expects `request: RequestDict` as argument and returns the masked body as bytes or None.
-        mask_response_body_callback: Callback to mask the response body. Expects `request: RequestDict` and `response: ResponseDict` as arguments and returns the masked body as bytes or None.
-        exclude_paths: Paths to exclude from logging. Expects regular expressions.
-        exclude_callback: Callback to exclude requests from logging. Should expect two arguments, `request: RequestDict` and `response: ResponseDict`, and return True to exclude the request.
-    """
-
     enabled: bool = False
     log_query_params: bool = True
     log_request_headers: bool = False
@@ -155,6 +152,12 @@ class RequestLoggingConfig:
     exclude_paths: List[str] = field(default_factory=list)
     exclude_callback: Optional[Callable[[RequestDict, ResponseDict], bool]] = None
 
+    @classmethod
+    def from_kwargs(cls, kwargs: RequestLoggingKwargs) -> "RequestLoggingConfig":
+        enabled = kwargs.get("enable_request_logging", False)
+        config_kwargs: dict[str, Any] = {k: v for k, v in kwargs.items() if k in cls.__dataclass_fields__}
+        return RequestLoggingConfig(enabled=enabled, **config_kwargs)
+
 
 class TempGzipFile:
     def __init__(self) -> None:

apitally/django.py

@@ -23,16 +23,23 @@ from apitally.client.request_logging import (
     MAX_BODY_SIZE,
     RequestLogger,
     RequestLoggingConfig,
+    RequestLoggingKwargs,
 )
 from apitally.common import get_versions, parse_int, try_json_loads
 
 
+try:
+    from typing import Unpack
+except ImportError:
+    from typing_extensions import Unpack
+
 if TYPE_CHECKING:
     from django.http import HttpRequest, HttpResponse
     from ninja import NinjaAPI
 
 
 __all__ = ["ApitallyMiddleware", "ApitallyConsumer", "RequestLoggingConfig"]
+
 logger = get_logger(__name__)
 
 
@@ -40,9 +47,9 @@ logger = get_logger(__name__)
 class ApitallyMiddlewareConfig:
     client_id: str
     env: str
-    request_logging_config: Optional[RequestLoggingConfig]
     app_version: Optional[str]
-    identify_consumer_callback: Optional[Callable[[HttpRequest], Union[str, ApitallyConsumer, None]]]
+    request_logging_config: Optional[RequestLoggingConfig]
+    consumer_callback: Optional[Callable[[HttpRequest], Union[str, ApitallyConsumer, None]]]
     include_django_views: bool
     urlconfs: List[Optional[str]]
     proxy: Optional[str]
@@ -102,21 +109,39 @@ class ApitallyMiddleware:
         cls,
         client_id: str,
         env: str = "dev",
-        request_logging_config: Optional[RequestLoggingConfig] = None,
         app_version: Optional[str] = None,
-        identify_consumer_callback: Optional[str] = None,
+        consumer_callback: Optional[str] = None,
         include_django_views: bool = False,
         urlconf: Optional[Union[List[Optional[str]], str]] = None,
         proxy: Optional[str] = None,
+        identify_consumer_callback: Optional[str] = None,
+        request_logging_config: Optional[RequestLoggingConfig] = None,
+        **kwargs: Unpack[RequestLoggingKwargs],
     ) -> None:
+        if identify_consumer_callback is not None:
+            warn(
+                "The 'identify_consumer_callback' setting is deprecated, use 'consumer_callback' instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        if request_logging_config is not None:
+            warn(
+                "The nested 'request_logging_config' setting is deprecated, use top-level settings instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
+        if identify_consumer_callback and not consumer_callback:
+            consumer_callback = identify_consumer_callback
+        if kwargs and request_logging_config is None:
+            request_logging_config = RequestLoggingConfig.from_kwargs(kwargs)
+
         cls.config = ApitallyMiddlewareConfig(
             client_id=client_id,
             env=env,
             request_logging_config=request_logging_config,
             app_version=app_version,
-            identify_consumer_callback=import_string(identify_consumer_callback)
-            if identify_consumer_callback
-            else None,
+            consumer_callback=import_string(consumer_callback) if consumer_callback else None,
             include_django_views=include_django_views,
             urlconfs=[urlconf] if urlconf is None or isinstance(urlconf, str) else urlconf,
             proxy=proxy,
@@ -270,8 +295,8 @@ class ApitallyMiddleware:
                 DeprecationWarning,
             )
             return ApitallyConsumer.from_string_or_object(request.consumer_identifier)
-        if self.config is not None and self.config.identify_consumer_callback is not None:
-            consumer = self.config.identify_consumer_callback(request)
+        if self.config is not None and self.config.consumer_callback is not None:
+            consumer = self.config.consumer_callback(request)
             return ApitallyConsumer.from_string_or_object(consumer)
         return None
 

apitally/fastapi.py

@@ -1,4 +1,17 @@
-from apitally.starlette import ApitallyConsumer, ApitallyMiddleware, RequestLoggingConfig, set_consumer
+from apitally.starlette import ApitallyConsumer, RequestLoggingConfig, set_consumer
+from apitally.starlette import ApitallyMiddleware as _ApitallyMiddlewareForStarlette
 
 
 __all__ = ["ApitallyMiddleware", "ApitallyConsumer", "RequestLoggingConfig", "set_consumer"]
+
+
+class ApitallyMiddleware(_ApitallyMiddlewareForStarlette):
+    """
+    Apitally middleware for FastAPI applications.
+
+    For more information, see:
+    - Setup guide: https://docs.apitally.io/frameworks/fastapi
+    - Reference: https://docs.apitally.io/reference/python
+    """
+
+    pass

apitally/flask.py

@@ -19,10 +19,17 @@ from apitally.client.request_logging import (
     MAX_BODY_SIZE,
     RequestLogger,
     RequestLoggingConfig,
+    RequestLoggingKwargs,
 )
 from apitally.common import get_versions
 
 
+try:
+    from typing import Unpack
+except ImportError:
+    from typing_extensions import Unpack
+
+
 if TYPE_CHECKING:
     from _typeshed.wsgi import StartResponse, WSGIApplication, WSGIEnvironment
     from werkzeug.routing.map import Map
@@ -32,19 +39,39 @@ __all__ = ["ApitallyMiddleware", "ApitallyConsumer", "RequestLoggingConfig", "se
 
 
 class ApitallyMiddleware:
+    """
+    Apitally middleware for Flask applications.
+
+    For more information, see:
+    - Setup guide: https://docs.apitally.io/frameworks/flask
+    - Reference: https://docs.apitally.io/reference/python
+    """
+
     def __init__(
         self,
         app: Flask,
         client_id: str,
         env: str = "dev",
-        request_logging_config: Optional[RequestLoggingConfig] = None,
         app_version: Optional[str] = None,
         openapi_url: Optional[str] = None,
         proxy: Optional[str] = None,
+        request_logging_config: Optional[RequestLoggingConfig] = None,
+        **kwargs: Unpack[RequestLoggingKwargs],
     ) -> None:
+        if request_logging_config is not None:
+            warn(
+                "The 'request_logging_config' parameter is deprecated, use keyword arguments instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
         self.app = app
         self.wsgi_app = app.wsgi_app
         self.patch_handle_exception()
+
+        if kwargs and request_logging_config is None:
+            request_logging_config = RequestLoggingConfig.from_kwargs(kwargs)
+
         self.client = ApitallyClient(
             client_id=client_id,
             env=env,
@@ -75,7 +102,7 @@ class ApitallyMiddleware:
         self.client.start_sync_loop()
 
     def __call__(self, environ: WSGIEnvironment, start_response: StartResponse) -> Iterable[bytes]:
-        if not self.client.enabled:
+        if not self.client.enabled or environ.get("REQUEST_METHOD") == "OPTIONS":
             return self.wsgi_app(environ, start_response)
 
         timestamp = time.time()
@@ -153,7 +180,7 @@ class ApitallyMiddleware:
         consumer_identifier = consumer.identifier if consumer else None
         self.client.consumer_registry.add_or_update_consumer(consumer)
 
-        if path is not None and request.method != "OPTIONS":
+        if path is not None:
             self.client.request_counter.add_request(
                 consumer=consumer_identifier,
                 method=request.method,

apitally/litestar.py

@@ -20,10 +20,17 @@ from apitally.client.request_logging import (
     MAX_BODY_SIZE,
     RequestLogger,
     RequestLoggingConfig,
+    RequestLoggingKwargs,
 )
 from apitally.common import get_versions, parse_int, try_json_loads
 
 
+try:
+    from typing import Unpack
+except ImportError:
+    from typing_extensions import Unpack
+
+
 __all__ = ["ApitallyPlugin", "ApitallyConsumer", "RequestLoggingConfig", "set_consumer"]
 
 
@@ -32,21 +39,40 @@ class ApitallyPlugin(InitPluginProtocol):
         self,
         client_id: str,
         env: str = "dev",
-        request_logging_config: Optional[RequestLoggingConfig] = None,
         app_version: Optional[str] = None,
         filter_openapi_paths: bool = True,
-        identify_consumer_callback: Optional[Callable[[Request], Union[str, ApitallyConsumer, None]]] = None,
+        consumer_callback: Optional[Callable[[Request], Union[str, ApitallyConsumer, None]]] = None,
         proxy: Optional[Union[str, Proxy]] = None,
+        identify_consumer_callback: Optional[Callable[[Request], Union[str, ApitallyConsumer, None]]] = None,
+        request_logging_config: Optional[RequestLoggingConfig] = None,
+        **kwargs: Unpack[RequestLoggingKwargs],
     ) -> None:
+        if identify_consumer_callback is not None:
+            warn(
+                "The 'identify_consumer_callback' parameter is deprecated, use 'consumer_callback' instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        if request_logging_config is not None:
+            warn(
+                "The 'request_logging_config' parameter is deprecated, use keyword arguments instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
+        if kwargs and request_logging_config is None:
+            request_logging_config = RequestLoggingConfig.from_kwargs(kwargs)
+
         self.client = ApitallyClient(
             client_id=client_id,
             env=env,
             request_logging_config=request_logging_config,
             proxy=proxy,
         )
+
         self.app_version = app_version
         self.filter_openapi_paths = filter_openapi_paths
-        self.identify_consumer_callback = identify_consumer_callback
+        self.consumer_callback = consumer_callback or identify_consumer_callback
 
         self.openapi_path = "/schema"
         self.capture_request_body = (
@@ -86,9 +112,9 @@ class ApitallyPlugin(InitPluginProtocol):
 
     def middleware_factory(self, app: ASGIApp) -> ASGIApp:
         async def middleware(scope: Scope, receive: Receive, send: Send) -> None:
-            if self.client.enabled and scope["type"] == "http" and scope["method"] != "OPTIONS":
+            if self.client.enabled and scope["type"] == ScopeType.HTTP and scope["method"] != "OPTIONS":
                 timestamp = time.time()
-                request = Request(scope)
+                request: Request = Request(scope)
                 request_size = parse_int(request.headers.get("Content-Length"))
                 request_body = b""
                 request_body_too_large = request_size is not None and request_size > MAX_BODY_SIZE
@@ -102,7 +128,7 @@ class ApitallyPlugin(InitPluginProtocol):
                 response_content_type: Optional[str] = None
                 start_time = time.perf_counter()
 
-                async def receive_wrapper() -> Message:
+                async def receive_wrapper():
                     nonlocal request_body, request_body_too_large
                     message = await receive()
                     if message["type"] == "http.request" and self.capture_request_body and not request_body_too_large:
@@ -112,7 +138,7 @@ class ApitallyPlugin(InitPluginProtocol):
                             request_body = b""
                     return message
 
-                async def send_wrapper(message: Message) -> None:
+                async def send_wrapper(message: Message):
                     nonlocal \
                         response_time, \
                         response_status, \
@@ -281,8 +307,8 @@ class ApitallyPlugin(InitPluginProtocol):
                 DeprecationWarning,
             )
             return ApitallyConsumer.from_string_or_object(request.state.consumer_identifier)
-        if self.identify_consumer_callback is not None:
-            consumer = self.identify_consumer_callback(request)
+        if self.consumer_callback is not None:
+            consumer = self.consumer_callback(request)
             return ApitallyConsumer.from_string_or_object(consumer)
         return None
 
@@ -301,5 +327,5 @@ def _get_routes(app: Litestar) -> List[Dict[str, str]]:
         {"method": method, "path": route.path}
         for route in app.routes
         for method in route.methods
-        if route.scope_type == ScopeType.HTTP and method != "OPTIONS"
+        if route.scope_type == ScopeType.HTTP and method not in ["OPTIONS", "HEAD"]
     ]

apitally/starlette.py

@@ -21,31 +21,65 @@ from apitally.client.request_logging import (
     MAX_BODY_SIZE,
     RequestLogger,
     RequestLoggingConfig,
+    RequestLoggingKwargs,
 )
 from apitally.common import get_versions, parse_int, try_json_loads
 
 
+try:
+    from typing import Unpack
+except ImportError:
+    from typing_extensions import Unpack
+
+
 __all__ = ["ApitallyMiddleware", "ApitallyConsumer", "RequestLoggingConfig", "set_consumer"]
 
 
 class ApitallyMiddleware:
+    """
+    Apitally middleware for Starlette applications.
+
+    For more information, see:
+    - Setup guide: https://docs.apitally.io/frameworks/starlette
+    - Reference: https://docs.apitally.io/reference/python
+    """
+
     def __init__(
         self,
         app: ASGIApp,
         client_id: str,
         env: str = "dev",
-        request_logging_config: Optional[RequestLoggingConfig] = None,
         app_version: Optional[str] = None,
         openapi_url: Optional[str] = "/openapi.json",
-        identify_consumer_callback: Optional[Callable[[Request], Union[str, ApitallyConsumer, None]]] = None,
+        consumer_callback: Optional[Callable[[Request], Union[str, ApitallyConsumer, None]]] = None,
         capture_client_disconnects: bool = False,
         proxy: Optional[Union[str, Proxy]] = None,
+        identify_consumer_callback: Optional[Callable[[Request], Union[str, ApitallyConsumer, None]]] = None,
+        request_logging_config: Optional[RequestLoggingConfig] = None,
+        **kwargs: Unpack[RequestLoggingKwargs],
     ) -> None:
+        if identify_consumer_callback is not None:
+            warn(
+                "The 'identify_consumer_callback' parameter is deprecated, use 'consumer_callback' instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        if request_logging_config is not None:
+            warn(
+                "The 'request_logging_config' parameter is deprecated, use keyword arguments instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
         self.app = app
         self.app_version = app_version
         self.openapi_url = openapi_url
-        self.identify_consumer_callback = identify_consumer_callback
+        self.consumer_callback = consumer_callback or identify_consumer_callback
         self.capture_client_disconnects = capture_client_disconnects
+
+        if kwargs and request_logging_config is None:
+            request_logging_config = RequestLoggingConfig.from_kwargs(kwargs)
+
         self.client = ApitallyClient(
             client_id=client_id,
             env=env,
@@ -262,8 +296,8 @@ class ApitallyMiddleware:
                 DeprecationWarning,
             )
             return ApitallyConsumer.from_string_or_object(request.state.consumer_identifier)
-        if self.identify_consumer_callback is not None:
-            consumer = self.identify_consumer_callback(request)
+        if self.consumer_callback is not None:
+            consumer = self.consumer_callback(request)
             return ApitallyConsumer.from_string_or_object(consumer)
         return None
 

{apitally-0.19.1.dist-info → apitally-0.20.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apitally
-Version: 0.19.1
+Version: 0.20.1
 Summary: Simple API monitoring & analytics for REST APIs built with FastAPI, Flask, Django, Starlette, Litestar and BlackSheep.
 Project-URL: Homepage, https://apitally.io
 Project-URL: Documentation, https://docs.apitally.io

{apitally-0.19.1.dist-info → apitally-0.20.1.dist-info}/RECORD

@@ -1,26 +1,26 @@
 apitally/__init__.py,sha256=ShXQBVjyiSOHxoQJS2BvNG395W4KZfqMxZWBAR0MZrE,22
-apitally/blacksheep.py,sha256=KvcPFeiwQgWZmRglbm8SLaN6_WRs5kZ3SymB1IuLR-A,9616
+apitally/blacksheep.py,sha256=jAkK20OcmV--_Y-RsXDIApRj8bX2eKf_u7ClDtAPvBc,10644
 apitally/common.py,sha256=azDxepViH0QW0MuufTHxeSQyLGzCkocAX_KPziWTx8A,1605
-apitally/django.py,sha256=7eSh1tzuu0wRl9PxJgXMBSz9DfyohCDIqd4ecQTOJ1M,18499
+apitally/django.py,sha256=hU3m1wf5E1qWAHsNjyZG1FEGcbsw3Tud8Vku0218C1Q,19412
 apitally/django_ninja.py,sha256=-CmrwFFRv7thFOUK_OrOSouhHL9bm5sIBNIQlpyE_2c,166
 apitally/django_rest_framework.py,sha256=-CmrwFFRv7thFOUK_OrOSouhHL9bm5sIBNIQlpyE_2c,166
-apitally/fastapi.py,sha256=813dGFl2eOSSYOYwuubFQYvpRikV3shu7bLR2TlwUC8,199
-apitally/flask.py,sha256=sqcsVmbfqpVSN409xDF8DeGOSNkWHI4SoyTFxNfWJ4w,9819
-apitally/litestar.py,sha256=fmcWNmvGvrjGG6J_q5lqB_qJpTk6PXFK9jam6bTWU8U,13678
+apitally/fastapi.py,sha256=uLAftbIHUmZSCc3ZPpNblIFS9Se5lUhNyj3-nqFKuVU,555
+apitally/flask.py,sha256=5sN6YvOqpfjTY8CPRw6FChfTp2-ax0lvHryQrbNeiSU,10606
+apitally/litestar.py,sha256=-01nxP4ZM29vAXJCtqxmn4BucEHhXRwi84z_i0TZPbs,14600
 apitally/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-apitally/starlette.py,sha256=PnEwplG7i0qJpfEWKdJxGCIioLFp4kQfa-5Y6NWGSSg,14105
+apitally/starlette.py,sha256=r3jVy-JEdc572BatOkHTCItY8jfj-AEFNYtpiAX6WfU,15240
 apitally/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 apitally/client/client_asyncio.py,sha256=rTsH5wlLHK3RmyIuEiT6vzjquU-l2OPC34JnC2U6uYw,6658
 apitally/client/client_base.py,sha256=DvivGeHd3dyOASRvkIo44Zh8RzdBMfH8_rROa2lFbgw,3799
 apitally/client/client_threading.py,sha256=sxMRcxRgk1SxJjSq-qpIcDVmD3Q7Kv4CVT5zEUVt0KM,7257
 apitally/client/consumers.py,sha256=w_AFQhVgdtJVt7pVySBvSZwQg-2JVqmD2JQtVBoMkus,2626
 apitally/client/logging.py,sha256=QMsKIIAFo92PNBUleeTgsrsQa7SEal-oJa1oOHUr1wI,507
-apitally/client/request_logging.py,sha256=yCF_CH8isp3gpQRVgakk6DNV60mtPZWG6z45pUNACOM,17644
+apitally/client/request_logging.py,sha256=pzE0kUwGHe5pZ7mwPDSzKu6pnY-NYsNEKpjqB2C9gC4,17147
 apitally/client/requests.py,sha256=SDptGOg9XvaEKFj2o3oxJz-JAuZzUrqpHnbOQixf99o,3794
 apitally/client/sentry.py,sha256=dXW2zf-wexYSp4CJBsFFRKz9jWkPBy0ftqIk0o5Hkq8,1364
 apitally/client/server_errors.py,sha256=4B2BKDFoIpoWc55UVH6AIdYSgzj6zxCdMNUW77JjhZw,3423
 apitally/client/validation_errors.py,sha256=6G8WYWFgJs9VH9swvkPXJGuOJgymj5ooWA9OwjUTbuM,1964
-apitally-0.19.1.dist-info/METADATA,sha256=QE1kA2cHRaEPmxm3feYkfbeowkZMGnuAu5plkvfXDz0,9316
-apitally-0.19.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-apitally-0.19.1.dist-info/licenses/LICENSE,sha256=vbLzC-4TddtXX-_AFEBKMYWRlxC_MN0g66QhPxo8PgY,1065
-apitally-0.19.1.dist-info/RECORD,,
+apitally-0.20.1.dist-info/METADATA,sha256=HeXviknfeo_NLF27Xz1pi_oYRpW12mAr4HeQUbrE0wo,9316
+apitally-0.20.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+apitally-0.20.1.dist-info/licenses/LICENSE,sha256=vbLzC-4TddtXX-_AFEBKMYWRlxC_MN0g66QhPxo8PgY,1065
+apitally-0.20.1.dist-info/RECORD,,