apitally 0.11.3__py3-none-any.whl → 0.12.1__py3-none-any.whl

apitally/__init__.py

@@ -1 +1 @@
-__version__ = "0.11.3"
+__version__ = "0.12.1"

apitally/litestar.py

@@ -72,16 +72,31 @@ class ApitallyPlugin(InitPluginProtocol):
                 response_time = 0.0
                 response_headers = Headers()
                 response_body = b""
+                response_size = 0
+                response_chunked = False
                 start_time = time.perf_counter()
 
                 async def send_wrapper(message: Message) -> None:
-                    nonlocal response_time, response_status, response_headers, response_body
+                    nonlocal \
+                        response_time, \
+                        response_status, \
+                        response_headers, \
+                        response_body, \
+                        response_size, \
+                        response_chunked
                     if message["type"] == "http.response.start":
                         response_time = time.perf_counter() - start_time
                         response_status = message["status"]
                         response_headers = Headers(message["headers"])
-                    elif message["type"] == "http.response.body" and response_status == 400:
-                        response_body += message["body"]
+                        response_chunked = (
+                            response_headers.get("Transfer-Encoding") == "chunked"
+                            or "Content-Length" not in response_headers
+                        )
+                    elif message["type"] == "http.response.body":
+                        if response_chunked:
+                            response_size += len(message.get("body", b""))
+                        if response_status == 400:
+                            response_body += message.get("body", b"")
                     await send(message)
 
                 await app(scope, receive, send_wrapper)
@@ -91,6 +106,7 @@ class ApitallyPlugin(InitPluginProtocol):
                     response_time=response_time,
                     response_headers=response_headers,
                     response_body=response_body,
+                    response_size=response_size,
                 )
             else:
                 await app(scope, receive, send)  # pragma: no cover
@@ -104,6 +120,7 @@ class ApitallyPlugin(InitPluginProtocol):
         response_time: float,
         response_headers: Headers,
         response_body: bytes,
+        response_size: int = 0,
     ) -> None:
         if response_status < 100 or not request.route_handler.paths:
             return  # pragma: no cover
@@ -120,7 +137,7 @@ class ApitallyPlugin(InitPluginProtocol):
             status_code=response_status,
             response_time=response_time,
             request_size=request.headers.get("Content-Length"),
-            response_size=response_headers.get("Content-Length"),
+            response_size=response_size or response_headers.get("Content-Length"),
         )
         if response_status == 400 and response_body and len(response_body) < 4096:
             with contextlib.suppress(json.JSONDecodeError):

apitally/starlette.py

@@ -1,35 +1,29 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import json
 import time
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 from warnings import warn
 
 from httpx import HTTPStatusError
-from starlette.concurrency import iterate_in_threadpool
-from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.datastructures import Headers
+from starlette.requests import Request
 from starlette.routing import BaseRoute, Match, Router
 from starlette.schemas import EndpointInfo, SchemaGenerator
-from starlette.status import HTTP_500_INTERNAL_SERVER_ERROR
 from starlette.testclient import TestClient
-from starlette.types import ASGIApp
+from starlette.types import ASGIApp, Message, Receive, Scope, Send
 
 from apitally.client.asyncio import ApitallyClient
 from apitally.client.base import Consumer as ApitallyConsumer
 from apitally.common import get_versions
 
 
-if TYPE_CHECKING:
-    from starlette.middleware.base import RequestResponseEndpoint
-    from starlette.requests import Request
-    from starlette.responses import Response
-
-
 __all__ = ["ApitallyMiddleware", "ApitallyConsumer"]
 
 
-class ApitallyMiddleware(BaseHTTPMiddleware):
+class ApitallyMiddleware:
     def __init__(
         self,
         app: ASGIApp,
@@ -40,6 +34,7 @@ class ApitallyMiddleware(BaseHTTPMiddleware):
         filter_unhandled_paths: bool = True,
         identify_consumer_callback: Optional[Callable[[Request], Union[str, ApitallyConsumer, None]]] = None,
     ) -> None:
+        self.app = app
         self.filter_unhandled_paths = filter_unhandled_paths
         self.identify_consumer_callback = identify_consumer_callback
         self.client = ApitallyClient(client_id=client_id, env=env)
@@ -47,7 +42,6 @@ class ApitallyMiddleware(BaseHTTPMiddleware):
         self._delayed_set_startup_data_task: Optional[asyncio.Task] = None
         self.delayed_set_startup_data(app_version, openapi_url)
         _register_shutdown_handler(app, self.client.handle_shutdown)
