devbench 0.1.0__tar.gz → 0.2.0__tar.gz

{devbench-0.1.0 → devbench-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devbench
-Version: 0.1.0
+Version: 0.2.0
 Summary: Dev Bench server SDK for Python: errors, who was affected, and the server log lines of a failing request, for Django, FastAPI, Flask and Celery.
 Author: Dev Bench
 License-Expression: MIT
@@ -153,6 +153,39 @@ the user.
   reporting is dropped, and the application's own exception always comes
   out unchanged.
 
+### Failed, slow and rate-limited requests
+
+The same middleware also watches what each request does *without* raising
+(no code needed; Django, Flask, FastAPI/Starlette and bare WSGI/ASGI):
+
+| Signal | When | Reported as |
+|---|---|---|
+| Failed | the app answered 500–599 and nothing was reported as an exception during the request | kind `error`, type `http_<status>` |
+| Slow | the app took **more than 3,000 ms** and answered 100–499 | kind `degradation`, type `slow_request` |
+| 429 spike | in one unix minute, a route answered at least ten 429s and at least 10% of its requests were 429s | kind `error`, type `http_429_spike` |
+
+- **Exceptions win.** An unhandled error, or a `capture_exception` during
+  the request, is the report on its own: its 500 is not also failed. A
+  `report_handled` changes nothing: a 5xx after it is still failed, and the
+  `x-adt-handled` header is unchanged. Each status is its own problem
+  (`http_500`, `http_503`). Raising an `HTTPException` with a 5xx status is
+  a response, so it is failed.
+- **Slow** is measured on a monotonic clock from the middleware's entry
+  until the app hands back its response (the WSGI callable returns, the
+  ASGI app's coroutine completes, Django's `get_response` returns).
+  Exactly 3,000 ms is not slow. Event streams (`text/event-stream`) are
+  never slow; a streaming 5xx is still failed. The threshold is a
+  constant, not a setting, for now.
+- **429 spikes** are counted per process and reported once per route per
+  minute, when the minute closes (the next request in a later minute, the
+  next flush, or process exit), with no trace or user.
+- Other 4xx are not reported. Each signal is identified by the method and
+  the route **pattern**, never the raw path: Django's
+  `resolver_match.route` (`orders/<int:id>`), Flask's URL rule
+  (`/orders/<int:id>`), the FastAPI/Starlette route path
+  (`/orders/{id}`), or `*` when no route matched (and for a bare WSGI/ASGI
+  app). A failed or slow request carries its trace and user.
+
 ## What is sent, and when
 
 - Each report is **fingerprinted and counted in the process** (class,

{devbench-0.1.0 → devbench-0.2.0}/README.md

@@ -134,6 +134,39 @@ the user.
   reporting is dropped, and the application's own exception always comes
   out unchanged.
 
+### Failed, slow and rate-limited requests
+
+The same middleware also watches what each request does *without* raising
+(no code needed; Django, Flask, FastAPI/Starlette and bare WSGI/ASGI):
+
+| Signal | When | Reported as |
+|---|---|---|
+| Failed | the app answered 500–599 and nothing was reported as an exception during the request | kind `error`, type `http_<status>` |
+| Slow | the app took **more than 3,000 ms** and answered 100–499 | kind `degradation`, type `slow_request` |
+| 429 spike | in one unix minute, a route answered at least ten 429s and at least 10% of its requests were 429s | kind `error`, type `http_429_spike` |
+
+- **Exceptions win.** An unhandled error, or a `capture_exception` during
+  the request, is the report on its own: its 500 is not also failed. A
+  `report_handled` changes nothing: a 5xx after it is still failed, and the
+  `x-adt-handled` header is unchanged. Each status is its own problem
+  (`http_500`, `http_503`). Raising an `HTTPException` with a 5xx status is
+  a response, so it is failed.
+- **Slow** is measured on a monotonic clock from the middleware's entry
+  until the app hands back its response (the WSGI callable returns, the
+  ASGI app's coroutine completes, Django's `get_response` returns).
+  Exactly 3,000 ms is not slow. Event streams (`text/event-stream`) are
+  never slow; a streaming 5xx is still failed. The threshold is a
+  constant, not a setting, for now.
+- **429 spikes** are counted per process and reported once per route per
+  minute, when the minute closes (the next request in a later minute, the
+  next flush, or process exit), with no trace or user.
+- Other 4xx are not reported. Each signal is identified by the method and
+  the route **pattern**, never the raw path: Django's
+  `resolver_match.route` (`orders/<int:id>`), Flask's URL rule
+  (`/orders/<int:id>`), the FastAPI/Starlette route path
+  (`/orders/{id}`), or `*` when no route matched (and for a bare WSGI/ASGI
+  app). A failed or slow request carries its trace and user.
+
 ## What is sent, and when
 
 - Each report is **fingerprinted and counted in the process** (class,

{devbench-0.1.0 → devbench-0.2.0}/devbench/__init__.py

@@ -13,6 +13,8 @@ What it does:
 * accepts and forwards the correlation id     (the middlewares, trace_headers)
 * reports unhandled exceptions                (the middlewares, Celery hooks,
                                                capture_exception)
+* reports 5xx answered without an exception,
+  requests over 3 s and 429 spikes            (the middlewares; reqsignal)
 * reports handled failures                    (report_handled)
 * records who was affected                    (set_user)
 * keeps recent log lines per trace            (capture_logs; a logging handler)
@@ -29,12 +31,12 @@ from .config import DSN, Configuration, InvalidDSN
 from .identity import set_user
 from .trace import HEADER as TRACE_HEADER
 from .trace import Trace
-from .version import PROTOCOL_VERSION, VERSION
+from .version import PROTOCOL_VERSION, SDK_NAME, VERSION
 
 __version__ = VERSION
 
 __all__ = [
-    "PROTOCOL_VERSION", "VERSION", "DSN", "Configuration", "InvalidDSN", "Trace", "TRACE_HEADER",
+    "PROTOCOL_VERSION", "VERSION", "SDK_NAME", "DSN", "Configuration", "InvalidDSN", "Trace", "TRACE_HEADER",
     "configure", "enabled", "set_user", "capture_exception", "report_handled", "ignore_exceptions",
     "trace_headers", "current_trace", "capture_logs", "flush", "test",
 ]

{devbench-0.1.0 → devbench-0.2.0}/devbench/_core.py

@@ -247,6 +247,8 @@ def _exit_flush() -> None:
     current = _transport
     if isinstance(current, DirectTransport):
         try:
+            # The open 429 spike window is evaluated as it stands at exit.
+            current.end_requests()
             current.flush(timeout=EXIT_TIMEOUT)
         except Exception:
             pass

devbench-0.2.0/devbench/_requests.py

@@ -0,0 +1,145 @@
+"""How the request middlewares observe Capability 2b (reqsignal has the
+rules).
+
+Once per request, after the application has handed back its response
+without raising: classify it (failed / slow / nothing), report the signal
+like any other report, and feed the process's 429 spike detector. On the
+request's thread, none of it blocking: a classification, a count under a
+lock, one mutex-guarded table update.
+
+A request that raised out of the middleware is not evaluated: the exception
+is its report. Only the outermost Dev Bench middleware observes (a nested one
+passes straight through), so a request is never counted twice.
+"""
+
+from __future__ import annotations
+
+import threading
+from typing import Any, Iterable, Optional, Tuple
+
+from . import _core, context, reporter, reqsignal
+
+
+# Requests evaluated in this process. A test seam: an ASGI request is
+# evaluated after its response has reached the client (when the app's
+# coroutine completes), so a test waits for this to move. Changes nothing.
+_finished = 0
+_finished_lock = threading.Lock()
+
+
+def finished() -> int:
+    return _finished
+
+
+class Request:
+    """One request being observed, held on the request's Scope."""
+
+    __slots__ = ("method", "route", "started", "exception_reported")
+
+    def __init__(self, method: Any) -> None:
+        self.method = method
+        # The framework's matched route pattern, set when routing ran; None
+        # reports as "*".
+        self.route: Optional[str] = None
+        self.started = reqsignal.monotonic_ns()
+        # An `exception` was reported during this request (any context).
+        self.exception_reported = False
+
+
+def observing() -> bool:
+    """True inside a request an outer Dev Bench middleware already
+    observes."""
+    scope = context.current()
+    return scope is not None and scope.request is not None
+
+
+def begin(scope: context.Scope, method: Any) -> Optional[Request]:
+    """Starts observing the request ``scope`` belongs to. None when this
+    process reports nothing (no DSN, or a DSN that does not parse): then
+    nothing is timed or counted. Never raises."""
+    try:
+        if not _core.direct():
+            return None
+        request = Request(method)
+        scope.request = request
+        return request
+    except Exception:
+        return None
+
+
+def set_route(route: Any) -> None:
+    """Records the matched route pattern on the request being observed."""
+    try:
+        scope = context.current()
+        request = scope.request if scope is not None else None
+        if request is not None and route is not None:
+            request.route = str(route)
+    except Exception:
+        pass
+
+
+def elapsed_ms(request: Request) -> int:
+    """Whole milliseconds since the middleware's entry (truncated, so 3000.9
+    ms is 3000: not slow)."""
+    return (reqsignal.monotonic_ns() - request.started) // 1000000
+
+
+def finish(request: Optional[Request], status: Any, streaming: bool, duration_ms: Optional[int] = None) -> None:
+    """The application handed back its response: classify, report, feed the
+    spike detector. ``duration_ms`` defaults to the time since the
+    middleware's entry. Never raises."""
+    if request is None:
+        return
+    try:
+        if duration_ms is None:
+            duration_ms = elapsed_ms(request)
+        code = status_code(status)
+        method = reqsignal.normalize_method(request.method)
+        route = reqsignal.normalize_route(request.route)
+        signal = reqsignal.classify(code, duration_ms, request.exception_reported, streaming)
+        if signal:
+            reporter.report_request(signal, method, route, code, duration_ms)
+        observe = getattr(_core.transport(), "observe_request", None)
+        if observe is not None:
+            observe(reqsignal.now_ms(), method, route, code)
+    except Exception:
+        pass
+    finally:
+        global _finished
+        with _finished_lock:
+            _finished += 1
+
+
+def status_code(status: Any) -> int:
+    """An int from 503, "503 Service Unavailable" (WSGI) or b"503"; 0 when
+    there is none."""
+    try:
+        if isinstance(status, int):
+            return status
+        if isinstance(status, bytes):
+            status = status.decode("latin-1")
+        head = str(status).strip().split(" ", 1)[0]
+        return int(head) if head.isdigit() and len(head) == 3 else 0
+    except Exception:
+        return 0
+
+
+def event_stream(content_type: Any) -> bool:
+    """A ``text/event-stream`` response (any case, parameters allowed): a
+    connection's lifetime, never slow."""
+    try:
+        if isinstance(content_type, bytes):
+            content_type = content_type.decode("latin-1")
+        return str(content_type or "").strip().lower().startswith("text/event-stream")
+    except Exception:
+        return False
+
+
+def header(headers: Optional[Iterable[Tuple[Any, Any]]], name: str) -> Any:
+    """The first value of a header in a WSGI/ASGI header list."""
+    want = name.lower()
+    for key, value in headers or ():
+        k = key.decode("latin-1") if isinstance(key, bytes) else str(key)
+        if k.lower() == want:
+            return value
+    return None

{devbench-0.1.0 → devbench-0.2.0}/devbench/asgi.py

@@ -18,7 +18,7 @@ from __future__ import annotations
 
 from typing import Any, Awaitable, Callable, MutableMapping, Optional
 
-from . import _core, _integration, context
+from . import _core, _integration, _requests, context
 from .trace import Trace
 
 Scope = MutableMapping[str, Any]
@@ -38,22 +38,41 @@ class DevbenchMiddleware:
         if scope.get("type") != "http" or not _core.enabled():
             await self.app(scope, receive, send)
             return
+        # Inside another Dev Bench middleware: that one scopes, reports and
+        # observes this request.
+        if _requests.observing():
+            await self.app(scope, receive, send)
+            return
         trace = _parse(scope)
+        answered: list = []
 
         async def send_wrapper(message: Message) -> None:
             if message.get("type") == "http.response.start":
+                try:
+                    if not answered:
+                        answered[:] = [message.get("status"), _requests.header(message.get("headers"), "content-type")]
+                except Exception:
+                    pass
                 try:
                     message = _with_handled(message)
                 except Exception:
                     pass
             await send(message)
 
-        with context.scoped(trace):
+        with context.scoped(trace) as request_scope:
+            request = _requests.begin(request_scope, scope.get("method"))
             try:
                 await self.app(scope, receive, send_wrapper)
             except Exception as error:
                 _integration.report_request_error(error, _symbol(scope))
                 raise
+            if request is not None:
+                # An app that returned without answering: the server sends
+                # 500 (uvicorn, hypercorn), and nothing was reported.
+                status = answered[0] if answered else 500
+                content_type = answered[1] if answered else None
+                request.route = _route(scope)
+                _requests.finish(request, status, _requests.event_stream(content_type))
 
 
 def _parse(scope: Scope) -> Optional[Trace]:
@@ -66,6 +85,25 @@ def _parse(scope: Scope) -> Optional[Trace]:
     return None
 
 
+def _route(scope: Scope) -> Optional[str]:
+    """The matched route's pattern: ``scope["route"].path`` (FastAPI, and
+    Starlette since it records the route), else the route whose endpoint the
+    router put in the scope. None (reported as "*") when nothing matched."""
+    try:
+        route = scope.get("route")
+        path = getattr(route, "path", None) if route is not None else None
+        if not isinstance(path, str):
+            endpoint, router = scope.get("endpoint"), scope.get("router")
+            if endpoint is not None and router is not None:
+                for candidate in getattr(router, "routes", None) or ():
+                    if getattr(candidate, "endpoint", None) is endpoint:
+                        path = getattr(candidate, "path", None)
+                        break
+        return path if isinstance(path, str) else None
+    except Exception:
+        return None
+
+
 def _symbol(scope: Scope) -> Optional[str]:
     # Starlette's router puts the matched endpoint in the scope.
     endpoint = scope.get("endpoint")

{devbench-0.1.0 → devbench-0.2.0}/devbench/config.py

@@ -1,5 +1,5 @@
 """Where reports go, parsed from DEVBENCH_DSN, and everything else read at
-start (docs/SERVER_SDK_SPEC.md, "Dev Bench naming and configuration";
+start (docs/server-sdk/configuration.md, "Dev Bench naming and configuration";
 DECISIONS #161)."""
 
 from __future__ import annotations

{devbench-0.1.0 → devbench-0.2.0}/devbench/context.py

@@ -18,13 +18,13 @@ from __future__ import annotations
 
 import contextlib
 import contextvars
-from typing import Iterator, Optional
+from typing import Any, Iterator, Optional
 
 from .trace import Trace
 
 
 class Scope:
-    __slots__ = ("trace", "user", "handled", "__weakref__")
+    __slots__ = ("trace", "user", "handled", "request", "__weakref__")
 
     def __init__(self, trace: Optional[Trace] = None) -> None:
         self.trace = trace
@@ -34,6 +34,9 @@ class Scope:
         # Failures handled during this request: the middleware turns a
         # non-zero count into the x-adt-handled response header.
         self.handled = 0
+        # The request middleware's observation (devbench._requests.Request)
+        # while a request is being observed; None in a job or a script.
+        self.request: Optional[Any] = None
 
 
 _SCOPE: "contextvars.ContextVar[Optional[Scope]]" = contextvars.ContextVar("devbench_scope", default=None)
@@ -80,6 +83,20 @@ def scoped(trace: Optional[Trace]) -> Iterator[Scope]:
             _SCOPE.set(None)
 
 
+@contextlib.contextmanager
+def within(scope: Scope) -> Iterator[Scope]:
+    """Runs the block in an existing scope (a WSGI body closed after the
+    middleware returned), restoring whatever was there before."""
+    token = _SCOPE.set(scope)
+    try:
+        yield scope
+    finally:
+        try:
+            _SCOPE.reset(token)
+        except ValueError:
+            _SCOPE.set(None)
+
+
 def enter(trace: Optional[Trace]) -> "tuple[Scope, contextvars.Token]":
     """For hooks whose start and end are separate calls (Celery's prerun and
     postrun): returns the new scope and the token ``leave`` needs."""

{devbench-0.1.0 → devbench-0.2.0}/devbench/direct.py

@@ -1,4 +1,4 @@
-"""Direct mode (docs/SERVER_SDK_SPEC.md, "Direct mode"): fingerprint and
+"""Direct mode (docs/server-sdk/transports.md, "Direct mode"): fingerprint and
 count in-process, flush counts to ingest once a minute, upload one redacted
 evidence bundle per fingerprint only when ingest asks, and answer ingest's
 requests for the log lines of a trace (need_logs) from the in-process buffer,
@@ -34,10 +34,10 @@ import urllib.error
 import urllib.request
 from typing import IO, Any, Dict, List, Optional, Tuple
 
-from . import fingerprint, logs, scrub
+from . import fingerprint, logs, reqsignal, scrub
 from .config import DSN
 from .egress_policy import EgressPolicy
-from .version import PROTOCOL_VERSION, VERSION
+from .version import PROTOCOL_VERSION, SDK_NAME, VERSION
 
 MAX_FINGERPRINTS = 512
 MAX_USERS = 20
@@ -56,6 +56,8 @@ MAX_SLICE_BYTES = 64 * 1024
 MAX_SLICES_PER_POST = 25
 HTTP_TIMEOUT = 5.0
 EXIT_TIMEOUT = 2.0
+# Which SDK sent a flush, on every request of it (#310).
+_SDK_FIELD = {"name": SDK_NAME, "version": VERSION}
 
 
 class _Count:
@@ -146,9 +148,33 @@ class DirectTransport:
         except Exception:
             return False
 
+    def observe_request(self, t_ms: int, method: str, route: str, status: int) -> None:
+        """Feeds one finished request to this process's 429 spike detector
+        (Capability 2b) and counts the spikes of any window it closed. The
+        first 429 starts the flush thread, so a process answering nothing but
+        429s still reports its spike within a minute. Never raises, never
+        does I/O."""
+        try:
+            self._check_fork()
+            closed = self._spikes.observe(t_ms, method, route, status)
+            if status == 429:
+                self._ensure_running()
+            self._record_spikes(closed)
+        except Exception:
+            pass
+
+    def end_requests(self) -> None:
+        """Process exit: the open spike window is evaluated as it stands."""
+        try:
+            self._check_fork()
+            self._record_spikes(self._spikes.end())
+        except Exception:
+            pass
+
     def stop(self) -> None:
         """A last flush (bounded to EXIT_TIMEOUT), then the thread stops."""
         try:
+            self.end_requests()
             self.flush(timeout=EXIT_TIMEOUT)
             self._stopped = True
             with self._wake:
@@ -205,8 +231,34 @@ class DirectTransport:
             return self._exception_signal(payload)
         if kind == "handled_failure":
             return self._handled_signal(payload)
+        if kind == "request":
+            return self._request_signal(payload)
         return None
 
+    def _request_signal(self, payload: dict) -> Optional[_Signal]:
+        """A failed or slow request, or a 429 spike (Capability 2b): the
+        sidecar's handling of the ``request`` message. A spike carries no
+        user."""
+        signal = payload.get("signal")
+        try:
+            built = reqsignal.build(signal, payload.get("method"), payload.get("route"), payload.get("status") or 0,
+                                    payload.get("duration_ms") or 0, payload.get("count") or 0, payload.get("total") or 0)
+        except reqsignal.InvalidSignal:
+            return None
+        fp = built.fingerprint(self.service)
+        if fp is None:
+            return None
+        user = None if signal == reqsignal.RATE_LIMIT_SPIKE else _user(payload.get("user"))
+        return _Signal(fp, built.kind, built.text, user, [], built.exemplar)
+
+    def _record_spikes(self, spikes: List[reqsignal.Spike]) -> None:
+        for spike in spikes:
+            signal = self._request_signal({"kind": "request", "signal": reqsignal.RATE_LIMIT_SPIKE, "method": spike.method,
+                                           "route": spike.route, "status": 429, "count": spike.count, "total": spike.total})
+            if signal is not None:
+                with self._lock:
+                    self._record(signal)
+
     def _exception_signal(self, payload: dict) -> Optional[_Signal]:
         type_ = _text(payload.get("error"))
         message = _text(payload.get("message"))[:MAX_MESSAGE]
@@ -270,6 +322,8 @@ class DirectTransport:
         self._window: Dict[str, _Count] = {}
         self._details: Dict[str, _Detail] = {}
         self._overflowed = 0
+        # Per process: a forked child starts its own windows.
+        self._spikes = reqsignal.SpikeDetector()
         self._sensor_id = "py-" + secrets.token_hex(10)
         self._thread: Optional[threading.Thread] = None
 
@@ -317,6 +371,9 @@ class DirectTransport:
         """Phase 1, then whatever the responses asked for: learned rules
         first (a rule arriving with a request for the shape it governs
         applies to that request), then log slices, then evidence."""
+        # A spike window that has ended is closed here, so it is reported
+        # even when no later request arrives to close it.
+        self._record_spikes(self._spikes.tick(reqsignal.now_ms()))
         with self._lock:
             counts, overflowed = self._window, self._overflowed
             self._window = {}
@@ -383,8 +440,11 @@ class DirectTransport:
         return out
 
     def _envelope(self, counts: List[dict], overflowed: int) -> bytes:
+        """Every flush request's body: counts, each request of a split window
+        and the empty poll are all built here, so all carry ``sdk``."""
         body: Dict[str, Any] = {"v": PROTOCOL_VERSION, "tenant": "", "source": "server", "service": self.service,
-                                "release": self.release, "sensor_id": self._sensor_id, "counts": counts}
+                                "release": self.release, "sensor_id": self._sensor_id, "sdk": _SDK_FIELD,
+                                "counts": counts}
         if overflowed > 0:
             body["overflowed"] = overflowed
         return _json(body)

{devbench-0.1.0 → devbench-0.2.0}/devbench/django/middleware.py

@@ -17,7 +17,7 @@ from typing import Any, Callable, Optional
 
 from asgiref.sync import iscoroutinefunction, markcoroutinefunction
 
-from .. import _core, _integration, context
+from .. import _core, _integration, _requests, context
 from ..trace import WSGI_HEADER, Trace
 
 
@@ -34,19 +34,23 @@ class DevbenchMiddleware:
     def __call__(self, request: Any) -> Any:
         if self._async:
             return self.__acall__(request)
-        if not _core.enabled():
+        if not _core.enabled() or _requests.observing():
             return self.get_response(request)
-        with context.scoped(_parse(request)):
+        with context.scoped(_parse(request)) as scope:
+            observed = _requests.begin(scope, getattr(request, "method", None))
             response = self.get_response(request)
             _mark_handled(response)
+            _finish(observed, request, response)
             return response
 
     async def __acall__(self, request: Any) -> Any:
-        if not _core.enabled():
+        if not _core.enabled() or _requests.observing():
             return await self.get_response(request)
-        with context.scoped(_parse(request)):
+        with context.scoped(_parse(request)) as scope:
+            observed = _requests.begin(scope, getattr(request, "method", None))
             response = await self.get_response(request)
             _mark_handled(response)
+            _finish(observed, request, response)
             return response
 
 
@@ -76,6 +80,22 @@ def _symbol(request: Any) -> Optional[str]:
         return None
 
 
+def _finish(observed: Any, request: Any, response: Any) -> None:
+    """Capability 2b: the route is the resolved URL pattern
+    (``resolver_match.route``, joined across includes); none matched is
+    "*"."""
+    if observed is None:
+        return
+    try:
+        match = getattr(request, "resolver_match", None)
+        observed.route = getattr(match, "route", None) if match is not None else None
+        status = getattr(response, "status_code", 0)
+        content_type = response.get("Content-Type") if response is not None else None
+        _requests.finish(observed, status, _requests.event_stream(content_type))
+    except Exception:
+        pass
+
+
 def _mark_handled(response: Any) -> None:
     try:
         count = _integration.handled_count()

{devbench-0.1.0 → devbench-0.2.0}/devbench/flask.py

@@ -9,16 +9,18 @@
 Wraps ``app.wsgi_app`` in the WSGI middleware (trace, identity scope,
 ``x-adt-handled``) and subscribes to ``got_request_exception``, which Flask
 sends for an unhandled exception before it answers 500 (an ``abort(404)`` or
-any other HTTPException is a response, not a failure, and never reaches it).
+any other HTTPException is a response, not a failure, and never reaches it),
+and to ``request_started``, which records the matched URL rule as the
+request's route (Capability 2b: failed and slow requests, 429 spikes).
 """
 
 from __future__ import annotations
 
 from typing import Any, Optional
 
-from flask import got_request_exception, request
+from flask import got_request_exception, request, request_started
 
-from . import _integration
+from . import _integration, _requests
 from .wsgi import DevbenchMiddleware
 
 
@@ -36,6 +38,18 @@ class Devbench:
         _integration.setup(service=getattr(app, "import_name", None))
         app.wsgi_app = DevbenchMiddleware(app.wsgi_app)
         got_request_exception.connect(_on_exception, app, weak=False)
+        request_started.connect(_on_request, app, weak=False)
+
+
+def _on_request(sender: Any, **_: Any) -> None:
+    """Routing has run: the matched rule (``/orders/<int:id>``) is the
+    request's route for Capability 2b. None matched (a 404) is "*"."""
+    try:
+        rule = request.url_rule
+        if rule is not None:
+            _requests.set_route(rule.rule)
+    except Exception:
+        pass
 
 
 def _on_exception(sender: Any, exception: Optional[BaseException] = None, **_: Any) -> None:

{devbench-0.1.0 → devbench-0.2.0}/devbench/identity.py

@@ -1,4 +1,4 @@
-"""Who was affected (docs/SERVER_SDK_SPEC.md, Capability 5).
+"""Who was affected (docs/server-sdk/identity.md, Capability 5).
 
 Identity travels in its own field and nowhere else: never in a message, a
 symbol or a log line, so it can never move a fingerprint.

{devbench-0.1.0 → devbench-0.2.0}/devbench/logs.py

@@ -1,4 +1,4 @@
-"""In-process log capture (docs/SERVER_SDK_SPEC.md, "In-process log capture
+"""In-process log capture (docs/server-sdk/configuration.md, "In-process log capture
 (direct mode)"): recent log lines kept in memory, keyed by the trace that was
 current when each was written, so triage can be handed the server lines of
 one user action without a sidecar.