apitally 0.10.1__py3-none-any.whl → 0.11.0__py3-none-any.whl

apitally/__init__.py

@@ -1 +1 @@
-__version__ = "0.10.1"
+__version__ = "0.11.0"

apitally/client/asyncio.py

@@ -29,7 +29,7 @@ class ApitallyClient(ApitallyClientBase):
         super().__init__(client_id=client_id, env=env)
         self._stop_sync_loop = False
         self._sync_loop_task: Optional[asyncio.Task[Any]] = None
-        self._requests_data_queue: asyncio.Queue[Tuple[float, Dict[str, Any]]] = asyncio.Queue()
+        self._sync_data_queue: asyncio.Queue[Tuple[float, Dict[str, Any]]] = asyncio.Queue()
 
     def get_http_client(self) -> httpx.AsyncClient:
         return httpx.AsyncClient(base_url=self.hub_url, timeout=REQUEST_TIMEOUT)
@@ -44,14 +44,14 @@ class ApitallyClient(ApitallyClientBase):
             try:
                 time_start = time.perf_counter()
                 async with self.get_http_client() as client:
-                    tasks = [self.send_requests_data(client)]
-                    if not self._app_info_sent and not first_iteration:
-                        tasks.append(self.send_app_info(client))
+                    tasks = [self.send_sync_data(client)]
+                    if not self._startup_data_sent and not first_iteration:
+                        tasks.append(self.send_startup_data(client))
                     await asyncio.gather(*tasks)
                 time_elapsed = time.perf_counter() - time_start
                 await asyncio.sleep(self.sync_interval - time_elapsed)
-            except Exception as e:  # pragma: no cover
-                logger.exception(e)
+            except Exception:  # pragma: no cover
+                logger.exception("An error occurred during sync with Apitally hub")
             first_iteration = False
 
     def stop_sync_loop(self) -> None:
@@ -60,57 +60,59 @@ class ApitallyClient(ApitallyClientBase):
     async def handle_shutdown(self) -> None:
         if self._sync_loop_task is not None:
             self._sync_loop_task.cancel()
-        # Send any remaining requests data before exiting
+        # Send any remaining data before exiting
         async with self.get_http_client() as client:
-            await self.send_requests_data(client)
+            await self.send_sync_data(client)
 
-    def set_app_info(self, app_info: Dict[str, Any]) -> None:
-        self._app_info_sent = False
-        self._app_info_payload = self.get_info_payload(app_info)
-        asyncio.create_task(self._set_app_info_task())
+    def set_startup_data(self, data: Dict[str, Any]) -> None:
+        self._startup_data_sent = False
+        self._startup_data = self.add_uuids_to_data(data)
+        asyncio.create_task(self._set_startup_data_task())
 
-    async def _set_app_info_task(self) -> None:
+    async def _set_startup_data_task(self) -> None:
         async with self.get_http_client() as client:
-            await self.send_app_info(client)
+            await self.send_startup_data(client)
 
-    async def send_app_info(self, client: httpx.AsyncClient) -> None:
-        if self._app_info_payload is not None:
-            await self._send_app_info(client, self._app_info_payload)
+    async def send_startup_data(self, client: httpx.AsyncClient) -> None:
+        if self._startup_data is not None:
+            await self._send_startup_data(client, self._startup_data)
 
-    async def send_requests_data(self, client: httpx.AsyncClient) -> None:
-        payload = self.get_requests_payload()
-        self._requests_data_queue.put_nowait((time.time(), payload))
+    async def send_sync_data(self, client: httpx.AsyncClient) -> None:
+        data = self.get_sync_data()
+        self._sync_data_queue.put_nowait((time.time(), data))
 
         failed_items = []
-        while not self._requests_data_queue.empty():
-            payload_time, payload = self._requests_data_queue.get_nowait()
+        while not self._sync_data_queue.empty():
+            timestamp, data = self._sync_data_queue.get_nowait()
             try:
-                if (time_offset := time.time() - payload_time) <= MAX_QUEUE_TIME:
-                    payload["time_offset"] = time_offset
-                    await self._send_requests_data(client, payload)
-                self._requests_data_queue.task_done()
+                if (time_offset := time.time() - timestamp) <= MAX_QUEUE_TIME:
+                    data["time_offset"] = time_offset
+                    await self._send_sync_data(client, data)
+                self._sync_data_queue.task_done()
             except httpx.HTTPError:
-                failed_items.append((payload_time, payload))
+                failed_items.append((timestamp, data))
         for item in failed_items:
-            self._requests_data_queue.put_nowait(item)
+            self._sync_data_queue.put_nowait(item)
 
     @retry(raise_on_giveup=False)
-    async def _send_app_info(self, client: httpx.AsyncClient, payload: Dict[str, Any]) -> None:
-        logger.debug("Sending app info")
-        response = await client.post(url="/info", json=payload, timeout=REQUEST_TIMEOUT)
+    async def _send_startup_data(self, client: httpx.AsyncClient, data: Dict[str, Any]) -> None:
+        logger.debug("Sending startup data to Apitally hub")
+        response = await client.post(url="/startup", json=data, timeout=REQUEST_TIMEOUT)
         self._handle_hub_response(response)
-        self._app_info_sent = True
-        self._app_info_payload = None
+        self._startup_data_sent = True
+        self._startup_data = None
 
     @retry()
-    async def _send_requests_data(self, client: httpx.AsyncClient, payload: Dict[str, Any]) -> None:
-        logger.debug("Sending requests data")
-        response = await client.post(url="/requests", json=payload)
+    async def _send_sync_data(self, client: httpx.AsyncClient, data: Dict[str, Any]) -> None:
+        logger.debug("Synchronizing data with Apitally hub")
+        response = await client.post(url="/sync", json=data)
         self._handle_hub_response(response)
 
     def _handle_hub_response(self, response: httpx.Response) -> None:
         if response.status_code == 404:
             self.stop_sync_loop()
-            logger.error(f"Invalid Apitally client ID {self.client_id}")
+            logger.error("Invalid Apitally client ID: %s", self.client_id)
+        elif response.status_code == 422:
+            logger.error("Received validation error from Apitally hub: %s", response.json())
         else:
             response.raise_for_status()

apitally/client/base.py

@@ -11,7 +11,7 @@ from abc import ABC
 from collections import Counter
 from dataclasses import dataclass
 from math import floor
-from typing import Any, Dict, List, Optional, Tuple, Type, TypeVar, cast
+from typing import Any, Dict, List, Optional, Set, Tuple, Type, TypeVar, Union, cast
 from uuid import UUID, uuid4
 
 from apitally.client.logging import get_logger
@@ -20,7 +20,7 @@ from apitally.client.logging import get_logger
 logger = get_logger(__name__)
 
 HUB_BASE_URL = os.getenv("APITALLY_HUB_BASE_URL") or "https://hub.apitally.io"
-HUB_VERSION = "v1"
+HUB_VERSION = "v2"
 REQUEST_TIMEOUT = 10
 MAX_QUEUE_TIME = 3600
 SYNC_INTERVAL = 60
@@ -59,9 +59,10 @@ class ApitallyClientBase(ABC):
         self.request_counter = RequestCounter()
         self.validation_error_counter = ValidationErrorCounter()
         self.server_error_counter = ServerErrorCounter()
+        self.consumer_registry = ConsumerRegistry()
 
-        self._app_info_payload: Optional[Dict[str, Any]] = None
-        self._app_info_sent = False
+        self._startup_data: Optional[Dict[str, Any]] = None
+        self._startup_data_sent = False
         self._started_at = time.time()
 
     @classmethod
@@ -80,25 +81,22 @@ class ApitallyClientBase(ABC):
     def hub_url(self) -> str:
         return f"{HUB_BASE_URL}/{HUB_VERSION}/{self.client_id}/{self.env}"
 