-        super().__init__(app)
 
     def delayed_set_startup_data(self, app_version: Optional[str] = None, openapi_url: Optional[str] = None) -> None:
         self._delayed_set_startup_data_task = asyncio.create_task(
@@ -61,38 +55,77 @@ class ApitallyMiddleware(BaseHTTPMiddleware):
         data = _get_startup_data(self.app, app_version, openapi_url)
         self.client.set_startup_data(data)
 
-    async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:
-        try:
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] == "http" and scope["method"] != "OPTIONS":
+            request = Request(scope)
+            response_status = 0
+            response_time = 0.0
+            response_headers = Headers()
+            response_body = b""
+            response_size = 0
+            response_chunked = False
             start_time = time.perf_counter()
-            response = await call_next(request)
-        except BaseException as e:
-            await self.add_request(
-                request=request,
-                response=None,
-                status_code=HTTP_500_INTERNAL_SERVER_ERROR,
-                response_time=time.perf_counter() - start_time,
-                exception=e,
-            )
-            raise e from None
+
+            async def send_wrapper(message: Message) -> None:
+                nonlocal \
+                    response_time, \
+                    response_status, \
+                    response_headers, \
+                    response_body, \
+                    response_size, \
+                    response_chunked
+                if message["type"] == "http.response.start":
+                    response_time = time.perf_counter() - start_time
+                    response_status = message["status"]
+                    response_headers = Headers(scope=message)
+                    response_chunked = (
+                        response_headers.get("Transfer-Encoding") == "chunked"
+                        or "Content-Length" not in response_headers
+                    )
+                elif message["type"] == "http.response.body":
+                    if response_chunked:
+                        response_size += len(message.get("body", b""))
+                    if response_status == 422:
+                        response_body += message.get("body", b"")
+                await send(message)
+
+            try:
+                await self.app(scope, receive, send_wrapper)
+            except BaseException as e:
+                self.add_request(
+                    request=request,
+                    response_status=500,
+                    response_time=time.perf_counter() - start_time,
+                    response_headers=response_headers,
+                    response_body=response_body,
+                    response_size=response_size,
+                    exception=e,
+                )
+                raise e from None
+            else:
+                self.add_request(
+                    request=request,
+                    response_status=response_status,
+                    response_time=response_time,
+                    response_headers=response_headers,
+                    response_body=response_body,
+                    response_size=response_size,
+                )
         else:
-            await self.add_request(
-                request=request,
-                response=response,
-                status_code=response.status_code,
-                response_time=time.perf_counter() - start_time,
-            )
-        return response
+            await self.app(scope, receive, send)  # pragma: no cover
 
-    async def add_request(
+    def add_request(
         self,
         request: Request,
-        response: Optional[Response],
-        status_code: int,
+        response_status: int,
         response_time: float,
+        response_headers: Headers,
+        response_body: bytes,
+        response_size: int = 0,
         exception: Optional[BaseException] = None,
     ) -> None:
         path_template, is_handled_path = self.get_path_template(request)
-        if (is_handled_path or not self.filter_unhandled_paths) and request.method != "OPTIONS":
+        if is_handled_path or not self.filter_unhandled_paths:
             consumer = self.get_consumer(request)
             consumer_identifier = consumer.identifier if consumer else None
             self.client.consumer_registry.add_or_update_consumer(consumer)
@@ -100,26 +133,23 @@ class ApitallyMiddleware(BaseHTTPMiddleware):
                 consumer=consumer_identifier,
                 method=request.method,
                 path=path_template,
-                status_code=status_code,
+                status_code=response_status,
                 response_time=response_time,
                 request_size=request.headers.get("Content-Length"),
-                response_size=response.headers.get("Content-Length") if response is not None else None,
+                response_size=response_size or response_headers.get("Content-Length"),
             )
-            if (
-                status_code == 422
-                and response is not None
-                and response.headers.get("Content-Type") == "application/json"
-            ):
-                body = await self.get_response_json(response)
-                if isinstance(body, dict) and "detail" in body and isinstance(body["detail"], list):
-                    # Log FastAPI / Pydantic validation errors
-                    self.client.validation_error_counter.add_validation_errors(
-                        consumer=consumer_identifier,
-                        method=request.method,
-                        path=path_template,
-                        detail=body["detail"],
-                    )
-            if status_code == 500 and exception is not None:
+            if response_status == 422 and response_body and response_headers.get("Content-Type") == "application/json":
+                with contextlib.suppress(json.JSONDecodeError):
+                    body = json.loads(response_body)
+                    if isinstance(body, dict) and "detail" in body and isinstance(body["detail"], list):
+                        # Log FastAPI / Pydantic validation errors
+                        self.client.validation_error_counter.add_validation_errors(
+                            consumer=consumer_identifier,
+                            method=request.method,
+                            path=path_template,
+                            detail=body["detail"],
+                        )
+            if response_status == 500 and exception is not None:
                 self.client.server_error_counter.add_server_error(
                     consumer=consumer_identifier,
                     method=request.method,
@@ -127,21 +157,6 @@ class ApitallyMiddleware(BaseHTTPMiddleware):
                     exception=exception,
                 )
 
