apitally 0.16.1__tar.gz → 0.16.2__tar.gz

{apitally-0.16.1 → apitally-0.16.2}/.github/workflows/tests.yaml

@@ -48,10 +48,7 @@ jobs:
       matrix:
         python: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13"]
         deps:
-          - starlette
           - fastapi starlette
-          - fastapi==0.109.0 starlette
-          - fastapi==0.100.1 starlette
           - fastapi==0.88.0 starlette
           - flask
           - flask==2.3.*
@@ -61,14 +58,10 @@ jobs:
           - djangorestframework==3.12.* django==3.2.* uritemplate
           - djangorestframework==3.10.* django==2.2.* uritemplate
           - django-ninja django
-          - django-ninja==0.22.* django
           - django-ninja==0.18.0 django
           - litestar
-          - litestar==2.6.1
-          - litestar==2.3.0
           - litestar==2.0.1
           - blacksheep
-          - blacksheep==2.2.0
           - blacksheep==2.1.0
         exclude:
           - python: "3.8"

{apitally-0.16.1 → apitally-0.16.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apitally
-Version: 0.16.1
+Version: 0.16.2
 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.16.1 → apitally-0.16.2}/apitally/client/client_asyncio.py

@@ -41,7 +41,6 @@ class ApitallyClient(ApitallyClientBase):
         self._stop_sync_loop = False
         self._sync_loop_task: Optional[asyncio.Task] = None
         self._sync_data_queue: asyncio.Queue[Dict[str, Any]] = asyncio.Queue()
-        self._set_startup_data_task: Optional[asyncio.Task] = None
 
     def get_http_client(self) -> httpx.AsyncClient:
         if httpx.__version__ >= "0.26.0":
@@ -67,7 +66,7 @@ class ApitallyClient(ApitallyClientBase):
                 try:
                     async with self.get_http_client() as client:
                         tasks = [self.send_sync_data(client), self.send_log_data(client)]
-                        if not self._startup_data_sent and last_sync_time > 0:  # not on first sync
+                        if not self._startup_data_sent:
                             tasks.append(self.send_startup_data(client))
                         await asyncio.gather(*tasks)
                     last_sync_time = now
@@ -92,11 +91,6 @@ class ApitallyClient(ApitallyClientBase):
     def set_startup_data(self, data: Dict[str, Any]) -> None:
         self._startup_data_sent = False
         self._startup_data = self.add_uuids_to_data(data)
-        self._set_startup_data_task = asyncio.create_task(self._set_startup_data())
-
-    async def _set_startup_data(self) -> None:
-        async with self.get_http_client() as client:
-            await self.send_startup_data(client)
 
     async def send_startup_data(self, client: httpx.AsyncClient) -> None:
         if self._startup_data is not None:

{apitally-0.16.1 → apitally-0.16.2}/apitally/client/client_threading.py

@@ -80,7 +80,7 @@ class ApitallyClient(ApitallyClientBase):
                 if (now - last_sync_time) >= self.sync_interval:
                     try:
                         with requests.Session() as session:
-                            if not self._startup_data_sent and last_sync_time > 0:  # not on first sync
+                            if not self._startup_data_sent:
                                 self.send_startup_data(session)
                             self.send_sync_data(session)
                             self.send_log_data(session)
@@ -105,8 +105,6 @@ class ApitallyClient(ApitallyClientBase):
     def set_startup_data(self, data: Dict[str, Any]) -> None:
         self._startup_data_sent = False
         self._startup_data = self.add_uuids_to_data(data)
-        with requests.Session() as session:
-            self.send_startup_data(session)
 
     def send_startup_data(self, session: requests.Session) -> None:
         if self._startup_data is not None:

{apitally-0.16.1 → apitally-0.16.2}/apitally/starlette.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import asyncio
 import time
 from typing import Any, Callable, Dict, List, Optional, Union
 from warnings import warn
@@ -40,6 +39,8 @@ class ApitallyMiddleware:
         proxy: Optional[Union[str, Proxy]] = None,
     ) -> None:
         self.app = app
