apitally 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

apitally/__init__.py

@@ -1 +1 @@
-__version__ = "0.7.0"
+__version__ = "0.8.0"

apitally/client/base.py

@@ -5,6 +5,7 @@ import os
 import re
 import threading
 import time
+import traceback
 from abc import ABC
 from collections import Counter
 from dataclasses import dataclass
@@ -24,6 +25,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 +57,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 +90,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 +228,75 @@ 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._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
+
+    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,
+                        "error_count": count,
+                    }
+                )
+            self.error_counts.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

@@ -40,18 +40,25 @@ class ApitallyMiddleware:
 
     def __init__(self, get_response: Callable[[HttpRequest], HttpResponse]) -> None:
         self.get_response = get_response
-        self.ninja_available = _check_import("ninja")
+        self.drf_available = _check_import("rest_framework")
         self.drf_endpoint_enumerator = None
-        if _check_import("rest_framework"):
-            from rest_framework.schemas.generators import EndpointEnumerator
-
-            self.drf_endpoint_enumerator = EndpointEnumerator()
+        self.ninja_available = _check_import("ninja")
+        self.callbacks = set()
 
         if self.config is None:
             config = getattr(settings, "APITALLY_MIDDLEWARE", {})
             self.configure(**config)
             assert self.config is not None
 
+        if self.drf_available:
+            from rest_framework.schemas.generators import EndpointEnumerator
+
+            self.drf_endpoint_enumerator = EndpointEnumerator()
+            if None not in self.config.urlconfs:
+                self.callbacks.update(_get_drf_callbacks(self.config.urlconfs))
+        if self.ninja_available and None not in self.config.urlconfs:
+            self.callbacks.update(_get_ninja_callbacks(self.config.urlconfs))
+
         self.client = ApitallyClient(client_id=self.config.client_id, env=self.config.env)
         self.client.start_sync_loop()
         self.client.set_app_info(
@@ -119,11 +126,27 @@ 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:
+                if self.callbacks and match.func not in self.callbacks:
+                    return None
                 if self.drf_endpoint_enumerator is not None:
                     from rest_framework.schemas.generators import is_api_view
 
@@ -206,6 +229,13 @@ def _get_drf_paths(urlconfs: List[Optional[str]]) -> List[Dict[str, str]]:
     ]
 
 
+def _get_drf_callbacks(urlconfs: List[Optional[str]]) -> Set[Callable]:
+    from rest_framework.schemas.generators import EndpointEnumerator
+
+    enumerators = [EndpointEnumerator(urlconf=urlconf) for urlconf in urlconfs]
+    return {callback for enumerator in enumerators for _, _, callback in enumerator.get_api_endpoints()}
+
+
 def _get_drf_schema(urlconfs: List[Optional[str]]) -> Optional[Dict[str, Any]]:
     from rest_framework.schemas.openapi import SchemaGenerator
 
@@ -237,6 +267,15 @@ def _get_ninja_paths(urlconfs: List[Optional[str]]) -> List[Dict[str, str]]:
     return endpoints
 
 
+def _get_ninja_callbacks(urlconfs: List[Optional[str]]) -> Set[Callable]:
+    return {
+        path_view.get_view()
+        for api in _get_ninja_api_instances(urlconfs=urlconfs)
+        for _, router in api._routers
+        for path_view in router.path_operations.values()
+    }
+
+
 def _get_ninja_schema(urlconfs: List[Optional[str]]) -> Optional[Dict[str, Any]]:
     schemas = []
     for api in _get_ninja_api_instances(urlconfs=urlconfs):

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.0.dist-info → apitally-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: apitally
-Version: 0.7.0
+Version: 0.8.0
 Summary: API monitoring for REST APIs built with FastAPI, Flask, Django, Starlette and Litestar.
 Home-page: https://apitally.io
 License: MIT

{apitally-0.7.0.dist-info → apitally-0.8.0.dist-info}/RECORD

@@ -1,19 +1,19 @@
-apitally/__init__.py,sha256=RaANGbRu5e-vehwXI1-Qe2ggPPfs1TQaZj072JdbLk4,22
+apitally/__init__.py,sha256=iPlYCcIzuzW7T2HKDkmYlMkRI51dBLfNRxPPiWrfw9U,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=-2Bw_zFq6de-mSQSYsTa0NSRoMcHwiZqpSCQnjjIZ2M,11351
 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=tp1bsBGyfG41yKMBHrqNG2rOyO4ToB7Fal40TTN4qvo,11052
+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.0.dist-info/LICENSE,sha256=vbLzC-4TddtXX-_AFEBKMYWRlxC_MN0g66QhPxo8PgY,1065
-apitally-0.7.0.dist-info/METADATA,sha256=huzvHmuBeVxea6HKDwXnT6ei8zrBI7RD7pdweMdKkEQ,6736
-apitally-0.7.0.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
-apitally-0.7.0.dist-info/RECORD,,
+apitally/starlette.py,sha256=kyXgzw0L90GUOZCgjuwM3q0uOpPX-hD0TQb2Wgqbqb8,7767
+apitally-0.8.0.dist-info/LICENSE,sha256=vbLzC-4TddtXX-_AFEBKMYWRlxC_MN0g66QhPxo8PgY,1065
+apitally-0.8.0.dist-info/METADATA,sha256=jl6_hdLWMu-CStH70iJ-4-Lt94328tX_X33avx-PIqI,6736
+apitally-0.8.0.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
+apitally-0.8.0.dist-info/RECORD,,