-    def get_info_payload(self, app_info: Dict[str, Any]) -> Dict[str, Any]:
-        payload = {
+    def add_uuids_to_data(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        data_with_uuids = {
             "instance_uuid": self.instance_uuid,
             "message_uuid": str(uuid4()),
         }
-        payload.update(app_info)
-        return payload
-
-    def get_requests_payload(self) -> Dict[str, Any]:
-        requests = self.request_counter.get_and_reset_requests()
-        validation_errors = self.validation_error_counter.get_and_reset_validation_errors()
-        server_errors = self.server_error_counter.get_and_reset_server_errors()
-        return {
-            "instance_uuid": self.instance_uuid,
-            "message_uuid": str(uuid4()),
-            "requests": requests,
-            "validation_errors": validation_errors,
-            "server_errors": server_errors,
+        data_with_uuids.update(data)
+        return data_with_uuids
+
+    def get_sync_data(self) -> Dict[str, Any]:
+        data = {
+            "requests": self.request_counter.get_and_reset_requests(),
+            "validation_errors": self.validation_error_counter.get_and_reset_validation_errors(),
+            "server_errors": self.server_error_counter.get_and_reset_server_errors(),
+            "consumers": self.consumer_registry.get_and_reset_updated_consumers(),
         }
+        return self.add_uuids_to_data(data)
 
 
 @dataclass(frozen=True)
@@ -334,3 +332,65 @@ class ServerErrorCounter:
             lines.append(line)
             length += len(line)
         return "".join(lines[::-1]).strip()
+
+
+class Consumer:
+    def __init__(self, identifier: str, name: Optional[str] = None, group: Optional[str] = None) -> None:
+        self.identifier = str(identifier).strip()[:128]
+        self.name = str(name).strip()[:64] if name else None
+        self.group = str(group).strip()[:64] if group else None
+
+    @classmethod
+    def from_string_or_object(cls, consumer: Optional[Union[str, Consumer]]) -> Optional[Consumer]:
+        if not consumer:
+            return None
+        if isinstance(consumer, Consumer):
+            return consumer
+        consumer = str(consumer).strip()
+        if not consumer:
+            return None
+        return cls(identifier=consumer)
+
+    def update(self, name: str | None = None, group: str | None = None) -> bool:
+        name = str(name).strip()[:64] if name else None
+        group = str(group).strip()[:64] if group else None
+        updated = False
+        if name and name != self.name:
+            self.name = name
+            updated = True
+        if group and group != self.group:
+            self.group = group
+            updated = True
+        return updated
+
+
+class ConsumerRegistry:
+    def __init__(self) -> None:
+        self.consumers: Dict[str, Consumer] = {}
+        self.updated: Set[str] = set()
+        self._lock = threading.Lock()
+
+    def add_or_update_consumer(self, consumer: Optional[Consumer]) -> None:
+        if not consumer or (not consumer.name and not consumer.group):
+            return  # Only register consumers with name or group set
+        with self._lock:
+            if consumer.identifier not in self.consumers:
+                self.consumers[consumer.identifier] = consumer
+                self.updated.add(consumer.identifier)
+            elif self.consumers[consumer.identifier].update(name=consumer.name, group=consumer.group):
+                self.updated.add(consumer.identifier)
+
+    def get_and_reset_updated_consumers(self) -> List[Dict[str, Any]]:
+        data: List[Dict[str, Any]] = []
+        with self._lock:
+            for identifier in self.updated:
+                if consumer := self.consumers.get(identifier):
+                    data.append(
+                        {
+                            "identifier": consumer.identifier,
+                            "name": str(consumer.name)[:64] if consumer.name else None,
+                            "group": str(consumer.group)[:64] if consumer.group else None,
+                        }
+                    )
+            self.updated.clear()
+        return data

apitally/client/threading.py

@@ -46,7 +46,7 @@ class ApitallyClient(ApitallyClientBase):
         super().__init__(client_id=client_id, env=env)
         self._thread: Optional[Thread] = None
         self._stop_sync_loop = Event()
-        self._requests_data_queue: queue.Queue[Tuple[float, Dict[str, Any]]] = queue.Queue()
+        self._sync_data_queue: queue.Queue[Tuple[float, Dict[str, Any]]] = queue.Queue()
 
     def start_sync_loop(self) -> None:
         self._stop_sync_loop.clear()
@@ -63,17 +63,17 @@ class ApitallyClient(ApitallyClientBase):
                     now = time.time()
                     if (now - last_sync_time) >= self.sync_interval:
                         with requests.Session() as session:
-                            if not self._app_info_sent and last_sync_time > 0:  # not on first sync
-                                self.send_app_info(session)
-                            self.send_requests_data(session)
+                            if not self._startup_data_sent and last_sync_time > 0:  # not on first sync
+                                self.send_startup_data(session)
+                            self.send_sync_data(session)
                         last_sync_time = now
                     time.sleep(1)
-                except Exception as e:  # pragma: no cover
-                    logger.exception(e)
+                except Exception:  # pragma: no cover
+                    logger.exception("An error occurred during sync with Apitally hub")
         finally:
-            # Send any remaining requests data before exiting
+            # Send any remaining data before exiting
             with requests.Session() as session:
-                self.send_requests_data(session)
+                self.send_sync_data(session)
 
     def stop_sync_loop(self) -> None:
         self._stop_sync_loop.set()
@@ -81,50 +81,52 @@ class ApitallyClient(ApitallyClientBase):
             self._thread.join()
             self._thread = None
 
-    def set_app_info(self, app_info: Dict[str, Any]) -> None:
-        self._app_info_sent = False
-        self._app_info_payload = self.get_info_payload(app_info)
+    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_app_info(session)
+            self.send_startup_data(session)
 
-    def send_app_info(self, session: requests.Session) -> None:
-        if self._app_info_payload is not None:
-            self._send_app_info(session, self._app_info_payload)
+    def send_startup_data(self, session: requests.Session) -> None:
+        if self._startup_data is not None:
+            self._send_startup_data(session, self._startup_data)
 
-    def send_requests_data(self, session: requests.Session) -> None:
-        payload = self.get_requests_payload()
-        self._requests_data_queue.put_nowait((time.time(), payload))
+    def send_sync_data(self, session: requests.Session) -> None:
+        data = self.get_sync_data()
+        self._sync_data_queue.put_nowait((time.time(), data))
 
         failed_items = []
-        while not self._requests_data_queue.empty():
-            payload_time, payload = self._requests_data_queue.get_nowait()
+        while not self._sync_data_queue.empty():
+            timestamp, data = self._sync_data_queue.get_nowait()
             try:
-                if (time_offset := time.time() - payload_time) <= MAX_QUEUE_TIME:
-                    payload["time_offset"] = time_offset
-                    self._send_requests_data(session, payload)
-                self._requests_data_queue.task_done()
+                if (time_offset := time.time() - timestamp) <= MAX_QUEUE_TIME:
+                    data["time_offset"] = time_offset
+                    self._send_sync_data(session, data)
+                self._sync_data_queue.task_done()
             except requests.RequestException:
-                failed_items.append((payload_time, payload))
+                failed_items.append((timestamp, data))
         for item in failed_items:
-            self._requests_data_queue.put_nowait(item)
+            self._sync_data_queue.put_nowait(item)
 
     @retry(raise_on_giveup=False)
-    def _send_app_info(self, session: requests.Session, payload: Dict[str, Any]) -> None:
-        logger.debug("Sending app info")
-        response = session.post(url=f"{self.hub_url}/info", json=payload, timeout=REQUEST_TIMEOUT)
+    def _send_startup_data(self, session: requests.Session, data: Dict[str, Any]) -> None:
+        logger.debug("Sending startup data to Apitally hub")
+        response = session.post(url=f"{self.hub_url}/startup", json=data, timeout=REQUEST_TIMEOUT)
         self._handle_hub_response(response)
-        self._app_info_sent = True
-        self._app_info_payload = None
+        self._startup_data_sent = True
+        self._startup_data = None
 
     @retry()
-    def _send_requests_data(self, session: requests.Session, payload: Dict[str, Any]) -> None:
-        logger.debug("Sending requests data")
-        response = session.post(url=f"{self.hub_url}/requests", json=payload, timeout=REQUEST_TIMEOUT)
+    def _send_sync_data(self, session: requests.Session, data: Dict[str, Any]) -> None:
+        logger.debug("Synchronizing data with Apitally hub")
+        response = session.post(url=f"{self.hub_url}/sync", json=data, timeout=REQUEST_TIMEOUT)
         self._handle_hub_response(response)
 
     def _handle_hub_response(self, response: requests.Response) -> None:
         if response.status_code == 404:
             self.stop_sync_loop()
-            logger.error(f"Invalid Apitally client ID {self.client_id}")
+            logger.error("Invalid Apitally client ID: %s", self.client_id)
+        elif response.status_code == 422:
+            logger.error("Received validation error from Apitally hub: %s", response.json())
         else:
             response.raise_for_status()

apitally/django.py

@@ -7,11 +7,13 @@ import time
 from dataclasses import dataclass
 from importlib import import_module
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Set, Union
+from warnings import warn
 
 from django.conf import settings
 from django.urls import URLPattern, URLResolver, get_resolver
 from django.utils.module_loading import import_string
 
+from apitally.client.base import Consumer as ApitallyConsumer
 from apitally.client.logging import get_logger
 from apitally.client.threading import ApitallyClient
 from apitally.common import get_versions
@@ -22,7 +24,7 @@ if TYPE_CHECKING:
     from ninja import NinjaAPI
 
 
-__all__ = ["ApitallyMiddleware"]
+__all__ = ["ApitallyMiddleware", "ApitallyConsumer"]
 logger = get_logger(__name__)
 
 
@@ -31,7 +33,7 @@ class ApitallyMiddlewareConfig:
     client_id: str
     env: str
     app_version: Optional[str]
-    identify_consumer_callback: Optional[Callable[[HttpRequest], Optional[str]]]
+    identify_consumer_callback: Optional[Callable[[HttpRequest], Union[str, ApitallyConsumer, None]]]
     urlconfs: List[Optional[str]]
 
 
@@ -61,8 +63,8 @@ class ApitallyMiddleware:
 
         self.client = ApitallyClient(client_id=self.config.client_id, env=self.config.env)
         self.client.start_sync_loop()
-        self.client.set_app_info(
-            app_info=_get_app_info(
+        self.client.set_startup_data(
+            _get_startup_data(
                 app_version=self.config.app_version,
                 urlconfs=self.config.urlconfs,
             )
@@ -93,10 +95,16 @@ class ApitallyMiddleware:
         response_time = time.perf_counter() - start_time
         path = self.get_path(request)
         if request.method is not None and path is not None:
-            consumer = self.get_consumer(request)
+            try:
+                consumer = self.get_consumer(request)
+                consumer_identifier = consumer.identifier if consumer else None
+                self.client.consumer_registry.add_or_update_consumer(consumer)
+            except Exception:  # pragma: no cover
+                logger.exception("Failed to get consumer for request")
+                consumer_identifier = None
             try:
                 self.client.request_counter.add_request(
-                    consumer=consumer,
+                    consumer=consumer_identifier,
                     method=request.method,
                     path=path,
                     status_code=response.status_code,
@@ -119,7 +127,7 @@ class ApitallyMiddleware:
                         if isinstance(body, dict) and "detail" in body and isinstance(body["detail"], list):
                             # Log Django Ninja / Pydantic validation errors
                             self.client.validation_error_counter.add_validation_errors(
-                                consumer=consumer,
+                                consumer=consumer_identifier,
                                 method=request.method,
                                 path=path,
                                 detail=body["detail"],
@@ -129,7 +137,7 @@ class ApitallyMiddleware:
             if response.status_code == 500 and hasattr(request, "unhandled_exception"):
                 try:
                     self.client.server_error_counter.add_server_error(
-                        consumer=consumer,
+                        consumer=consumer_identifier,
                         method=request.method,
                         path=path,
                         exception=getattr(request, "unhandled_exception"),
@@ -162,35 +170,37 @@ class ApitallyMiddleware:
                 logger.exception("Failed to get path for request")
         return None
 
-    def get_consumer(self, request: HttpRequest) -> Optional[str]:
-        try:
-            if hasattr(request, "apitally_consumer"):
-                return str(request.apitally_consumer)
-            if hasattr(request, "consumer_identifier"):  # Keeping this for legacy support
-                return str(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 consumer is not None:
-                    return str(consumer)
-        except Exception:  # pragma: no cover
-            logger.exception("Failed to get consumer identifier for request")
+    def get_consumer(self, request: HttpRequest) -> Optional[ApitallyConsumer]:
+        if hasattr(request, "apitally_consumer") and request.apitally_consumer:
+            return ApitallyConsumer.from_string_or_object(request.apitally_consumer)
+        if hasattr(request, "consumer_identifier") and request.consumer_identifier:
+            # Keeping this for legacy support
+            warn(
+                "Providing a consumer identifier via `request.consumer_identifier` is deprecated, "
+                "use `request.apitally_consumer` instead.",
+                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)
+            return ApitallyConsumer.from_string_or_object(consumer)
         return None
 
 
-def _get_app_info(app_version: Optional[str], urlconfs: List[Optional[str]]) -> Dict[str, Any]:
-    app_info: Dict[str, Any] = {}
+def _get_startup_data(app_version: Optional[str], urlconfs: List[Optional[str]]) -> Dict[str, Any]:
+    data: Dict[str, Any] = {}
     try:
-        app_info["paths"] = _get_paths(urlconfs)
+        data["paths"] = _get_paths(urlconfs)
     except Exception:  # pragma: no cover
-        app_info["paths"] = []
+        data["paths"] = []
         logger.exception("Failed to get paths")
     try:
-        app_info["openapi"] = _get_openapi(urlconfs)
+        data["openapi"] = _get_openapi(urlconfs)
     except Exception:  # pragma: no cover
         logger.exception("Failed to get OpenAPI schema")
-    app_info["versions"] = get_versions("django", "djangorestframework", "django-ninja", app_version=app_version)
-    app_info["client"] = "python:django"
-    return app_info
+    data["versions"] = get_versions("django", "djangorestframework", "django-ninja", app_version=app_version)
+    data["client"] = "python:django"
+    return data
 
 
 def _get_openapi(urlconfs: List[Optional[str]]) -> Optional[str]:

apitally/django_ninja.py

@@ -1,4 +1,4 @@
-from apitally.django import ApitallyMiddleware
+from apitally.django import ApitallyConsumer, ApitallyMiddleware
 
 
-__all__ = ["ApitallyMiddleware"]
+__all__ = ["ApitallyMiddleware", "ApitallyConsumer"]

apitally/django_rest_framework.py

@@ -1,4 +1,4 @@
-from apitally.django import ApitallyMiddleware
+from apitally.django import ApitallyConsumer, ApitallyMiddleware
 
 
-__all__ = ["ApitallyMiddleware"]
+__all__ = ["ApitallyMiddleware", "ApitallyConsumer"]

apitally/fastapi.py

@@ -1,4 +1,4 @@
-from apitally.starlette import ApitallyMiddleware
+from apitally.starlette import ApitallyConsumer, ApitallyMiddleware
 
 
-__all__ = ["ApitallyMiddleware"]
+__all__ = ["ApitallyMiddleware", "ApitallyConsumer"]

apitally/flask.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import time
 from threading import Timer
 from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Optional, Tuple
+from warnings import warn
 
 from flask import Flask, g
 from flask.wrappers import Response
@@ -10,6 +11,7 @@ from werkzeug.datastructures import Headers
 from werkzeug.exceptions import NotFound
 from werkzeug.test import Client
 
+from apitally.client.base import Consumer as ApitallyConsumer
 from apitally.client.threading import ApitallyClient
 from apitally.common import get_versions
 
@@ -19,7 +21,7 @@ if TYPE_CHECKING:
     from werkzeug.routing.map import Map
 
 
-__all__ = ["ApitallyMiddleware"]
+__all__ = ["ApitallyMiddleware", "ApitallyConsumer"]
 
 
 class ApitallyMiddleware:
@@ -38,16 +40,20 @@ class ApitallyMiddleware:
         self.patch_handle_exception()
         self.client = ApitallyClient(client_id=client_id, env=env)
         self.client.start_sync_loop()
-        self.delayed_set_app_info(app_version, openapi_url)
+        self.delayed_set_startup_data(app_version, openapi_url)
 
-    def delayed_set_app_info(self, app_version: Optional[str] = None, openapi_url: Optional[str] = None) -> None:
+    def delayed_set_startup_data(self, app_version: Optional[str] = None, openapi_url: Optional[str] = None) -> None:
         # Short delay to allow app routes to be registered first
-        timer = Timer(1.0, self._delayed_set_app_info, kwargs={"app_version": app_version, "openapi_url": openapi_url})
+        timer = Timer(
+            1.0,
+            self._delayed_set_startup_data,
+            kwargs={"app_version": app_version, "openapi_url": openapi_url},
+        )
         timer.start()
 
-    def _delayed_set_app_info(self, app_version: Optional[str] = None, openapi_url: Optional[str] = None) -> None:
-        app_info = _get_app_info(self.app, app_version, openapi_url)
-        self.client.set_app_info(app_info)
+    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)
 
     def __call__(self, environ: WSGIEnvironment, start_response: StartResponse) -> Iterable[bytes]:
         status_code = 200
@@ -88,8 +94,11 @@ class ApitallyMiddleware:
     ) -> None:
         rule, is_handled_path = self.get_rule(environ)
         if is_handled_path or not self.filter_unhandled_paths:
+            consumer = self.get_consumer()
+            consumer_identifier = consumer.identifier if consumer else None
+            self.client.consumer_registry.add_or_update_consumer(consumer)
             self.client.request_counter.add_request(
-                consumer=self.get_consumer(),
+                consumer=consumer_identifier,
                 method=environ["REQUEST_METHOD"],
                 path=rule,
                 status_code=status_code,
@@ -99,7 +108,7 @@ class ApitallyMiddleware:
             )
             if status_code == 500 and "unhandled_exception" in g:
                 self.client.server_error_counter.add_server_error(
-                    consumer=self.get_consumer(),
+                    consumer=consumer_identifier,
                     method=environ["REQUEST_METHOD"],
                     path=rule,
                     exception=g.unhandled_exception,
@@ -114,23 +123,31 @@ class ApitallyMiddleware:
         except NotFound:
             return environ["PATH_INFO"], False
 
-    def get_consumer(self) -> Optional[str]:
-        if "apitally_consumer" in g:
-            return str(g.apitally_consumer)
-        if "consumer_identifier" in g:  # Keeping this for legacy support
-            return str(g.consumer_identifier)
+    def get_consumer(self) -> Optional[ApitallyConsumer]:
+        if "apitally_consumer" in g and g.apitally_consumer:
+            return ApitallyConsumer.from_string_or_object(g.apitally_consumer)
+        if "consumer_identifier" in g and g.consumer_identifier:
+            # Keeping this for legacy support
+            warn(
+                "Providing a consumer identifier via `g.consumer_identifier` is deprecated, "
+                "use `g.apitally_consumer` instead.",
+                DeprecationWarning,
+            )
+            return ApitallyConsumer.from_string_or_object(g.consumer_identifier)
         return None
 
 
-def _get_app_info(app: Flask, app_version: Optional[str] = None, openapi_url: Optional[str] = None) -> Dict[str, Any]:
-    app_info: Dict[str, Any] = {}
+def _get_startup_data(
+    app: Flask, app_version: Optional[str] = None, openapi_url: Optional[str] = None
+) -> Dict[str, Any]:
+    data: Dict[str, Any] = {}
     if openapi_url and (openapi := _get_openapi(app, openapi_url)):
-        app_info["openapi"] = openapi
+        data["openapi"] = openapi
     if paths := _get_paths(app.url_map):
-        app_info["paths"] = paths
-    app_info["versions"] = get_versions("flask", app_version=app_version)
-    app_info["client"] = "python:flask"
-    return app_info
+        data["paths"] = paths
+    data["versions"] = get_versions("flask", app_version=app_version)
+    data["client"] = "python:flask"
+    return data
 
 
 def _get_paths(url_map: Map) -> List[Dict[str, str]]:

apitally/litestar.py

@@ -1,7 +1,8 @@
 import contextlib
 import json
 import time
-from typing import Callable, Dict, List, Optional
+from typing import Callable, Dict, List, Optional, Union
+from warnings import warn
 
 from litestar.app import DEFAULT_OPENAPI_CONFIG, Litestar
 from litestar.config.app import AppConfig
@@ -13,10 +14,11 @@ from litestar.plugins import InitPluginProtocol
 from litestar.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
 
 
-__all__ = ["ApitallyPlugin"]
+__all__ = ["ApitallyPlugin", "ApitallyConsumer"]
 
 
 class ApitallyPlugin(InitPluginProtocol):
@@ -26,7 +28,7 @@ class ApitallyPlugin(InitPluginProtocol):
         env: str = "dev",
         app_version: Optional[str] = None,
         filter_openapi_paths: bool = True,
-        identify_consumer_callback: Optional[Callable[[Request], Optional[str]]] = None,
+        identify_consumer_callback: Optional[Callable[[Request], Union[str, ApitallyConsumer, None]]] = None,
     ) -> None:
         self.client = ApitallyClient(client_id=client_id, env=env)
         self.app_version = app_version
@@ -50,13 +52,13 @@ class ApitallyPlugin(InitPluginProtocol):
         elif openapi_config.path is not None:
             self.openapi_path = openapi_config.path
 
-        app_info = {
+        data = {
             "openapi": _get_openapi(app),
             "paths": [route for route in _get_routes(app) if not self.filter_path(route["path"])],
             "versions": get_versions("litestar", app_version=self.app_version),
             "client": "python:litestar",
         }
-        self.client.set_app_info(app_info)
+        self.client.set_startup_data(data)
         self.client.start_sync_loop()
 
     def after_exception(self, exception: Exception, scope: Scope) -> None:
@@ -109,8 +111,10 @@ class ApitallyPlugin(InitPluginProtocol):
         if path is None or self.filter_path(path):
             return
         consumer = self.get_consumer(request)
+        consumer_identifier = consumer.identifier if consumer else None
+        self.client.consumer_registry.add_or_update_consumer(consumer)
         self.client.request_counter.add_request(
-            consumer=consumer,
+            consumer=consumer_identifier,
             method=request.method,
             path=path,
             status_code=response_status,
@@ -130,7 +134,7 @@ class ApitallyPlugin(InitPluginProtocol):
                     and isinstance(parsed_body["extra"], list)
                 ):
                     self.client.validation_error_counter.add_validation_errors(
-                        consumer=consumer,
+                        consumer=consumer_identifier,
                         method=request.method,
                         path=path,
                         detail=[
@@ -145,7 +149,7 @@ class ApitallyPlugin(InitPluginProtocol):
                     )
         if response_status == 500 and "exception" in request.state:
             self.client.server_error_counter.add_server_error(
-                consumer=consumer,
+                consumer=consumer_identifier,
                 method=request.method,
                 path=path,
                 exception=request.state["exception"],
@@ -167,15 +171,20 @@ class ApitallyPlugin(InitPluginProtocol):
             return path == self.openapi_path or path.startswith(self.openapi_path + "/")
         return False  # pragma: no cover
 
-    def get_consumer(self, request: Request) -> Optional[str]:
-        if hasattr(request.state, "apitally_consumer"):
-            return str(request.state.apitally_consumer)
-        if hasattr(request.state, "consumer_identifier"):  # Keeping this for legacy support
-            return str(request.state.consumer_identifier)
+    def get_consumer(self, request: Request) -> Optional[ApitallyConsumer]:
+        if hasattr(request.state, "apitally_consumer") and request.state.apitally_consumer:
+            return ApitallyConsumer.from_string_or_object(request.state.apitally_consumer)
+        if hasattr(request.state, "consumer_identifier") and request.state.consumer_identifier:
+            # Keeping this for legacy support
+            warn(
+                "Providing a consumer identifier via `request.state.consumer_identifier` is deprecated, "
+                "use `request.state.apitally_consumer` instead.",
+                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 consumer is not None:
-                return str(consumer)
+            return ApitallyConsumer.from_string_or_object(consumer)
         return None
 
 

apitally/starlette.py

@@ -4,6 +4,7 @@ import asyncio
 import json
 import time
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union
+from warnings import warn
 
 from httpx import HTTPStatusError
 from starlette.concurrency import iterate_in_threadpool
@@ -15,6 +16,7 @@ from starlette.testclient import TestClient
 from starlette.types import ASGIApp
 
 from apitally.client.asyncio import ApitallyClient
+from apitally.client.base import Consumer as ApitallyConsumer
 from apitally.common import get_versions
 
 
@@ -24,7 +26,7 @@ if TYPE_CHECKING:
     from starlette.responses import Response
 
 
-__all__ = ["ApitallyMiddleware"]
+__all__ = ["ApitallyMiddleware", "ApitallyConsumer"]
 
 
 class ApitallyMiddleware(BaseHTTPMiddleware):
@@ -36,23 +38,25 @@ class ApitallyMiddleware(BaseHTTPMiddleware):
         app_version: Optional[str] = None,
         openapi_url: Optional[str] = "/openapi.json",
         filter_unhandled_paths: bool = True,
-        identify_consumer_callback: Optional[Callable[[Request], Optional[str]]] = None,
+        identify_consumer_callback: Optional[Callable[[Request], Union[str, ApitallyConsumer, None]]] = None,
     ) -> None:
         self.filter_unhandled_paths = filter_unhandled_paths
         self.identify_consumer_callback = identify_consumer_callback
         self.client = ApitallyClient(client_id=client_id, env=env)
         self.client.start_sync_loop()
-        self.delayed_set_app_info(app_version, openapi_url)
+        self.delayed_set_startup_data(app_version, openapi_url)
         _register_shutdown_handler(app, self.client.handle_shutdown)
         super().__init__(app)
 
-    def delayed_set_app_info(self, app_version: Optional[str] = None, openapi_url: Optional[str] = None) -> None:
-        asyncio.create_task(self._delayed_set_app_info(app_version, openapi_url))
+    def delayed_set_startup_data(self, app_version: Optional[str] = None, openapi_url: Optional[str] = None) -> None:
+        asyncio.create_task(self._delayed_set_startup_data(app_version, openapi_url))
 
-    async def _delayed_set_app_info(self, app_version: Optional[str] = None, openapi_url: Optional[str] = None) -> None:
+    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
-        app_info = _get_app_info(self.app, app_version, openapi_url)
-        self.client.set_app_info(app_info)
+        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:
@@ -87,8 +91,10 @@ class ApitallyMiddleware(BaseHTTPMiddleware):
         path_template, is_handled_path = self.get_path_template(request)
         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)
             self.client.request_counter.add_request(
-                consumer=consumer,
+                consumer=consumer_identifier,
                 method=request.method,
                 path=path_template,
                 status_code=status_code,
@@ -105,14 +111,14 @@ class ApitallyMiddleware(BaseHTTPMiddleware):
                 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,
+                        consumer=consumer_identifier,
                         method=request.method,
                         path=path_template,
                         detail=body["detail"],
                     )
             if status_code == 500 and exception is not None:
                 self.client.server_error_counter.add_server_error(
-                    consumer=consumer,
+                    consumer=consumer_identifier,
                     method=request.method,
                     path=path_template,
                     exception=exception,
@@ -141,27 +147,34 @@ class ApitallyMiddleware(BaseHTTPMiddleware):
                 return route.path, True
         return request.url.path, False
 
-    def get_consumer(self, request: Request) -> Optional[str]:
-        if hasattr(request.state, "apitally_consumer"):
-            return str(request.state.apitally_consumer)
-        if hasattr(request.state, "consumer_identifier"):  # Keeping this for legacy support
-            return str(request.state.consumer_identifier)
+    def get_consumer(self, request: Request) -> Optional[ApitallyConsumer]:
+        if hasattr(request.state, "apitally_consumer") and request.state.apitally_consumer:
+            return ApitallyConsumer.from_string_or_object(request.state.apitally_consumer)
+        if hasattr(request.state, "consumer_identifier") and request.state.consumer_identifier:
+            # Keeping this for legacy support
+            warn(
+                "Providing a consumer identifier via `request.state.consumer_identifier` is deprecated, "
+                "use `request.state.apitally_consumer` instead.",
+                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 consumer is not None:
-                return str(consumer)
+            return ApitallyConsumer.from_string_or_object(consumer)
         return None
 
 
-def _get_app_info(app: ASGIApp, app_version: Optional[str] = None, openapi_url: Optional[str] = None) -> Dict[str, Any]:
-    app_info: Dict[str, Any] = {}
+def _get_startup_data(
+    app: ASGIApp, app_version: Optional[str] = None, openapi_url: Optional[str] = None
+) -> Dict[str, Any]:
+    data: Dict[str, Any] = {}
     if openapi_url and (openapi := _get_openapi(app, openapi_url)):
-        app_info["openapi"] = openapi
+        data["openapi"] = openapi
     if endpoints := _get_endpoint_info(app):
-        app_info["paths"] = [{"path": endpoint.path, "method": endpoint.http_method} for endpoint in endpoints]
-    app_info["versions"] = get_versions("fastapi", "starlette", app_version=app_version)
-    app_info["client"] = "python:starlette"
-    return app_info
+        data["paths"] = [{"path": endpoint.path, "method": endpoint.http_method} for endpoint in endpoints]
+    data["versions"] = get_versions("fastapi", "starlette", app_version=app_version)
+    data["client"] = "python:starlette"
+    return data
 
 
 def _get_openapi(app: ASGIApp, openapi_url: str) -> Optional[str]:

{apitally-0.10.1.dist-info → apitally-0.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: apitally
-Version: 0.10.1
+Version: 0.11.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.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+apitally/__init__.py,sha256=raMu9XA9JEjvdoTmFqcOw7qhJX24rYDP7XmS59TAO-Q,23
+apitally/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apitally/client/asyncio.py,sha256=7Q1LRENXdN69pmRHc3IXdxWVKoWrfYoJiImj4ufyLcw,4692
+apitally/client/base.py,sha256=IbAyC1VCONGA1B_Wj0jM82pkAn_cnVKe_iqR5xy3Zp0,15299
+apitally/client/logging.py,sha256=QMsKIIAFo92PNBUleeTgsrsQa7SEal-oJa1oOHUr1wI,507
+apitally/client/threading.py,sha256=tgADSLbqQFnf5JqFmDT3ul3Jch00jZtU2MUJmOP22A4,5085
+apitally/common.py,sha256=GbVmnXxhRvV30d7CfCQ9r0AeXj14Mv9Jm_Yd1bRWP28,1088
+apitally/django.py,sha256=J4dLh3vYFFm3bKgoQesGmghRmPDV5sOU2DpC6OxvW-Y,13612
+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/litestar.py,sha256=sQcrHw-JV9AlpnXlrczmaDe0k6tD9PYQsc8nyQul8Ko,8802
+apitally/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apitally/starlette.py,sha256=ib73Xe8GUMDwR4uREZsJjtmJtgk7uNEiINr9ex3Atm0,8612
+apitally-0.11.0.dist-info/LICENSE,sha256=vbLzC-4TddtXX-_AFEBKMYWRlxC_MN0g66QhPxo8PgY,1065
+apitally-0.11.0.dist-info/METADATA,sha256=822XloDi47QyB8-wm7sWbNwMU9BQ7n7BVuszSwEXDvc,6834
+apitally-0.11.0.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
+apitally-0.11.0.dist-info/RECORD,,

apitally-0.10.1.dist-info/RECORD

@@ -1,19 +0,0 @@
-apitally/__init__.py,sha256=v7Gyp89umFzDtY45tTjCdXqZnQ2RN01AibdYNxEvxYo,23
-apitally/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-apitally/client/asyncio.py,sha256=nvW3LcwIJsfE4h-nHiHJLSdnluxdZGu9AyH6l6MJH24,4556
-apitally/client/base.py,sha256=VWtHTkA6UT5aV37i_CXUvcfmYrabjHGBhzbDU6EeH1A,12785
-apitally/client/logging.py,sha256=QMsKIIAFo92PNBUleeTgsrsQa7SEal-oJa1oOHUr1wI,507
-apitally/client/threading.py,sha256=aEFDXDr5SI2g0Zv1GNcP9PhToeZ5Tp2VhPtPwbPGAIs,4957
-apitally/common.py,sha256=GbVmnXxhRvV30d7CfCQ9r0AeXj14Mv9Jm_Yd1bRWP28,1088
-apitally/django.py,sha256=ZsCKTUq4V3nCwIcrO8_3mPQFuPRiriqRSxQ8IPMRoOQ,12922
-apitally/django_ninja.py,sha256=iMvZd7j04nbOLpJgYxs7tpbsyXlZuhmHjcswXMvyUlU,82
-apitally/django_rest_framework.py,sha256=iMvZd7j04nbOLpJgYxs7tpbsyXlZuhmHjcswXMvyUlU,82
-apitally/fastapi.py,sha256=Q3n2bVREKQ_V_2yCQ48ngPtr-NJxDskpT_l20xhSbpM,85
-apitally/flask.py,sha256=iD2mbFqrWoEFFmDNXUtR32OYwlHob4I3tJT90-kwcnw,5691
-apitally/litestar.py,sha256=fgpdIlOpXS7TYFM02GUXk78H8WuJgDWMePPsQf-Pw1I,8092
-apitally/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-apitally/starlette.py,sha256=e0PoLTrihHioLGDF1TThjlsiyYtusa6Or6GKCX7Y9NQ,7881
-apitally-0.10.1.dist-info/LICENSE,sha256=vbLzC-4TddtXX-_AFEBKMYWRlxC_MN0g66QhPxo8PgY,1065
-apitally-0.10.1.dist-info/METADATA,sha256=m6jKQm1yML6RCaURdrSzJsn76em3JYScavaPDyCvxQs,6834
-apitally-0.10.1.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
-apitally-0.10.1.dist-info/RECORD,,