+        self.app_version = app_version
+        self.openapi_url = openapi_url
         self.identify_consumer_callback = identify_consumer_callback
         self.client = ApitallyClient(
             client_id=client_id,
@@ -47,10 +48,6 @@ class ApitallyMiddleware:
             request_logging_config=request_logging_config,
             proxy=proxy,
         )
-        self.client.start_sync_loop()
-        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)
 
         self.capture_request_body = (
             self.client.request_logger.config.enabled and self.client.request_logger.config.log_request_body
@@ -59,17 +56,13 @@ class ApitallyMiddleware:
             self.client.request_logger.config.enabled and self.client.request_logger.config.log_response_body
         )
 
-    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(
-            self._delayed_set_startup_data(app_version, openapi_url)
-        )
+        _register_event_handler(app, "startup", self.on_startup)
+        _register_event_handler(app, "shutdown", self.client.handle_shutdown)
 
-    async def _delayed_set_startup_data(
-        self, app_version: Optional[str] = None, openapi_url: Optional[str] = None
-    ) -> None:
-        await asyncio.sleep(1.0)  # Short delay to allow app routes to be registered first
-        data = _get_startup_data(self.app, app_version, openapi_url)
+    def on_startup(self) -> None:
+        data = _get_startup_data(self.app, app_version=self.app_version, openapi_url=self.openapi_url)
         self.client.set_startup_data(data)
+        self.client.start_sync_loop()
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
         if self.client.enabled and scope["type"] == "http" and scope["method"] != "OPTIONS":
@@ -296,8 +289,8 @@ def _get_routes(app: Union[ASGIApp, Router]) -> List[BaseRoute]:
     return []  # pragma: no cover
 
 
-def _register_shutdown_handler(app: Union[ASGIApp, Router], shutdown_handler: Callable[[], Any]) -> None:
+def _register_event_handler(app: Union[ASGIApp, Router], event: str, handler: Callable[[], Any]) -> None:
     if isinstance(app, Router):
-        app.add_event_handler("shutdown", shutdown_handler)
+        app.add_event_handler(event, handler)
     elif hasattr(app, "app"):
-        _register_shutdown_handler(app.app, shutdown_handler)
+        _register_event_handler(app.app, event, handler)

{apitally-0.16.1 → apitally-0.16.2}/tests/test_client_asyncio.py

@@ -156,13 +156,14 @@ async def test_send_log_data(client: ApitallyClient, httpx_mock: HTTPXMock):
     assert len(client.request_logger.file_deque) == 0
 
 
-async def test_set_startup_data(client: ApitallyClient, httpx_mock: HTTPXMock):
+async def test_send_startup_data(client: ApitallyClient, httpx_mock: HTTPXMock):
     from apitally.client.client_base import HUB_BASE_URL, HUB_VERSION
 
     httpx_mock.add_response()
     data = {"paths": [], "client_version": "1.0.0", "starlette_version": "0.28.0", "python_version": "3.11.4"}
     client.set_startup_data(data)
-    await asyncio.sleep(0.01)
+    async with client.get_http_client() as http_client:
+        await client.send_startup_data(client=http_client)
 
     request = httpx_mock.get_request(url=f"{HUB_BASE_URL}/{HUB_VERSION}/{CLIENT_ID}/{ENV}/startup")
     assert request is not None

{apitally-0.16.1 → apitally-0.16.2}/tests/test_client_threading.py

@@ -141,12 +141,14 @@ def test_send_log_data(client: ApitallyClient, requests_mock: Mocker):
     assert len(client.request_logger.file_deque) == 0
 
 
-def test_set_startup_data(client: ApitallyClient, requests_mock: Mocker):
+def test_send_startup_data(client: ApitallyClient, requests_mock: Mocker):
     from apitally.client.client_base import HUB_BASE_URL, HUB_VERSION
 
     mock = requests_mock.register_uri("POST", f"{HUB_BASE_URL}/{HUB_VERSION}/{CLIENT_ID}/{ENV}/startup")
     data = {"paths": [], "client_version": "1.0.0", "starlette_version": "0.28.0", "python_version": "3.11.4"}
     client.set_startup_data(data)
