apitally 0.7.1__py3-none-any.whl → 0.9.0__py3-none-any.whl

apitally/__init__.py

@@ -1 +1 @@
-__version__ = "0.7.1"
+__version__ = "0.9.0"

apitally/client/base.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
+import asyncio
 import contextlib
 import os
 import re
 import threading
 import time
+import traceback
 from abc import ABC
 from collections import Counter
 from dataclasses import dataclass
@@ -24,6 +26,8 @@ MAX_QUEUE_TIME = 3600
 SYNC_INTERVAL = 60
 INITIAL_SYNC_INTERVAL = 10
 INITIAL_SYNC_INTERVAL_DURATION = 3600
+MAX_EXCEPTION_MSG_LENGTH = 2048
+MAX_EXCEPTION_TRACEBACK_LENGTH = 65536
 
 TApitallyClient = TypeVar("TApitallyClient", bound="ApitallyClientBase")
 
@@ -54,6 +58,7 @@ class ApitallyClientBase(ABC):
         self.instance_uuid = str(uuid4())
         self.request_counter = RequestCounter()
         self.validation_error_counter = ValidationErrorCounter()
+        self.server_error_counter = ServerErrorCounter()
 
         self._app_info_payload: Optional[Dict[str, Any]] = None
         self._app_info_sent = False
@@ -86,11 +91,13 @@ class ApitallyClientBase(ABC):
     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,
         }
 
 
@@ -222,3 +229,108 @@ class ValidationErrorCounter:
                 )
             self.error_counts.clear()
         return data
+
+
+@dataclass(frozen=True)
+class ServerError:
+    consumer: Optional[str]
+    method: str
+    path: str
+    type: str
+    msg: str
+    traceback: str
+
+
+class ServerErrorCounter:
+    def __init__(self) -> None:
+        self.error_counts: Counter[ServerError] = Counter()
+        self.sentry_event_ids: Dict[ServerError, str] = {}
+        self._lock = threading.Lock()
+
+    def add_server_error(self, consumer: Optional[str], method: str, path: str, exception: BaseException) -> None:
+        if not isinstance(exception, BaseException):
+            return  # pragma: no cover
+        exception_type = type(exception)
+        with self._lock:
+            server_error = ServerError(
+                consumer=consumer,
+                method=method.upper(),
+                path=path,
+                type=f"{exception_type.__module__}.{exception_type.__qualname__}",
+                msg=self._get_truncated_exception_msg(exception),
+                traceback=self._get_truncated_exception_traceback(exception),
+            )
+            self.error_counts[server_error] += 1
+            self.capture_sentry_event_id(server_error)
+
+    def capture_sentry_event_id(self, server_error: ServerError) -> None:
+        try:
+            from sentry_sdk.hub import Hub
+            from sentry_sdk.scope import Scope
+        except ImportError:
+            return  # pragma: no cover
+        if not hasattr(Scope, "get_isolation_scope") or not hasattr(Scope, "last_event_id"):
+            # sentry-sdk < 2.2.0 is not supported
+            return  # pragma: no cover
+        if Hub.current.client is None:
+            return  # sentry-sdk not initialized
+
+        scope = Scope.get_isolation_scope()
+        if event_id := scope.last_event_id():
+            self.sentry_event_ids[server_error] = event_id
+            return
+
+        async def _wait_for_sentry_event_id(scope: Scope) -> None:
+            i = 0
+            while not (event_id := scope.last_event_id()) and i < 100:
+                i += 1
+                await asyncio.sleep(0.001)
+            if event_id:
+                self.sentry_event_ids[server_error] = event_id
+
+        with contextlib.suppress(RuntimeError):  # ignore no running loop
+            loop = asyncio.get_running_loop()
+            loop.create_task(_wait_for_sentry_event_id(scope))
+
+    def get_and_reset_server_errors(self) -> List[Dict[str, Any]]:
+        data: List[Dict[str, Any]] = []
+        with self._lock:
+            for server_error, count in self.error_counts.items():
+                data.append(
+                    {
+                        "consumer": server_error.consumer,
+                        "method": server_error.method,
+                        "path": server_error.path,
+                        "type": server_error.type,
+                        "msg": server_error.msg,
+                        "traceback": server_error.traceback,
+                        "sentry_event_id": self.sentry_event_ids.get(server_error),
+                        "error_count": count,
+                    }
+                )
+            self.error_counts.clear()
+            self.sentry_event_ids.clear()
+        return data
+
+    @staticmethod
+    def _get_truncated_exception_msg(exception: BaseException) -> str:
+        msg = str(exception).strip()
+        if len(msg) <= MAX_EXCEPTION_MSG_LENGTH:
+            return msg
+        suffix = "... (truncated)"
+        cutoff = MAX_EXCEPTION_MSG_LENGTH - len(suffix)
+        return msg[:cutoff] + suffix
+
+    @staticmethod
+    def _get_truncated_exception_traceback(exception: BaseException) -> str:
+        prefix = "... (truncated) ...\n"
+        cutoff = MAX_EXCEPTION_TRACEBACK_LENGTH - len(prefix)
+        lines = []
+        length = 0
+        for line in traceback.format_exception(exception)[::-1]:
+            if length + len(line) > cutoff:
+                lines.append(prefix)
+                break
+            lines.append(line)
+            length += len(line)
+        return "".join(lines[::-1]).strip()

apitally/django.py

@@ -126,8 +126,22 @@ class ApitallyMiddleware:
                             )
                 except Exception:  # pragma: no cover
                     logger.exception("Failed to log validation errors")
+            if response.status_code == 500 and hasattr(request, "unhandled_exception"):
+                try:
+                    self.client.server_error_counter.add_server_error(
+                        consumer=consumer,
+                        method=request.method,
+                        path=path,
+                        exception=getattr(request, "unhandled_exception"),
+                    )
+                except Exception:  # pragma: no cover
+                    logger.exception("Failed to log server error")
         return response
 
+    def process_exception(self, request: HttpRequest, exception: Exception) -> None:
+        setattr(request, "unhandled_exception", exception)
+        return None
+
     def get_path(self, request: HttpRequest) -> Optional[str]:
         if (match := request.resolver_match) is not None:
             try:

apitally/flask.py

@@ -5,6 +5,7 @@ from threading import Timer
 from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Optional, Tuple
 
 from flask import Flask, g
+from flask.wrappers import Response
 from werkzeug.datastructures import Headers
 from werkzeug.exceptions import NotFound
 from werkzeug.test import Client
@@ -34,6 +35,7 @@ class ApitallyMiddleware:
         self.app = app
         self.wsgi_app = app.wsgi_app
         self.filter_unhandled_paths = filter_unhandled_paths
+        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)
@@ -68,8 +70,21 @@ class ApitallyMiddleware:
             )
         return response
 
+    def patch_handle_exception(self) -> None:
+        original_handle_exception = self.app.handle_exception
+
+        def handle_exception(e: Exception) -> Response:
+            g.unhandled_exception = e
+            return original_handle_exception(e)
+
+        self.app.handle_exception = handle_exception  # type: ignore[method-assign]
+
     def add_request(
-        self, environ: WSGIEnvironment, status_code: int, response_time: float, response_headers: Headers
+        self,
+        environ: WSGIEnvironment,
+        status_code: int,
+        response_time: float,
+        response_headers: Headers,
     ) -> None:
         rule, is_handled_path = self.get_rule(environ)
         if is_handled_path or not self.filter_unhandled_paths:
@@ -82,6 +97,13 @@ class ApitallyMiddleware:
                 request_size=environ.get("CONTENT_LENGTH"),
                 response_size=response_headers.get("Content-Length", type=int),
             )
+            if status_code == 500 and "unhandled_exception" in g:
+                self.client.server_error_counter.add_server_error(
+                    consumer=self.get_consumer(),
+                    method=environ["REQUEST_METHOD"],
+                    path=rule,
+                    exception=g.unhandled_exception,
+                )
 
     def get_rule(self, environ: WSGIEnvironment) -> Tuple[str, bool]:
         url_adapter = self.app.url_map.bind_to_environ(environ)

apitally/litestar.py

@@ -32,17 +32,23 @@ class ApitallyPlugin(InitPluginProtocol):
         self.app_version = app_version
         self.filter_openapi_paths = filter_openapi_paths
         self.identify_consumer_callback = identify_consumer_callback
-        self.openapi_path: Optional[str] = None
+        self.openapi_path = "/schema"
 
     def on_app_init(self, app_config: AppConfig) -> AppConfig:
         app_config.on_startup.append(self.on_startup)
         app_config.on_shutdown.append(self.client.handle_shutdown)
         app_config.middleware.append(self.middleware_factory)
+        app_config.after_exception.append(self.after_exception)
         return app_config
 
     def on_startup(self, app: Litestar) -> None:
         openapi_config = app.openapi_config or DEFAULT_OPENAPI_CONFIG
-        self.openapi_path = openapi_config.openapi_controller.path
+        if openapi_config.openapi_controller is not None:
+            self.openapi_path = openapi_config.openapi_controller.path
+        elif hasattr(openapi_config, "openapi_router") and openapi_config.openapi_router is not None:
+            self.openapi_path = openapi_config.openapi_router.path
+        elif openapi_config.path is not None:
+            self.openapi_path = openapi_config.path
 
         app_info = {
             "openapi": _get_openapi(app),
@@ -53,6 +59,9 @@ class ApitallyPlugin(InitPluginProtocol):
         self.client.set_app_info(app_info)
         self.client.start_sync_loop()
 
+    def after_exception(self, exception: Exception, scope: Scope) -> None:
+        scope["state"]["exception"] = exception
+
     def middleware_factory(self, app: ASGIApp) -> ASGIApp:
         async def middleware(scope: Scope, receive: Receive, send: Send) -> None:
             if scope["type"] == "http" and scope["method"] != "OPTIONS":
@@ -134,6 +143,13 @@ class ApitallyPlugin(InitPluginProtocol):
                             if "key" in error and "message" in error
                         ],
                     )
+        if response_status == 500 and "exception" in request.state:
+            self.client.server_error_counter.add_server_error(
+                consumer=consumer,
+                method=request.method,
+                path=path,
+                exception=request.state["exception"],
+            )
 
     def get_path(self, request: Request) -> Optional[str]:
         path: List[str] = []

apitally/starlette.py

@@ -64,6 +64,7 @@ class ApitallyMiddleware(BaseHTTPMiddleware):
                 response=None,
                 status_code=HTTP_500_INTERNAL_SERVER_ERROR,
                 response_time=time.perf_counter() - start_time,
+                exception=e,
             )
             raise e from None
         else:
@@ -76,7 +77,12 @@ class ApitallyMiddleware(BaseHTTPMiddleware):
         return response
 
     async def add_request(
-        self, request: Request, response: Optional[Response], status_code: int, response_time: float
+        self,
+        request: Request,
+        response: Optional[Response],
+        status_code: int,
+        response_time: float,
+        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:
@@ -104,6 +110,13 @@ class ApitallyMiddleware(BaseHTTPMiddleware):
                         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,
+                    method=request.method,
+                    path=path_template,
+                    exception=exception,
+                )
 
     @staticmethod
     async def get_response_json(response: Response) -> Any:

{apitally-0.7.1.dist-info → apitally-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: apitally
-Version: 0.7.1
+Version: 0.9.0
 Summary: API monitoring for REST APIs built with FastAPI, Flask, Django, Starlette and Litestar.
 Home-page: https://apitally.io
 License: MIT
@@ -26,6 +26,7 @@ Provides-Extra: django-rest-framework
 Provides-Extra: fastapi
 Provides-Extra: flask
 Provides-Extra: litestar
+Provides-Extra: sentry
 Provides-Extra: starlette
 Requires-Dist: backoff (>=2.0.0)
 Requires-Dist: django (>=2.2) ; extra == "django-ninja" or extra == "django-rest-framework"
@@ -37,6 +38,7 @@ Requires-Dist: httpx (>=0.22.0) ; extra == "fastapi" or extra == "litestar" or e
 Requires-Dist: inflection (>=0.5.1) ; extra == "django-rest-framework"
 Requires-Dist: litestar (>=2.0.0) ; extra == "litestar"
 Requires-Dist: requests (>=2.26.0) ; extra == "django-ninja" or extra == "django-rest-framework" or extra == "flask"
+Requires-Dist: sentry-sdk (>=2.2.0) ; extra == "sentry"
 Requires-Dist: starlette (>=0.21.0,<1.0.0) ; extra == "fastapi" or extra == "starlette"
 Requires-Dist: uritemplate (>=3.0.0) ; extra == "django-rest-framework"
 Project-URL: Documentation, https://docs.apitally.io

{apitally-0.7.1.dist-info → apitally-0.9.0.dist-info}/RECORD

@@ -1,19 +1,19 @@
-apitally/__init__.py,sha256=2KJZDSMOG7KS82AxYOrZ4ZihYxX0wjfUjDsIZh3L024,22
+apitally/__init__.py,sha256=H9NWRZb7NbeRRPLP_V1fARmLNXranorVM-OOY-8_2ug,22
 apitally/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 apitally/client/asyncio.py,sha256=uR5JlH37G6gZvAJ7A1gYOGkjn3zjC-4I6avA1fncXHs,4433
-apitally/client/base.py,sha256=E_yUTItAtZWPOx80K3Pm55CNBgF_NZ6RMyXZTnjSV9c,8511
+apitally/client/base.py,sha256=VWtHTkA6UT5aV37i_CXUvcfmYrabjHGBhzbDU6EeH1A,12785
 apitally/client/logging.py,sha256=QMsKIIAFo92PNBUleeTgsrsQa7SEal-oJa1oOHUr1wI,507
 apitally/client/threading.py,sha256=ihQzUStrSQFynpqXgFpseAXrHuc5Et1QvG-YHlzqDr8,4831
 apitally/common.py,sha256=GbVmnXxhRvV30d7CfCQ9r0AeXj14Mv9Jm_Yd1bRWP28,1088
-apitally/django.py,sha256=SHSM00eRsvoJC2d4c4tK6gctKLnxLfrw4LoZ4CWPm4U,12124
+apitally/django.py,sha256=Ym590Tiz1Qnk-IgFcna8r-XkSgcln2riziSPZCwD9nw,12812
 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=xxyrHchMiPuEMP3c_Us_niJn9K7x87RDvxD5GtntEvU,4769
-apitally/litestar.py,sha256=Pl1tEbxve3vqrdflWdvZjPFrEVxNIr6NjuQVf4YSpzY,7171
+apitally/flask.py,sha256=Utn92aXXl_1f4bKvuf4iZDB4v1vVLpeW5p1tF57Kf-8,5552
+apitally/litestar.py,sha256=1-skfFDKjYa7y6mOdNvjR4YGtsQbNA0iGQP1jyre41Q,7978
 apitally/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-apitally/starlette.py,sha256=9VKGdNuKPrRcnQv7GeyV5cLa7TpgidxMVnAKSxMsWjI,7345
-apitally-0.7.1.dist-info/LICENSE,sha256=vbLzC-4TddtXX-_AFEBKMYWRlxC_MN0g66QhPxo8PgY,1065
-apitally-0.7.1.dist-info/METADATA,sha256=SO16kB-1EwZGAm28P4m4E2EMltFfmKUy4uF44X4LB30,6736
-apitally-0.7.1.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
-apitally-0.7.1.dist-info/RECORD,,
+apitally/starlette.py,sha256=kyXgzw0L90GUOZCgjuwM3q0uOpPX-hD0TQb2Wgqbqb8,7767
+apitally-0.9.0.dist-info/LICENSE,sha256=vbLzC-4TddtXX-_AFEBKMYWRlxC_MN0g66QhPxo8PgY,1065
+apitally-0.9.0.dist-info/METADATA,sha256=SsnJeg47jd8Q8MP9RXC9mbmweeE8ywLCxOLtQks3VKQ,6815
+apitally-0.9.0.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
+apitally-0.9.0.dist-info/RECORD,,