apitally 0.15.1__py3-none-any.whl → 0.16.0__py3-none-any.whl

apitally/blacksheep.py

@@ -0,0 +1,236 @@
+import asyncio
+import time
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Tuple, Union
+
+from blacksheep import Application, Headers, Request, Response
+from blacksheep.server.openapi.v3 import Info, OpenAPIHandler, Operation
+from blacksheep.server.routing import RouteMatch
+
+from apitally.client.client_asyncio import ApitallyClient
+from apitally.client.consumers import Consumer as ApitallyConsumer
+from apitally.client.request_logging import (
+    BODY_TOO_LARGE,
+    MAX_BODY_SIZE,
+    RequestLogger,
+    RequestLoggingConfig,
+)
+from apitally.common import get_versions, parse_int
+
+
+__all__ = ["use_apitally", "ApitallyMiddleware", "ApitallyConsumer", "RequestLoggingConfig"]
+
+
+def use_apitally(
+    app: Application,
+    client_id: str,
+    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,
+) -> None:
+    original_get_match = app.router.get_match
+
+    def _wrapped_router_get_match(request: Request) -> Optional[RouteMatch]:
+        match = original_get_match(request)
+        if match is not None:
+            setattr(request, "_route_pattern", match.pattern.decode())
+        return match
+
+    app.router.get_match = _wrapped_router_get_match  # type: ignore[assignment,method-assign]
+
+    middleware = ApitallyMiddleware(
+        app,
+        client_id,
+        env=env,
+        request_logging_config=request_logging_config,
+        app_version=app_version,
+        identify_consumer_callback=identify_consumer_callback,
+    )
+    app.middlewares.append(middleware)
+
+
+class ApitallyMiddleware:
+    def __init__(
+        self,
+        app: Application,
+        client_id: str,
+        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,
+    ) -> None:
+        self.app = app
+        self.identify_consumer_callback = identify_consumer_callback
+        self.client = ApitallyClient(
+            client_id=client_id,
+            env=env,
+            request_logging_config=request_logging_config,
+        )
+        self.client.start_sync_loop()
+        self._delayed_set_startup_data_task: Optional[asyncio.Task] = None
+        self.delayed_set_startup_data(app_version)
+        self.app.on_stop += self.on_stop
+
+        self.capture_request_body = (
+            self.client.request_logger.config.enabled and self.client.request_logger.config.log_request_body
+        )
+        self.capture_response_body = (
+            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) -> None:
+        self._delayed_set_startup_data_task = asyncio.create_task(self._delayed_set_startup_data(app_version))
+
+    async def _delayed_set_startup_data(self, app_version: 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=app_version)
+        self.client.set_startup_data(data)
+
+    async def on_stop(self, application: Application) -> None:
+        await self.client.handle_shutdown()
+
+    def get_consumer(self, request: Request) -> Optional[ApitallyConsumer]:
+        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)
+            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:
+            return await handler(request)
+
+        timestamp = time.time()
+        start_time = time.perf_counter()
+        response: Optional[Response] = None
+        exception: Optional[BaseException] = None
+
+        try:
+            response = await handler(request)
+        except BaseException as e:
+            exception = e
+            raise e from None
+        finally:
+            response_time = time.perf_counter() - start_time
+
+            consumer = self.get_consumer(request)
+            consumer_identifier = consumer.identifier if consumer else None
+            self.client.consumer_registry.add_or_update_consumer(consumer)
+
+            route_pattern: Optional[str] = getattr(request, "_route_pattern", None)
+            request_size = parse_int(request.get_first_header(b"Content-Length"))
+            request_content_type = (request.content_type() or b"").decode() or None
+            request_body = b""
+
+            response_status = response.status if response else 500
+            response_size: Optional[int] = None
+            response_headers = Headers()
+            response_body = b""
+
+            if self.capture_request_body and RequestLogger.is_supported_content_type(request_content_type):
+                if request_size is not None and request_size > MAX_BODY_SIZE:
+                    request_body = BODY_TOO_LARGE
+                else:
+                    request_body = await request.read() or b""
+                    if request_size is None:
+                        request_size = len(request_body)
+
+            if response is not None:
+                response_size = (
+                    response.content.length
+                    if response.content
+                    else parse_int(response.get_first_header(b"Content-Length"))
+                )
+                response_content_type = (response.content_type() or b"").decode()
+
+                response_headers = response.headers.clone()
+                if not response_headers.contains(b"Content-Type") and response.content:
+                    response_headers.set(b"Content-Type", response.content.type)
+                if not response_headers.contains(b"Content-Length") and response.content:
+                    response_headers.set(b"Content-Length", str(response.content.length).encode())
+
+                if self.capture_response_body and RequestLogger.is_supported_content_type(response_content_type):
+                    if response_size is not None and response_size > MAX_BODY_SIZE:
+                        response_body = BODY_TOO_LARGE
+                    else:
+                        response_body = await response.read() or b""
+                        if response_size is None or response_size < 0:
+                            response_size = len(response_body)
+
+            if route_pattern and request.method.upper() != "OPTIONS":
+                self.client.request_counter.add_request(
+                    consumer=consumer_identifier,
+                    method=request.method.upper(),
+                    path=route_pattern,
+                    status_code=response_status,
+                    response_time=response_time,
+                    request_size=request_size,
+                    response_size=response_size,
+                )
+
+                if response_status == 500 and exception is not None:
+                    self.client.server_error_counter.add_server_error(
+                        consumer=consumer_identifier,
+                        method=request.method.upper(),
+                        path=route_pattern,
+                        exception=exception,
+                    )
+
+            if self.client.request_logger.enabled:
+                self.client.request_logger.log_request(
+                    request={
+                        "timestamp": timestamp,
+                        "method": request.method.upper(),
+                        "path": route_pattern,
+                        "url": _get_full_url(request),
+                        "headers": _transform_headers(request.headers),
+                        "size": request_size,
+                        "consumer": consumer_identifier,
+                        "body": request_body,
+                    },
+                    response={
+                        "status_code": response_status,
+                        "response_time": response_time,
+                        "headers": _transform_headers(response_headers),
+                        "size": response_size,
+                        "body": response_body,
+                    },
+                    exception=exception,
+                )
+
+        return response
+
+
+def _get_full_url(request: Request) -> str:
+    return f"{request.scheme}://{request.host}/{str(request.url).lstrip('/')}"
+
+
+def _transform_headers(headers: Headers) -> List[Tuple[str, str]]:
+    return [(key.decode(), value.decode()) for key, value in headers.items()]
+
+
+def _get_startup_data(app: Application, app_version: Optional[str] = None) -> Dict[str, Any]:
+    return {
+        "paths": _get_paths(app),
+        "versions": get_versions("blacksheep", app_version=app_version),
+        "client": "python:blacksheep",
+    }
+
+
+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")
+    for path, path_item in openapi.get_paths(app).items():
+        for method in methods:
+            operation: Operation = getattr(path_item, method, None)
+            if operation is not None:
+                item = {"method": method.upper(), "path": path}
+                if operation.summary:
+                    item["summary"] = operation.summary
+                if operation.description:
+                    item["description"] = operation.description
+                paths.append(item)
+    return paths

apitally/client/request_logging.py

@@ -225,6 +225,11 @@ class RequestLogger:
         request["headers"] = self._mask_headers(request["headers"]) if self.config.log_request_headers else []
         response["headers"] = self._mask_headers(response["headers"]) if self.config.log_response_headers else []
 
+        if request["size"] is not None and request["size"] < 0:
+            request["size"] = None
+        if response["size"] is not None and response["size"] < 0:
+            response["size"] = None
+
         item: Dict[str, Any] = {
             "uuid": str(uuid4()),
             "request": _skip_empty_values(request),

apitally/client/requests.py

@@ -49,15 +49,17 @@ class RequestCounter:
             if request_size is not None:
                 with contextlib.suppress(ValueError):
                     request_size = int(request_size)
-                    request_size_kb_bin = request_size // 1000  # In KB, rounded down to nearest 1KB
-                    self.request_size_sums[request_info] += request_size
-                    self.request_sizes.setdefault(request_info, Counter())[request_size_kb_bin] += 1
+                    if request_size >= 0:
+                        request_size_kb_bin = request_size // 1000  # In KB, rounded down to nearest 1KB
+                        self.request_size_sums[request_info] += request_size
+                        self.request_sizes.setdefault(request_info, Counter())[request_size_kb_bin] += 1
             if response_size is not None:
                 with contextlib.suppress(ValueError):
                     response_size = int(response_size)
-                    response_size_kb_bin = response_size // 1000  # In KB, rounded down to nearest 1KB
-                    self.response_size_sums[request_info] += response_size
-                    self.response_sizes.setdefault(request_info, Counter())[response_size_kb_bin] += 1
+                    if response_size >= 0:
+                        response_size_kb_bin = response_size // 1000  # In KB, rounded down to nearest 1KB
+                        self.response_size_sums[request_info] += response_size
+                        self.response_sizes.setdefault(request_info, Counter())[response_size_kb_bin] += 1
 
     def get_and_reset_requests(self) -> List[Dict[str, Any]]:
         data: List[Dict[str, Any]] = []

apitally/common.py

@@ -5,7 +5,7 @@ from importlib.metadata import PackageNotFoundError, version
 from typing import Any, Dict, Optional, Union
 
 
-def parse_int(x: Union[str, int, None]) -> Optional[int]:
+def parse_int(x: Union[str, bytes, int, None]) -> Optional[int]:
     if x is None:
         return None
     try:

{apitally-0.15.1.dist-info → apitally-0.16.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: apitally
-Version: 0.15.1
-Summary: Simple API monitoring & analytics for REST APIs built with FastAPI, Flask, Django, Starlette and Litestar.
+Version: 0.16.0
+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
 Project-URL: Repository, https://github.com/apitally/apitally-py
@@ -24,6 +24,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Internet
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Middleware
@@ -32,6 +33,9 @@ Classifier: Topic :: System :: Monitoring
 Classifier: Typing :: Typed
 Requires-Python: <4.0,>=3.8
 Requires-Dist: backoff>=2.0.0
+Provides-Extra: blacksheep
+Requires-Dist: blacksheep>=2; extra == 'blacksheep'
+Requires-Dist: httpx>=0.22.0; extra == 'blacksheep'
 Provides-Extra: django-ninja
 Requires-Dist: django-ninja>=0.18.0; extra == 'django-ninja'
 Requires-Dist: django<5,>=2.2; (python_version < '3.10') and extra == 'django-ninja'
@@ -94,6 +98,7 @@ This SDK for Apitally currently supports the following Python web frameworks:
 - [Flask](https://docs.apitally.io/frameworks/flask)
 - [Starlette](https://docs.apitally.io/frameworks/starlette)
 - [Litestar](https://docs.apitally.io/frameworks/litestar)
+- [BlackSheep](https://docs.apitally.io/frameworks/blacksheep)
 
 Learn more about Apitally on our 🌎 [website](https://apitally.io) or check out
 the 📚 [documentation](https://docs.apitally.io).
@@ -235,6 +240,24 @@ app = Litestar(
 )
 ```
 
+### BlackSheep
+
+This is an example of how to add the Apitally middleware to a BlackSheep
+application. For further instructions, see our
+[setup guide for BlackSheep](https://docs.apitally.io/frameworks/blacksheep).
+
+```python
+from blacksheep import Application
+from apitally.blacksheep import use_apitally
+
+app = Application()
+use_apitally(
+    app,
+    client_id="your-client-id",
+    env="dev",  # or "prod" etc.
+)
+```
+
 ## Getting help
 
 If you need help please

{apitally-0.15.1.dist-info → apitally-0.16.0.dist-info}/RECORD

@@ -1,5 +1,6 @@
 apitally/__init__.py,sha256=ShXQBVjyiSOHxoQJS2BvNG395W4KZfqMxZWBAR0MZrE,22
-apitally/common.py,sha256=FMDBPlYHCqomgAq-Z8JiyTSMAoqJRycPsJzsxncQqQA,1598
+apitally/blacksheep.py,sha256=LSdg5LG-bnXdhKtPkp71CBQKGVtUi3t_EirovoaRy-s,9973
+apitally/common.py,sha256=azDxepViH0QW0MuufTHxeSQyLGzCkocAX_KPziWTx8A,1605
 apitally/django.py,sha256=zwe8svC8rfo7TyHfOlkYTeXptxPFoRjvt0bbYvgtJKM,16892
 apitally/django_ninja.py,sha256=-CmrwFFRv7thFOUK_OrOSouhHL9bm5sIBNIQlpyE_2c,166
 apitally/django_rest_framework.py,sha256=-CmrwFFRv7thFOUK_OrOSouhHL9bm5sIBNIQlpyE_2c,166
@@ -14,12 +15,12 @@ apitally/client/client_base.py,sha256=DvivGeHd3dyOASRvkIo44Zh8RzdBMfH8_rROa2lFbg
 apitally/client/client_threading.py,sha256=7JPu2Uulev7X2RiSLx4HJYfvAP6Z5zB_yuSevMfQC7I,7389
 apitally/client/consumers.py,sha256=w_AFQhVgdtJVt7pVySBvSZwQg-2JVqmD2JQtVBoMkus,2626
 apitally/client/logging.py,sha256=QMsKIIAFo92PNBUleeTgsrsQa7SEal-oJa1oOHUr1wI,507
-apitally/client/request_logging.py,sha256=OL1jlpHXYpZw2VKRekgNSwZQ0qZJeiiJxKeTYrmP22g,13913
-apitally/client/requests.py,sha256=RdJyvIqQGVHvS-wjpAPUwcO7byOJ6jO8dYqNTU2Furg,3685
+apitally/client/request_logging.py,sha256=SMvQd3WDolnb8u9rHVh2_OgXwFjL2jLZt-GpZNQ1XGk,14115
+apitally/client/requests.py,sha256=SDptGOg9XvaEKFj2o3oxJz-JAuZzUrqpHnbOQixf99o,3794
 apitally/client/sentry.py,sha256=qMjHdI0V7c50ruo1WjmjWc8g6oGDv724vSCvcuZ8G9k,1188
 apitally/client/server_errors.py,sha256=4B2BKDFoIpoWc55UVH6AIdYSgzj6zxCdMNUW77JjhZw,3423
 apitally/client/validation_errors.py,sha256=6G8WYWFgJs9VH9swvkPXJGuOJgymj5ooWA9OwjUTbuM,1964
-apitally-0.15.1.dist-info/METADATA,sha256=Z8Es_x6H-rxC5KB26S0i1BFGVBlISkQfNiYPglyS09E,8643
-apitally-0.15.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-apitally-0.15.1.dist-info/licenses/LICENSE,sha256=vbLzC-4TddtXX-_AFEBKMYWRlxC_MN0g66QhPxo8PgY,1065
-apitally-0.15.1.dist-info/RECORD,,
+apitally-0.16.0.dist-info/METADATA,sha256=kWbylw8pJ0Q0xHBt1P7S3h6cTqx9UQ8SBAnrxFew5CM,9321
+apitally-0.16.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+apitally-0.16.0.dist-info/licenses/LICENSE,sha256=vbLzC-4TddtXX-_AFEBKMYWRlxC_MN0g66QhPxo8PgY,1065
+apitally-0.16.0.dist-info/RECORD,,