+    with requests.Session() as session:
+        client.send_startup_data(session)
 
     assert len(mock.request_history) == 1
     request_data = mock.request_history[0].json()

{apitally-0.16.1 → apitally-0.16.2}/tests/test_fastapi.py

@@ -30,8 +30,6 @@ def app(module_mocker: MockerFixture) -> FastAPI:
 
     module_mocker.patch("apitally.client.client_asyncio.ApitallyClient._instance", None)
     module_mocker.patch("apitally.client.client_asyncio.ApitallyClient.start_sync_loop")
-    module_mocker.patch("apitally.client.client_asyncio.ApitallyClient.set_startup_data")
-    module_mocker.patch("apitally.starlette.ApitallyMiddleware.delayed_set_startup_data")
 
     def identify_consumer(request: Request) -> Optional[str]:
         if consumer := request.query_params.get("consumer"):

{apitally-0.16.1 → apitally-0.16.2}/tests/test_litestar.py

@@ -37,7 +37,6 @@ async def app(module_mocker: MockerFixture) -> Litestar:
 
     module_mocker.patch("apitally.client.client_asyncio.ApitallyClient._instance", None)
     module_mocker.patch("apitally.client.client_asyncio.ApitallyClient.start_sync_loop")
-    module_mocker.patch("apitally.client.client_asyncio.ApitallyClient.set_startup_data")
     module_mocker.patch("apitally.client.client_asyncio.ApitallyClient.handle_shutdown", mocked_handle_shutdown)
 
     @get("/foo")

{apitally-0.16.1 → apitally-0.16.2}/tests/test_starlette.py

@@ -28,8 +28,6 @@ if TYPE_CHECKING:
 async def app(request: FixtureRequest, module_mocker: MockerFixture) -> Starlette:
     module_mocker.patch("apitally.client.client_asyncio.ApitallyClient._instance", None)
     module_mocker.patch("apitally.client.client_asyncio.ApitallyClient.start_sync_loop")
-    module_mocker.patch("apitally.client.client_asyncio.ApitallyClient.set_startup_data")
-    module_mocker.patch("apitally.starlette.ApitallyMiddleware.delayed_set_startup_data")
     if request.param == "starlette":
         return get_starlette_app()
     elif request.param == "fastapi":

{apitally-0.16.1 → apitally-0.16.2}/apitally/django.py

@@ -75,13 +75,13 @@ class ApitallyMiddleware:
             request_logging_config=self.config.request_logging_config,
             proxy=self.config.proxy,
         )
-        self.client.start_sync_loop()
         self.client.set_startup_data(
             _get_startup_data(
                 app_version=self.config.app_version,
                 urlconfs=self.config.urlconfs,
             )
         )
+        self.client.start_sync_loop()
 
         self.capture_request_body = (
             self.client.request_logger.config.enabled and self.client.request_logger.config.log_request_body

{apitally-0.16.1 → apitally-0.16.2}/apitally/flask.py

@@ -51,7 +51,6 @@ class ApitallyMiddleware:
             request_logging_config=request_logging_config,
             proxy=proxy,
         )
-        self.client.start_sync_loop()
         self.delayed_set_startup_data(app_version, openapi_url)
 
         self.capture_request_body = (
@@ -73,6 +72,7 @@ class ApitallyMiddleware:
     def _delayed_set_startup_data(self, app_version: Optional[str] = None, openapi_url: Optional[str] = None) -> None:
         data = _get_startup_data(self.app, app_version, openapi_url)
         self.client.set_startup_data(data)
+        self.client.start_sync_loop()
 
     def __call__(self, environ: WSGIEnvironment, start_response: StartResponse) -> Iterable[bytes]:
         if not self.client.enabled: