errorgap 0.2.0__tar.gz → 0.3.0__tar.gz

{errorgap-0.2.0 → errorgap-0.3.0}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.3.0 — 2026-10-04
+
+- Django and FastAPI/Starlette middleware now time each request as an APM
+  transaction (with `apm_enabled`), grouped by URL pattern / route path, with
+  errors linked to their request and the browser's `x-errorgap-trace` header
+  recorded. `errorgap.django.spans(request)` / `errorgap.fastapi.spans(request)`
+  record spans.
+
 ## 0.2.0 — 2026-10-03
 
 - APM: `track_transaction` / `track_job` context managers, `notify_transaction`,

{errorgap-0.2.0 → errorgap-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: errorgap
-Version: 0.2.0
+Version: 0.3.0
 Summary: Python notifier for Errorgap error tracking.
 Project-URL: Homepage, https://github.com/errorgaphq/errorgap-python
 Project-URL: Source, https://github.com/errorgaphq/errorgap-python
@@ -97,6 +97,11 @@ MIDDLEWARE = [
 ]
 ```
 
+With `apm_enabled=True` each request is also an APM transaction grouped by
+its URL pattern (`/orders/<int:order_id>`); errors raised during it carry its
+transaction id, and the browser SDK's `x-errorgap-trace` header is recorded.
+Record spans from a view with `errorgap.django.spans(request).database(sql, ms)`.
+
 ## Flask
 
 ```python
@@ -155,8 +160,8 @@ concurrent threads and asyncio tasks never share one;
 ## Browser trace links
 
 When the errorgap browser SDK (`@errorgap/browser` 0.3+) is on the page, its
-API calls send an `x-errorgap-trace` header. The WSGI middleware (and so
-`init_app`) records it, and `track_transaction(..., trace_id=header)` accepts
+API calls send an `x-errorgap-trace` header. The WSGI, Django and FastAPI
+middleware (and so Flask's `init_app`) record it, and `track_transaction(..., trace_id=header)` accepts
 it, so errorgap's browser Performance view links each call to the server
 request that answered it. Malformed values are ignored.
 
@@ -170,6 +175,12 @@ app = FastAPI()
 app.add_middleware(ErrorgapMiddleware)
 ```
 
+With `apm_enabled=True` each request is also an APM transaction grouped by
+its route path (`/orders/{order_id}`); errors raised during it carry its
+transaction id, and the browser SDK's `x-errorgap-trace` header is recorded.
+Record spans from an endpoint with `errorgap.fastapi.spans(request).database(sql, ms)`
+(take `request: Request` as a parameter).
+
 ## Configuration reference
 
 | Argument | Default | Notes |

{errorgap-0.2.0 → errorgap-0.3.0}/README.md

@@ -61,6 +61,11 @@ MIDDLEWARE = [
 ]
 ```
 
+With `apm_enabled=True` each request is also an APM transaction grouped by
+its URL pattern (`/orders/<int:order_id>`); errors raised during it carry its
+transaction id, and the browser SDK's `x-errorgap-trace` header is recorded.
+Record spans from a view with `errorgap.django.spans(request).database(sql, ms)`.
+
 ## Flask
 
 ```python
@@ -119,8 +124,8 @@ concurrent threads and asyncio tasks never share one;
 ## Browser trace links
 
 When the errorgap browser SDK (`@errorgap/browser` 0.3+) is on the page, its
-API calls send an `x-errorgap-trace` header. The WSGI middleware (and so
-`init_app`) records it, and `track_transaction(..., trace_id=header)` accepts
+API calls send an `x-errorgap-trace` header. The WSGI, Django and FastAPI
+middleware (and so Flask's `init_app`) record it, and `track_transaction(..., trace_id=header)` accepts
 it, so errorgap's browser Performance view links each call to the server
 request that answered it. Malformed values are ignored.
 
@@ -134,6 +139,12 @@ app = FastAPI()
 app.add_middleware(ErrorgapMiddleware)
 ```
 
+With `apm_enabled=True` each request is also an APM transaction grouped by
+its route path (`/orders/{order_id}`); errors raised during it carry its
+transaction id, and the browser SDK's `x-errorgap-trace` header is recorded.
+Record spans from an endpoint with `errorgap.fastapi.spans(request).database(sql, ms)`
+(take `request: Request` as a parameter).
+
 ## Configuration reference
 
 | Argument | Default | Notes |

{errorgap-0.2.0 → errorgap-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "errorgap"
-version = "0.2.0"
+version = "0.3.0"
 description = "Python notifier for Errorgap error tracking."
 readme = "README.md"
 license = { text = "MIT" }

{errorgap-0.2.0 → errorgap-0.3.0}/src/errorgap/django.py

@@ -1,12 +1,22 @@
 from __future__ import annotations
 
+import time
+from datetime import datetime, timezone
 from typing import Any, Callable, Dict, Optional
 
 from . import notify
+from .apm import SpanCollector, Transaction, browser_trace_id
+from .transaction_context import new_transaction_id, transaction_scope
+
+_TRANSACTION_ATTR = "errorgap_transaction"
 
 
 class ErrorgapMiddleware:
-    """Django middleware that reports unhandled exceptions to Errorgap.
+    """Django middleware that reports unhandled exceptions to Errorgap and
+    times each request as an APM transaction (sent with ``apm_enabled``),
+    grouped by its URL pattern. Errors raised during the request carry its
+    transaction id, and the browser SDK's ``x-errorgap-trace`` header links
+    the browser's view of the call to it.
 
     Add ``"errorgap.django.ErrorgapMiddleware"`` to ``MIDDLEWARE``. Place it
     early so it sees exceptions raised by inner middleware too.
@@ -16,7 +26,30 @@ class ErrorgapMiddleware:
         self.get_response = get_response
 
     def __call__(self, request: Any) -> Any:
-        return self.get_response(request)
+        meta = getattr(request, "META", {}) or {}
+        txn = Transaction(
+            kind="web",
+            id=new_transaction_id(),
+            trace_id=browser_trace_id(meta.get("HTTP_X_ERRORGAP_TRACE")),
+            method=getattr(request, "method", None),
+            path_raw=getattr(request, "path", None) or "/",
+            occurred_at=datetime.now(timezone.utc).isoformat(timespec="milliseconds").replace("+00:00", "Z"),
+        )
+        try:
+            setattr(request, _TRANSACTION_ATTR, txn)
+        except Exception:  # noqa: BLE001
+            pass
+        start = time.perf_counter()
+        response = None
+        try:
+            with transaction_scope(txn.id or new_transaction_id()):
+                response = self.get_response(request)
+            return response
+        finally:
+            txn.status_code = getattr(response, "status_code", None) or 500
+            txn.duration_ms = (time.perf_counter() - start) * 1000.0
+            txn.path = _route(request) or txn.path_raw
+            _send_transaction(txn)
 
     def process_exception(self, request: Any, exception: BaseException) -> Optional[Any]:
         notify(
@@ -31,6 +64,28 @@ class ErrorgapMiddleware:
         return None
 
 
+def spans(request: Any) -> Optional[SpanCollector]:
+    """The span collector for ``request``'s transaction, for recording DB and
+    outbound HTTP spans from views."""
+    txn = getattr(request, _TRANSACTION_ATTR, None)
+    return txn.spans if txn is not None else None
+
+
+def _route(request: Any) -> Optional[str]:
+    """The matched URL pattern (``/orders/<int:id>``), when one matched."""
+    match = getattr(request, "resolver_match", None)
+    route = getattr(match, "route", None) if match is not None else None
+    if not route:
+        return None
+    return route if route.startswith("/") else "/" + route
+
+
+def _send_transaction(txn: Transaction) -> None:
+    import errorgap
+
+    errorgap.notify_transaction(txn)
+
+
 def _context(request: Any) -> Dict[str, Any]:
     try:
         resolver = getattr(request, "resolver_match", None)

errorgap-0.3.0/src/errorgap/fastapi.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import time
+from datetime import datetime, timezone
+from typing import Any, Callable, Dict, Optional
+
+from . import notify
+from .apm import SpanCollector, Transaction, browser_trace_id
+from .transaction_context import new_transaction_id, transaction_scope
+
+#: ASGI scope key holding the request's :class:`~errorgap.apm.Transaction`.
+TRANSACTION_KEY = "errorgap.transaction"
+
+
+class ErrorgapMiddleware:
+    """Pure ASGI middleware that reports unhandled exceptions to Errorgap and
+    times each request as an APM transaction (sent with ``apm_enabled``),
+    grouped by its route path (``/orders/{order_id}``). Errors raised during
+    the request carry its transaction id, and the browser SDK's
+    ``x-errorgap-trace`` header links the browser's view of the call to it.
+
+    Usage::
+
+        from fastapi import FastAPI
+        from errorgap.fastapi import ErrorgapMiddleware
+
+        app = FastAPI()
+        app.add_middleware(ErrorgapMiddleware)
+    """
+
+    def __init__(self, app: Callable[..., Any]) -> None:
+        self.app = app
+
+    async def __call__(self, scope: Dict[str, Any], receive: Callable, send: Callable) -> None:
+        if scope.get("type") != "http":
+            await self.app(scope, receive, send)
+            return
+
+        headers = dict(scope.get("headers", []))
+        txn = Transaction(
+            kind="web",
+            id=new_transaction_id(),
+            trace_id=browser_trace_id(headers.get(b"x-errorgap-trace")),
+            method=scope.get("method"),
+            path_raw=scope.get("path") or "/",
+            occurred_at=datetime.now(timezone.utc).isoformat(timespec="milliseconds").replace("+00:00", "Z"),
+        )
+        scope[TRANSACTION_KEY] = txn
+        start = time.perf_counter()
+
+        async def _send(message: Dict[str, Any]) -> None:
+            if message.get("type") == "http.response.start":
+                txn.status_code = message.get("status")
+            await send(message)
+
+        try:
+            with transaction_scope(txn.id or new_transaction_id()):
+                try:
+                    await self.app(scope, receive, _send)
+                except Exception as exc:
+                    txn.status_code = 500
+                    notify(
+                        exc,
+                        sync=True,
+                        context=_context(scope),
+                        environment=_environment(scope),
+                    )
+                    raise
+        finally:
+            import errorgap
+
+            txn.duration_ms = (time.perf_counter() - start) * 1000.0
+            txn.path = _route(scope) or txn.path_raw
+            if txn.status_code is None:
+                txn.status_code = 500
+            errorgap.notify_transaction(txn)
+
+
+def spans(request: Any) -> Optional[SpanCollector]:
+    """The span collector for the request's transaction (a Starlette/FastAPI
+    ``Request``), for recording DB and outbound HTTP spans from endpoints."""
+    txn = getattr(request, "scope", {}).get(TRANSACTION_KEY)
+    return txn.spans if txn is not None else None
+
+
+def _route(scope: Dict[str, Any]) -> Optional[str]:
+    """The matched route's path template, which FastAPI's router records."""
+    route = scope.get("route")
+    path = getattr(route, "path", None)
+    return path if isinstance(path, str) and path else None
+
+
+def _context(scope: Dict[str, Any]) -> Dict[str, Any]:
+    return {
+        "url": _build_url(scope),
+        "component": scope.get("path"),
+        "action": scope.get("method"),
+    }
+
+
+def _environment(scope: Dict[str, Any]) -> Dict[str, Any]:
+    headers = {k.decode("latin1"): v.decode("latin1") for k, v in scope.get("headers", [])}
+    client = scope.get("client") or (None, None)
+    return {
+        "method": scope.get("method"),
+        "path": scope.get("path"),
+        "query_string": scope.get("query_string", b"").decode("utf-8", errors="replace"),
+        "user_agent": headers.get("user-agent"),
+        "remote_addr": client[0],
+    }
+
+
+def _build_url(scope: Dict[str, Any]) -> str:
+    scheme = scope.get("scheme", "http")
+    headers = dict(scope.get("headers", []))
+    host = headers.get(b"host", b"").decode("latin1") or "localhost"
+    path = scope.get("path", "/")
+    query = scope.get("query_string", b"").decode("utf-8", errors="replace")
+    suffix = f"?{query}" if query else ""
+    return f"{scheme}://{host}{path}{suffix}"

errorgap-0.3.0/src/errorgap/version.py

@@ -0,0 +1 @@
+VERSION = "0.3.0"

errorgap-0.3.0/tests/test_django.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import pytest
+
+django = pytest.importorskip("django")
+
+from django.conf import settings
+from django.http import HttpResponse
+from django.test import RequestFactory
+from django.urls import path
+
+import errorgap
+from errorgap.django import ErrorgapMiddleware
+
+
+@pytest.fixture(scope="module", autouse=True)
+def _django_setup():
+    if not settings.configured:
+        settings.configure(
+            DEBUG=False,
+            ALLOWED_HOSTS=["*"],
+            ROOT_URLCONF=__name__,
+            DATABASES={},
+            INSTALLED_APPS=[],
+            MIDDLEWARE=[],
+            SECRET_KEY="test",
+            DEFAULT_AUTO_FIELD="django.db.models.BigAutoField",
+        )
+        import django as _django
+
+        _django.setup()
+
+
+def _boom(_request):
+    raise RuntimeError("django-boom")
+
+
+urlpatterns = [path("boom", _boom)]
+
+
+def test_middleware_reports_exception(ingestor, reset_errorgap):
+    errorgap.init(
+        endpoint=ingestor.endpoint,
+        project_slug="demo",
+        api_key="flk_test",
+        async_=False,
+        capture_globals=False,
+    )
+
+    factory = RequestFactory()
+    request = factory.get("/boom?x=1")
+
+    middleware = ErrorgapMiddleware(get_response=lambda req: HttpResponse(""))
+
+    try:
+        _boom(request)
+    except RuntimeError as exc:
+        middleware.process_exception(request, exc)
+
+    errorgap.flush(timeout=5)
+    assert len(ingestor.requests) == 1
+    body = ingestor.requests[0].body
+    assert body["errors"][0]["type"] == "RuntimeError"
+    assert body["errors"][0]["message"] == "django-boom"
+    assert body["context"]["action"] == "GET"
+
+
+def _order(request, order_id):
+    from errorgap.django import spans
+
+    spans(request).database("SELECT * FROM orders WHERE id = %d" % order_id, 1.0)
+    errorgap.notify(RuntimeError("card declined"))
+    return HttpResponse("ok", status=201)
+
+
+urlpatterns.append(path("orders/<int:order_id>", _order))
+
+
+def test_requests_are_transactions_linked_to_their_errors(ingestor, reset_errorgap):
+    from django.test import Client
+
+    errorgap.init(
+        endpoint=ingestor.endpoint,
+        project_slug="demo",
+        async_=False,
+        capture_globals=False,
+        apm_enabled=True,
+    )
+    settings.MIDDLEWARE = ["errorgap.django.ErrorgapMiddleware"]
+    try:
+        client = Client(raise_request_exception=False)
+        ok = client.get("/orders/7", HTTP_X_ERRORGAP_TRACE="0192F3C4-7A1B-4C2D-9E3F-0123456789AB")
+        boom = client.get("/boom")
+    finally:
+        settings.MIDDLEWARE = []
+    assert ok.status_code == 201
+    assert boom.status_code == 500
+
+    txns = [r.body for r in ingestor.requests if r.path.endswith("/transactions")]
+    notices = [r.body for r in ingestor.requests if r.path.endswith("/notices")]
+    ok_txn = next(t for t in txns if t["path_raw"] == "/orders/7")
+    boom_txn = next(t for t in txns if t["path_raw"] == "/boom")
+    assert ok_txn["path"] == "/orders/<int:order_id>"
+    assert ok_txn["status_code"] == 201
+    assert ok_txn["trace_id"] == "0192f3c4-7a1b-4c2d-9e3f-0123456789ab"
+    assert ok_txn["spans"][0]["sql"] == "SELECT * FROM orders WHERE id = ?"
+    assert boom_txn["status_code"] == 500
+    assert "trace_id" not in boom_txn
+    by_message = {n["errors"][0]["message"]: n["context"].get("transaction_id") for n in notices}
+    assert by_message["card declined"] == ok_txn["id"]
+    assert by_message["django-boom"] == boom_txn["id"]

errorgap-0.3.0/tests/test_fastapi.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import pytest
+
+fastapi = pytest.importorskip("fastapi")
+
+from fastapi import FastAPI, Request
+from starlette.testclient import TestClient
+
+import errorgap
+from errorgap.fastapi import ErrorgapMiddleware, spans
+
+
+def test_fastapi_middleware_reports_exception(ingestor, reset_errorgap):
+    errorgap.init(
+        endpoint=ingestor.endpoint,
+        project_slug="demo",
+        api_key="flk_test",
+        async_=False,
+        capture_globals=False,
+    )
+
+    app = FastAPI()
+    app.add_middleware(ErrorgapMiddleware)
+
+    @app.get("/boom")
+    def boom():
+        raise RuntimeError("fastapi-boom")
+
+    client = TestClient(app, raise_server_exceptions=False)
+    response = client.get("/boom?x=1")
+    assert response.status_code == 500
+
+    errorgap.flush(timeout=5)
+    assert len(ingestor.requests) == 1
+    body = ingestor.requests[0].body
+    assert body["errors"][0]["type"] == "RuntimeError"
+    assert body["errors"][0]["message"] == "fastapi-boom"
+    assert body["context"]["action"] == "GET"
+
+
+def test_fastapi_requests_are_transactions_linked_to_their_errors(ingestor, reset_errorgap):
+    errorgap.init(
+        endpoint=ingestor.endpoint,
+        project_slug="demo",
+        async_=False,
+        capture_globals=False,
+        apm_enabled=True,
+    )
+
+    app = FastAPI()
+    app.add_middleware(ErrorgapMiddleware)
+
+    @app.get("/orders/{order_id}", status_code=201)
+    async def order(order_id: int, request: Request):
+        spans(request).database("SELECT * FROM orders WHERE id = %d" % order_id, 1.0)
+        errorgap.notify(RuntimeError("card declined"))
+        return {"id": order_id}
+
+    @app.get("/sync/{n}")
+    def sync_boom(n: int):
+        raise RuntimeError("fastapi-boom")
+
+    client = TestClient(app, raise_server_exceptions=False)
+    ok = client.get("/orders/7", headers={"x-errorgap-trace": "0192F3C4-7A1B-4C2D-9E3F-0123456789AB"})
+    boom = client.get("/sync/1")
+    assert ok.status_code == 201
+    assert boom.status_code == 500
+
+    txns = [r.body for r in ingestor.requests if r.path.endswith("/transactions")]
+    notices = [r.body for r in ingestor.requests if r.path.endswith("/notices")]
+    ok_txn = next(t for t in txns if t["path_raw"] == "/orders/7")
+    boom_txn = next(t for t in txns if t["path_raw"] == "/sync/1")
+    assert ok_txn["path"] == "/orders/{order_id}"
+    assert ok_txn["status_code"] == 201
+    assert ok_txn["trace_id"] == "0192f3c4-7a1b-4c2d-9e3f-0123456789ab"
+    assert ok_txn["spans"][0]["sql"] == "SELECT * FROM orders WHERE id = ?"
+    assert boom_txn["path"] == "/sync/{n}"
+    assert boom_txn["status_code"] == 500
+    by_message = {n["errors"][0]["message"]: n["context"].get("transaction_id") for n in notices}
+    assert by_message["card declined"] == ok_txn["id"]
+    assert by_message["fastapi-boom"] == boom_txn["id"]

errorgap-0.2.0/src/errorgap/fastapi.py

@@ -1,67 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Callable, Dict
-
-from . import notify
-
-
-class ErrorgapMiddleware:
-    """Pure ASGI middleware that reports unhandled exceptions to Errorgap.
-
-    Usage::
-
-        from fastapi import FastAPI
-        from errorgap.fastapi import ErrorgapMiddleware
-
-        app = FastAPI()
-        app.add_middleware(ErrorgapMiddleware)
-    """
-
-    def __init__(self, app: Callable[..., Any]) -> None:
-        self.app = app
-
-    async def __call__(self, scope: Dict[str, Any], receive: Callable, send: Callable) -> None:
-        if scope.get("type") != "http":
-            await self.app(scope, receive, send)
-            return
-
-        try:
-            await self.app(scope, receive, send)
-        except Exception as exc:
-            notify(
-                exc,
-                sync=True,
-                context=_context(scope),
-                environment=_environment(scope),
-            )
-            raise
-
-
-def _context(scope: Dict[str, Any]) -> Dict[str, Any]:
-    return {
-        "url": _build_url(scope),
-        "component": scope.get("path"),
-        "action": scope.get("method"),
-    }
-
-
-def _environment(scope: Dict[str, Any]) -> Dict[str, Any]:
-    headers = {k.decode("latin1"): v.decode("latin1") for k, v in scope.get("headers", [])}
-    client = scope.get("client") or (None, None)
-    return {
-        "method": scope.get("method"),
-        "path": scope.get("path"),
-        "query_string": scope.get("query_string", b"").decode("utf-8", errors="replace"),
-        "user_agent": headers.get("user-agent"),
-        "remote_addr": client[0],
-    }
-
-
-def _build_url(scope: Dict[str, Any]) -> str:
-    scheme = scope.get("scheme", "http")
-    headers = dict(scope.get("headers", []))
-    host = headers.get(b"host", b"").decode("latin1") or "localhost"
-    path = scope.get("path", "/")
-    query = scope.get("query_string", b"").decode("utf-8", errors="replace")
-    suffix = f"?{query}" if query else ""
-    return f"{scheme}://{host}{path}{suffix}"

errorgap-0.2.0/src/errorgap/version.py

@@ -1 +0,0 @@
-VERSION = "0.2.0"

errorgap-0.2.0/tests/test_django.py

@@ -1,65 +0,0 @@
-from __future__ import annotations
-
-import pytest
-
-django = pytest.importorskip("django")
-
-from django.conf import settings
-from django.http import HttpResponse
-from django.test import RequestFactory
-from django.urls import path
-
-import errorgap
-from errorgap.django import ErrorgapMiddleware
-
-
-@pytest.fixture(scope="module", autouse=True)
-def _django_setup():
-    if not settings.configured:
-        settings.configure(
-            DEBUG=False,
-            ALLOWED_HOSTS=["*"],
-            ROOT_URLCONF=__name__,
-            DATABASES={},
-            INSTALLED_APPS=[],
-            MIDDLEWARE=[],
-            SECRET_KEY="test",
-            DEFAULT_AUTO_FIELD="django.db.models.BigAutoField",
-        )
-        import django as _django
-
-        _django.setup()
-
-
-def _boom(_request):
-    raise RuntimeError("django-boom")
-
-
-urlpatterns = [path("boom", _boom)]
-
-
-def test_middleware_reports_exception(ingestor, reset_errorgap):
-    errorgap.init(
-        endpoint=ingestor.endpoint,
-        project_slug="demo",
-        api_key="flk_test",
-        async_=False,
-        capture_globals=False,
-    )
-
-    factory = RequestFactory()
-    request = factory.get("/boom?x=1")
-
-    middleware = ErrorgapMiddleware(get_response=lambda req: HttpResponse(""))
-
-    try:
-        _boom(request)
-    except RuntimeError as exc:
-        middleware.process_exception(request, exc)
-
-    errorgap.flush(timeout=5)
-    assert len(ingestor.requests) == 1
-    body = ingestor.requests[0].body
-    assert body["errors"][0]["type"] == "RuntimeError"
-    assert body["errors"][0]["message"] == "django-boom"
-    assert body["context"]["action"] == "GET"

errorgap-0.2.0/tests/test_fastapi.py

@@ -1,39 +0,0 @@
-from __future__ import annotations
-
-import pytest
-
-fastapi = pytest.importorskip("fastapi")
-
-from fastapi import FastAPI
-from starlette.testclient import TestClient
-
-import errorgap
-from errorgap.fastapi import ErrorgapMiddleware
-
-
-def test_fastapi_middleware_reports_exception(ingestor, reset_errorgap):
-    errorgap.init(
-        endpoint=ingestor.endpoint,
-        project_slug="demo",
-        api_key="flk_test",
-        async_=False,
-        capture_globals=False,
-    )
-
-    app = FastAPI()
-    app.add_middleware(ErrorgapMiddleware)
-
-    @app.get("/boom")
-    def boom():
-        raise RuntimeError("fastapi-boom")
-
-    client = TestClient(app, raise_server_exceptions=False)
-    response = client.get("/boom?x=1")
-    assert response.status_code == 500
-
-    errorgap.flush(timeout=5)
-    assert len(ingestor.requests) == 1
-    body = ingestor.requests[0].body
-    assert body["errors"][0]["type"] == "RuntimeError"
-    assert body["errors"][0]["message"] == "fastapi-boom"
-    assert body["context"]["action"] == "GET"