-    @staticmethod
-    async def get_response_json(response: Response) -> Any:
-        if hasattr(response, "body"):
-            try:
-                return json.loads(response.body)
-            except json.JSONDecodeError:  # pragma: no cover
-                return None
-        elif hasattr(response, "body_iterator"):
-            try:
-                response_body = [section async for section in response.body_iterator]
-                response.body_iterator = iterate_in_threadpool(iter(response_body))
-                return json.loads(b"".join(response_body))
-            except json.JSONDecodeError:  # pragma: no cover
-                return None
-
     @staticmethod
     def get_path_template(request: Request) -> Tuple[str, bool]:
         for route in request.app.routes:

{apitally-0.11.3.dist-info → apitally-0.12.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: apitally
-Version: 0.11.3
+Version: 0.12.1
 Summary: Simple API monitoring & analytics for REST APIs built with FastAPI, Flask, Django, Starlette and Litestar.
 Home-page: https://apitally.io
 License: MIT

{apitally-0.11.3.dist-info → apitally-0.12.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-apitally/__init__.py,sha256=tCUnamQN48_YKI84dtjiVJI4cF4gypc8nKdvXAnhY_E,23
+apitally/__init__.py,sha256=PAuBI8I6F9Yu_86XjI2yaWn8QmCd9ZvK7tkZLWvEg-Q,23
 apitally/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 apitally/client/asyncio.py,sha256=Y5sbRLRnJCIJx9VQ2DGgQsYNKGvURV2U1y3VxHuPhgQ,4874
 apitally/client/base.py,sha256=v4LSOYNIOoeL3KTVyBlXBY5LCXc79Lvu9yK5Y_KILSQ,15442
@@ -10,10 +10,10 @@ apitally/django_ninja.py,sha256=dqQtnz2s8YWYHCwvkK5BjokjvpZJpPNhP0vng4kFtrQ,120
 apitally/django_rest_framework.py,sha256=dqQtnz2s8YWYHCwvkK5BjokjvpZJpPNhP0vng4kFtrQ,120
 apitally/fastapi.py,sha256=hEyYZsvIaA3OXZSSFdey5iqeEjfBPHgfNbyX8pLm7GI,123
 apitally/flask.py,sha256=7TJIoAT91-bR_7gZkL0clDk-Whl-V21hbo4nASaDmB4,6447
-apitally/litestar.py,sha256=sQcrHw-JV9AlpnXlrczmaDe0k6tD9PYQsc8nyQul8Ko,8802
+apitally/litestar.py,sha256=O9bSzwJC-dN6ukRqyVNYBhUqxEpzie-bR2bFojcvvMI,9547
 apitally/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-apitally/starlette.py,sha256=HvphuX401h_ccqvOk2RKu7GGEai2WbGOjJ-WOE7-fWM,8781
-apitally-0.11.3.dist-info/LICENSE,sha256=vbLzC-4TddtXX-_AFEBKMYWRlxC_MN0g66QhPxo8PgY,1065
-apitally-0.11.3.dist-info/METADATA,sha256=oIrHGgHHvCpqj7LzkhpvT3nbMiTChIkPK5pPGBwH8C8,6994
-apitally-0.11.3.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
-apitally-0.11.3.dist-info/RECORD,,
+apitally/starlette.py,sha256=qmdcAlypqACd4yL_B_5W0ykpkWJaf1YcCAW1yDxaS0c,9615
+apitally-0.12.1.dist-info/LICENSE,sha256=vbLzC-4TddtXX-_AFEBKMYWRlxC_MN0g66QhPxo8PgY,1065
+apitally-0.12.1.dist-info/METADATA,sha256=Fibm2KONAkF7Omu-bpxBWvzvhRbjYdtcN9I7h1oVMbg,6994
+apitally-0.12.1.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
+apitally-0.12.1.dist-info/RECORD,,