errorgap 0.1.1__tar.gz → 0.3.0__tar.gz

errorgap-0.3.0/CHANGELOG.md

@@ -0,0 +1,30 @@
+# 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`,
+  and `SpanCollector` for DB and HTTP spans; enabled with `apm_enabled=True`,
+  sampled by `apm_sample_rate`.
+- Errors reported during a transaction carry its id as
+  `context.transaction_id` (held in a `ContextVar`), linking each error to
+  the request or job that raised it.
+- `errorgap.wsgi.ErrorgapMiddleware` times WSGI requests; `errorgap.flask.init_app`
+  installs it and groups requests by URL rule.
+- Requests record the browser SDK's `x-errorgap-trace` header as the
+  transaction's `trace_id`, linking browser API calls to server requests.
+
+## 0.1.1 — 2026-07-18
+
+- Include bounded inline source excerpts for readable application and dependency
+  traceback frames so
+  Errorgap can render highlighted source without a repository integration.
+- Order traceback frames innermost-first so frame 0 and group fingerprints use
+  the actual exception site.

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: errorgap
-Version: 0.1.1
+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
@@ -107,6 +112,59 @@ app = Flask(__name__)
 init_app(app)
 ```
 
+`init_app` also times each request as an APM transaction (sent with
+`apm_enabled=True`) grouped by its URL rule (`/orders/<int:id>`), and errors
+raised during the request carry its transaction id. Record spans from a view
+with `errorgap.flask.spans()`:
+
+```python
+from errorgap.flask import spans
+
+@app.route("/orders/<int:order_id>")
+def order(order_id):
+    started = time.perf_counter()
+    row = db.execute("SELECT * FROM orders WHERE id = %s", (order_id,)).fetchone()
+    spans().database("SELECT * FROM orders WHERE id = %s", (time.perf_counter() - started) * 1000)
+    return row
+```
+
+## WSGI
+
+Any WSGI app gets the same request transactions from
+`errorgap.wsgi.ErrorgapMiddleware`. Set `environ["errorgap.route"]` to the
+matched route template to group requests (otherwise the raw path is used).
+
+```python
+from errorgap.wsgi import ErrorgapMiddleware
+
+application = ErrorgapMiddleware(application)
+```
+
+## Transactions and jobs
+
+```python
+with errorgap.track_transaction("GET", "/orders/{id}", "/orders/123") as txn:
+    txn.spans.database("SELECT * FROM orders WHERE id = 123", 4.2)
+    txn.status_code = 200
+
+with errorgap.track_job("ReceiptJob", queue="mailers") as txn:
+    send_receipt()
+```
+
+Both time the block and deliver on exit even if it raises. Errors reported
+inside carry the transaction id (`context.transaction_id`), so errorgap shows
+the error a request raised on its trace. The id lives in a `ContextVar`, so
+concurrent threads and asyncio tasks never share one;
+`errorgap.current_transaction_id()` returns the id in effect.
+
+## 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, 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.
+
 ## FastAPI
 
 ```python
@@ -117,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 |
@@ -130,6 +194,8 @@ app.add_middleware(ErrorgapMiddleware)
 | `async_` | `True` | Background-thread delivery |
 | `logger` | `logging.getLogger("errorgap")` | Pass `None` to silence |
 | `filter_keys` | `("password", "token", ...)` | Substring match, case-insensitive |
+| `apm_enabled` | `False` | Send APM transactions |
+| `apm_sample_rate` | `1.0` | Fraction of transactions sent (errors are unaffected) |
 | `capture_globals` | `True` | Install `sys.excepthook` |
 
 ## Graceful shutdown

