apitally 0.11.2__py3-none-any.whl → 0.12.0__py3-none-any.whl

apitally/__init__.py

@@ -1 +1 @@
-__version__ = "0.11.2"
+__version__ = "0.12.0"

apitally/client/asyncio.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import random
 import time
 from functools import partial
 from typing import Any, Dict, Optional, Tuple
@@ -82,18 +83,21 @@ class ApitallyClient(ApitallyClientBase):
         data = self.get_sync_data()
         self._sync_data_queue.put_nowait((time.time(), data))
 
-        failed_items = []
+        i = 0
         while not self._sync_data_queue.empty():
             timestamp, data = self._sync_data_queue.get_nowait()
             try:
                 if (time_offset := time.time() - timestamp) <= MAX_QUEUE_TIME:
+                    if i > 0:
+                        await asyncio.sleep(random.uniform(0.1, 0.3))
                     data["time_offset"] = time_offset
                     await self._send_sync_data(client, data)
-                self._sync_data_queue.task_done()
+                    i += 1
             except httpx.HTTPError:
-                failed_items.append((timestamp, data))
-        for item in failed_items:
-            self._sync_data_queue.put_nowait(item)
+                self._sync_data_queue.put_nowait((timestamp, data))
+                break
+            finally:
+                self._sync_data_queue.task_done()
 
     @retry(raise_on_giveup=False)
     async def _send_startup_data(self, client: httpx.AsyncClient, data: Dict[str, Any]) -> None:

apitally/client/threading.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import logging
 import queue
+import random
 import time
 from functools import partial
 from threading import Event, Thread
@@ -95,18 +96,21 @@ class ApitallyClient(ApitallyClientBase):
         data = self.get_sync_data()
         self._sync_data_queue.put_nowait((time.time(), data))
 
-        failed_items = []
+        i = 0
         while not self._sync_data_queue.empty():
             timestamp, data = self._sync_data_queue.get_nowait()
             try:
                 if (time_offset := time.time() - timestamp) <= MAX_QUEUE_TIME:
+                    if i > 0:
+                        time.sleep(random.uniform(0.1, 0.3))
                     data["time_offset"] = time_offset
                     self._send_sync_data(session, data)
-                self._sync_data_queue.task_done()
+                    i += 1
             except requests.RequestException:
-                failed_items.append((timestamp, data))
-        for item in failed_items:
-            self._sync_data_queue.put_nowait(item)
+                self._sync_data_queue.put_nowait((timestamp, data))
+                break
+            finally:
+                self._sync_data_queue.task_done()
 
     @retry(raise_on_giveup=False)
     def _send_startup_data(self, session: requests.Session, data: Dict[str, Any]) -> None:

apitally/django.py

@@ -94,7 +94,7 @@ class ApitallyMiddleware:
         response = self.get_response(request)
         response_time = time.perf_counter() - start_time
         path = self.get_path(request)
-        if request.method is not None and path is not None:
+        if request.method is not None and request.method != "OPTIONS" and path is not None:
             try:
                 consumer = self.get_consumer(request)
                 consumer_identifier = consumer.identifier if consumer else None

apitally/flask.py

@@ -93,7 +93,7 @@ class ApitallyMiddleware:
         response_headers: Headers,
     ) -> None:
         rule, is_handled_path = self.get_rule(environ)
-        if is_handled_path or not self.filter_unhandled_paths:
+        if (is_handled_path or not self.filter_unhandled_paths) and environ["REQUEST_METHOD"] != "OPTIONS":
             consumer = self.get_consumer()
             consumer_identifier = consumer.identifier if consumer else None
             self.client.consumer_registry.add_or_update_consumer(consumer)

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,34 +55,55 @@ 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""
             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
+                if message["type"] == "http.response.start":
+                    response_time = time.perf_counter() - start_time
+                    response_status = message["status"]
+                    response_headers = Headers(scope=message)
+                elif message["type"] == "http.response.body" and response_status == 422:
+                    response_body += message["body"]
+                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,
+                    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,
+                )
         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,
         exception: Optional[BaseException] = None,
     ) -> None:
         path_template, is_handled_path = self.get_path_template(request)
@@ -100,26 +115,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_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 +139,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.2.dist-info → apitally-0.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: apitally
-Version: 0.11.2
+Version: 0.12.0
 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.2.dist-info → apitally-0.12.0.dist-info}/RECORD

@@ -1,19 +1,19 @@
-apitally/__init__.py,sha256=bmMNWd6X6fx5JJd3CqzukH9Aez4xKCZuJNcmMU1pbEc,23
+apitally/__init__.py,sha256=eHjt9DPsMbptabS2yGx9Yhbyzq5hFSUHXb7zc8Q_8-o,23
 apitally/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-apitally/client/asyncio.py,sha256=L8cnh2Pd_abC9Y5dnoH18kPHjcQ1n_ngmJJu7yU1G2Q,4774
+apitally/client/asyncio.py,sha256=Y5sbRLRnJCIJx9VQ2DGgQsYNKGvURV2U1y3VxHuPhgQ,4874
 apitally/client/base.py,sha256=v4LSOYNIOoeL3KTVyBlXBY5LCXc79Lvu9yK5Y_KILSQ,15442
 apitally/client/logging.py,sha256=QMsKIIAFo92PNBUleeTgsrsQa7SEal-oJa1oOHUr1wI,507
-apitally/client/threading.py,sha256=NhKgA8b9F1Sa0BdnTCcyVyWKI6vy9shGF9umG70kpfc,5113
+apitally/client/threading.py,sha256=cASa0C9nyRp5gf5IzCDj6TE-v8t8SW4zJ38W6NdJ3Q8,5204
 apitally/common.py,sha256=GbVmnXxhRvV30d7CfCQ9r0AeXj14Mv9Jm_Yd1bRWP28,1088
-apitally/django.py,sha256=vqBloQH4WaxvIlVpDZoazPcj5ljFapi1kvUHRgkd0O4,13763
+apitally/django.py,sha256=Zw8a971UwGKaEMPUtmlBbjufAYwMkSjRSQlss8FDY-E,13795
 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=KZxWN1xeXUazYYluu3aoKkZQ_aRljHmtjZi1AxvzpGw,6402
+apitally/flask.py,sha256=7TJIoAT91-bR_7gZkL0clDk-Whl-V21hbo4nASaDmB4,6447
 apitally/litestar.py,sha256=sQcrHw-JV9AlpnXlrczmaDe0k6tD9PYQsc8nyQul8Ko,8802
 apitally/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-apitally/starlette.py,sha256=tizWLlKMltKU1w3pUqa4EHfY3wjneUVZyvndmgl82c4,8747
-apitally-0.11.2.dist-info/LICENSE,sha256=vbLzC-4TddtXX-_AFEBKMYWRlxC_MN0g66QhPxo8PgY,1065
-apitally-0.11.2.dist-info/METADATA,sha256=enN-rzxB2Ooc8jFKhJrksz4cxrRH39f_43TkpW3ksrQ,6994
-apitally-0.11.2.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
-apitally-0.11.2.dist-info/RECORD,,
+apitally/starlette.py,sha256=PA_0BTy9aVtrY2_QrWU7Js5vjW1uxZ476rmg95fXq2g,8881
+apitally-0.12.0.dist-info/LICENSE,sha256=vbLzC-4TddtXX-_AFEBKMYWRlxC_MN0g66QhPxo8PgY,1065
+apitally-0.12.0.dist-info/METADATA,sha256=gGryZ9u9sLV8mYrcoRhvYK4lQ4bFf9vhbvrCENA6T-I,6994
+apitally-0.12.0.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
+apitally-0.12.0.dist-info/RECORD,,