{errorgap-0.1.1 → 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
@@ -71,6 +76,59 @@ app = Flask(__name__)
 init_app(app)
 ```
 
+`init_app` also times each request as an APM transaction (sent with
+`apm_enabled=True`) grouped by its URL rule (`/orders/<int:id>`), and errors
+raised during the request carry its transaction id. Record spans from a view
+with `errorgap.flask.spans()`:
+
+```python
+from errorgap.flask import spans
+
+@app.route("/orders/<int:order_id>")
+def order(order_id):
+    started = time.perf_counter()
+    row = db.execute("SELECT * FROM orders WHERE id = %s", (order_id,)).fetchone()
+    spans().database("SELECT * FROM orders WHERE id = %s", (time.perf_counter() - started) * 1000)
+    return row
+```
+
+## WSGI
+
+Any WSGI app gets the same request transactions from
+`errorgap.wsgi.ErrorgapMiddleware`. Set `environ["errorgap.route"]` to the
+matched route template to group requests (otherwise the raw path is used).
+
+```python
+from errorgap.wsgi import ErrorgapMiddleware
+
+application = ErrorgapMiddleware(application)
+```
+
+## Transactions and jobs
+
+```python
+with errorgap.track_transaction("GET", "/orders/{id}", "/orders/123") as txn:
+    txn.spans.database("SELECT * FROM orders WHERE id = 123", 4.2)
+    txn.status_code = 200
+
+with errorgap.track_job("ReceiptJob", queue="mailers") as txn:
+    send_receipt()
+```
+
+Both time the block and deliver on exit even if it raises. Errors reported
+inside carry the transaction id (`context.transaction_id`), so errorgap shows
+the error a request raised on its trace. The id lives in a `ContextVar`, so
+concurrent threads and asyncio tasks never share one;
+`errorgap.current_transaction_id()` returns the id in effect.
+
+## 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, 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.
+
 ## FastAPI
 
 ```python
@@ -81,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 |
@@ -94,6 +158,8 @@ app.add_middleware(ErrorgapMiddleware)
 | `async_` | `True` | Background-thread delivery |
 | `logger` | `logging.getLogger("errorgap")` | Pass `None` to silence |
 | `filter_keys` | `("password", "token", ...)` | Substring match, case-insensitive |
+| `apm_enabled` | `False` | Send APM transactions |
+| `apm_sample_rate` | `1.0` | Fraction of transactions sent (errors are unaffected) |
 | `capture_globals` | `True` | Install `sys.excepthook` |
 
 ## Graceful shutdown

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

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

{errorgap-0.1.1 → errorgap-0.3.0}/src/errorgap/__init__.py

@@ -1,15 +1,26 @@
 from __future__ import annotations
 
-from typing import Any, Dict, Optional
+import contextlib
+import time
+from datetime import datetime, timezone
+from typing import Any, Dict, Iterator, Optional
 
+from .apm import TRACE_HEADER, Span, SpanCollector, Transaction, browser_trace_id, normalize_sql
 from .client import Client, DeliveryResult
 from .configuration import Configuration
 from .handlers import install_excepthook, uninstall_excepthook
+from .transaction_context import current_transaction_id, new_transaction_id, transaction_scope
 from .version import VERSION
 
 __all__ = [
     "init",
     "notify",
+    "notify_transaction",
+    "track_transaction",
+    "track_job",
+    "current_transaction_id",
+    "transaction_scope",
+    "browser_trace_id",
     "flush",
     "shutdown",
     "configuration",
@@ -17,6 +28,11 @@ __all__ = [
     "Configuration",
     "Client",
     "DeliveryResult",
+    "Span",
+    "SpanCollector",
+    "Transaction",
+    "TRACE_HEADER",
+    "normalize_sql",
     "VERSION",
 ]
 
@@ -35,6 +51,8 @@ def init(
     async_: Optional[bool] = None,
     filter_keys: Optional[tuple] = None,
     logger: Optional[Any] = None,
+    apm_enabled: Optional[bool] = None,
+    apm_sample_rate: Optional[float] = None,
     capture_globals: bool = True,
 ) -> None:
     """Configure the SDK and install global error hooks.
@@ -64,6 +82,10 @@ def init(
         overrides["filter_keys"] = filter_keys
     if logger is not None:
         overrides["logger"] = logger
+    if apm_enabled is not None:
+        overrides["apm_enabled"] = apm_enabled
+    if apm_sample_rate is not None:
+        overrides["apm_sample_rate"] = apm_sample_rate
 
     _configuration = Configuration(**overrides)
     _client.configure(_configuration)
@@ -92,6 +114,61 @@ def notify(
     )
 
 
+def notify_transaction(transaction: Transaction, sync: bool = False) -> DeliveryResult:
+    """Deliver a pre-measured APM transaction."""
+    return _client.notify_transaction(transaction, sync=sync)
+
+
+@contextlib.contextmanager
+def track_transaction(
+    method: Optional[str] = None,
+    path: Optional[str] = None,
+    path_raw: Optional[str] = None,
+    trace_id: Optional[str] = None,
+    kind: str = "web",
+) -> Iterator[Transaction]:
+    """Time the ``with`` block as an APM transaction and deliver it on exit,
+    even if the block raises. Errors reported inside it carry the
+    transaction's id. Yields the :class:`Transaction`: record spans on
+    ``txn.spans`` and set ``txn.status_code``. ``trace_id`` takes the raw
+    ``x-errorgap-trace`` header value and ignores anything but a UUID."""
+    txn = Transaction(
+        kind=kind,
+        id=new_transaction_id(),
+        trace_id=browser_trace_id(trace_id),
+        method=method,
+        path=path,
+        path_raw=path_raw,
+    )
+    with _timed(txn):
+        yield txn
+
+
+@contextlib.contextmanager
+def track_job(job_class: str, queue: str = "default") -> Iterator[Transaction]:
+    """Time the ``with`` block as a ``job`` transaction; see
+    :func:`track_transaction`."""
+    txn = Transaction(kind="job", id=new_transaction_id(), job_class=job_class, queue=queue)
+    with _timed(txn):
+        yield txn
+
+
+@contextlib.contextmanager
+def _timed(txn: Transaction) -> Iterator[None]:
+    txn.occurred_at = datetime.now(timezone.utc).isoformat(timespec="milliseconds").replace("+00:00", "Z")
+    start = time.perf_counter()
+    try:
+        with transaction_scope(txn.id or new_transaction_id()):
+            yield
+    except BaseException:
+        if txn.kind == "web" and txn.status_code is None:
+            txn.status_code = 500
+        raise
+    finally:
+        txn.duration_ms = (time.perf_counter() - start) * 1000.0
+        _client.notify_transaction(txn)
+
+
 def flush(timeout: Optional[float] = None) -> None:
     _client.flush(timeout)
 

errorgap-0.3.0/src/errorgap/apm.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Union
+
+from .configuration import Configuration
+
+#: The header the errorgap browser SDK sends with API calls.
+TRACE_HEADER = "x-errorgap-trace"
+
+_UUID = re.compile(r"\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\Z")
+_STRING_LITERAL = re.compile(r"'(?:''|[^'])*'")
+_NUMBER = re.compile(r"\b\d+(?:\.\d+)?\b")
+_WHITESPACE = re.compile(r"\s+")
+
+
+def browser_trace_id(header: Union[str, bytes, None]) -> Optional[str]:
+    """The trace id in an ``x-errorgap-trace`` header value, lowercased, or
+    ``None`` unless it is a well-formed UUID."""
+    if isinstance(header, bytes):
+        header = header.decode("latin-1")
+    if not isinstance(header, str):
+        return None
+    value = header.strip().lower()
+    return value if _UUID.match(value) else None
+
+
+def normalize_sql(sql: str) -> str:
+    """Strip literals so query shapes aggregate: '…' and numbers become ?."""
+    sql = _STRING_LITERAL.sub("?", sql)
+    sql = _NUMBER.sub("?", sql)
+    return _WHITESPACE.sub(" ", sql).strip()
+
+
+@dataclass
+class Span:
+    kind: str
+    duration_ms: float
+    sql: Optional[str] = None
+    file: Optional[str] = None
+    line: Optional[int] = None
+    function: Optional[str] = None
+
+    def to_payload(self) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {"kind": self.kind, "duration_ms": self.duration_ms}
+        if self.sql is not None:
+            payload["sql"] = self.sql
+        if self.file is not None:
+            payload["file"] = self.file
+        if self.line is not None:
+            payload["line"] = self.line
+        if self.function is not None:
+            payload["fn_name"] = self.function
+        return payload
+
+
+class SpanCollector:
+    """Collects the spans recorded while a transaction or job is in flight."""
+
+    def __init__(self) -> None:
+        self._spans: List[Span] = []
+
+    def add(self, span: Span) -> None:
+        self._spans.append(span)
+
+    def database(
+        self,
+        sql: str,
+        duration_ms: float,
+        file: Optional[str] = None,
+        line: Optional[int] = None,
+        function: Optional[str] = None,
+    ) -> None:
+        self.add(Span("db", duration_ms, normalize_sql(sql), file, line, function))
+
+    def external(
+        self,
+        duration_ms: float,
+        file: Optional[str] = None,
+        line: Optional[int] = None,
+        function: Optional[str] = None,
+    ) -> None:
+        self.add(Span("http", duration_ms, None, file, line, function))
+
+    def snapshot(self) -> List[Span]:
+        return list(self._spans)
+
+
+@dataclass
+class Transaction:
+    """An APM transaction: a web interaction (``kind="web"``) or a background
+    job (``kind="job"``)."""
+
+    kind: str = "web"
+    #: Links the errors raised during this transaction to it.
+    id: Optional[str] = None
+    #: The browser's ``x-errorgap-trace`` header (see :func:`browser_trace_id`).
+    trace_id: Optional[str] = None
+    method: Optional[str] = None
+    #: Normalized route template used for grouping, e.g. ``/orders/<int:id>``.
+    path: Optional[str] = None
+    #: Concrete path for one request, e.g. ``/orders/123``.
+    path_raw: Optional[str] = None
+    status_code: Optional[int] = None
+    duration_ms: float = 0.0
+    environment: Optional[str] = None
+    #: ISO-8601; defaults to now.
+    occurred_at: Optional[str] = None
+    spans: SpanCollector = field(default_factory=SpanCollector)
+    job_class: Optional[str] = None
+    queue: Optional[str] = None
+
+    def to_payload(self, configuration: Configuration) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {
+            "kind": self.kind,
+            "duration_ms": self.duration_ms,
+            "environment": self.environment or configuration.environment,
+            "occurred_at": self.occurred_at or _now(),
+            "spans": [span.to_payload() for span in self.spans.snapshot()],
+        }
+        for key in ("id", "trace_id", "method", "path", "path_raw", "status_code", "job_class", "queue"):
+            value = getattr(self, key)
+            if value is not None:
+                payload[key] = value
+        return payload
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="milliseconds").replace("+00:00", "Z")

{errorgap-0.1.1 → errorgap-0.3.0}/src/errorgap/client.py

@@ -3,14 +3,17 @@ from __future__ import annotations
 import json
 import logging
 import queue
+import random
 import threading
 from dataclasses import dataclass
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Tuple
 from urllib import error as urlerror
 from urllib import request as urlrequest
 
+from .apm import Transaction
 from .configuration import Configuration
 from .notice import build_notice
+from .transaction_context import current_transaction_id
 from .version import VERSION
 
 
@@ -29,7 +32,7 @@ class DeliveryResult:
 class Client:
     def __init__(self, configuration: Configuration):
         self._configuration = configuration
-        self._queue: "queue.Queue[Optional[Dict[str, Any]]]" = queue.Queue()
+        self._queue: "queue.Queue[Optional[Tuple[str, Dict[str, Any]]]]" = queue.Queue()
         self._worker: Optional[threading.Thread] = None
         self._lock = threading.Lock()
 
@@ -51,6 +54,9 @@ class Client:
     ) -> DeliveryResult:
         try:
             self._configuration.validate()
+            transaction_id = current_transaction_id()
+            if transaction_id and "transaction_id" not in (context or {}):
+                context = {**(context or {}), "transaction_id": transaction_id}
             notice = build_notice(
                 exc,
                 self._configuration,
@@ -67,12 +73,37 @@ class Client:
             return self.deliver(notice)
 
         self._ensure_worker()
-        self._queue.put(notice)
+        self._queue.put(("notices", notice))
+        return DeliveryResult(queued=True, status=202)
+
+    def notify_transaction(self, transaction: Transaction, sync: bool = False) -> DeliveryResult:
+        """Deliver an APM transaction. Dropped unless ``apm_enabled``, and
+        sampled by ``apm_sample_rate``."""
+        try:
+            self._configuration.validate()
+            if not self._configuration.apm_enabled:
+                return DeliveryResult(status=204)
+            rate = self._configuration.apm_sample_rate
+            if not (rate >= 1 or (rate > 0 and random.random() < rate)):
+                return DeliveryResult(status=204)
+            payload = transaction.to_payload(self._configuration)
+        except Exception as caught:  # noqa: BLE001 — SDK must not raise
+            self._log(caught)
+            return DeliveryResult(error=caught)
+
+        if sync or not self._configuration.async_:
+            return self._post("transactions", payload)
+
+        self._ensure_worker()
+        self._queue.put(("transactions", payload))
         return DeliveryResult(queued=True, status=202)
 
     def deliver(self, notice: Dict[str, Any]) -> DeliveryResult:
-        url = _notices_url(self._configuration)
-        body = json.dumps(notice).encode("utf-8")
+        return self._post("notices", notice)
+
+    def _post(self, resource: str, payload: Dict[str, Any]) -> DeliveryResult:
+        url = _project_url(self._configuration, resource)
+        body = json.dumps(payload).encode("utf-8")
         headers = {
             "Content-Type": "application/json",
             "User-Agent": f"errorgap-python/{VERSION}",
@@ -130,7 +161,8 @@ class Client:
             try:
                 if item is None:
                     return
-                self.deliver(item)
+                resource, payload = item
+                self._post(resource, payload)
             finally:
                 self._queue.task_done()
 
@@ -147,9 +179,9 @@ class Client:
                 pass
 
 
-def _notices_url(configuration: Configuration) -> str:
+def _project_url(configuration: Configuration, resource: str) -> str:
     base = configuration.endpoint.rstrip("/")
-    return f"{base}/api/projects/{configuration.project_slug}/notices"
+    return f"{base}/api/projects/{configuration.project_slug}/{resource}"
 
 
 def _wait_join(q: "queue.Queue[Any]", timeout: float) -> None:

{errorgap-0.1.1 → 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)