aperioflow 0.1.0__tar.gz

aperioflow-0.1.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: aperioflow
+Version: 0.1.0
+Summary: Report errors from Python to AperioFlow. No dependencies.
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# AperioFlow for Python
+
+Report errors from Python 3.8 or later to an AperioFlow project. No dependencies: events go to your project's ingest URL with
+`urllib`.
+
+Not on PyPI yet. Until it is, copy the `aperioflow` folder into your project.
+
+## Set up
+
+Open the project in AperioFlow, choose **Set up reporting** and copy the ingest URL.
+
+```python
+import aperioflow
+
+aperioflow.init(
+    "https://app.aperioflow.co.uk/ingest/YOUR_KEY",
+    release="1.4.0",          # optional, groups events by release and finds regressions
+    environment="production",  # optional
+)
+```
+
+After `init`, uncaught exceptions are reported through `sys.excepthook`; the previous hook still runs, so the traceback is printed and
+the program exits as before (`capture_uncaught=False` turns that off).
+
+## Report errors yourself
+
+```python
+try:
+    charge_card(order)
+except Exception as exc:
+    aperioflow.capture_exception(exc, fingerprint="card-charge", extra={"order_id": order.id})
+
+aperioflow.capture_message("Queue is backing up", level="warning")
+aperioflow.add_breadcrumb("Started nightly import", category="job")
+aperioflow.set_tag("region", "eu-west-2")
+aperioflow.set_user(id=user.id)  # only the id is sent
+```
+
+`capture_exception()` with no argument reports the exception being handled. Sends wait for the answer (5 seconds at most); pass
+`background=True` to `init` to send on a thread, and call `aperioflow._client.flush()` before the program exits.
+
+## Options
+
+| Option | What it does |
+| --- | --- |
+| `ingest_url` | Required. The project's ingest URL. |
+| `release`, `environment` | Sent with every event. |
+| `sample_rate` | 0 to 1 (default 1). The share of events sent. |
+| `before_send(event)` | Change an event, or return `None` to drop it. |
+| `capture_uncaught` | Default `True`. |
+| `timeout`, `background` | How long one send may take (default 5 seconds), and whether to send on a thread. |
+
+## Privacy
+
+- Nothing about the user, the machine or its IP address is collected on its own. A user id is sent only when you call `set_user`, and
+  only the id, whatever else you pass.
+- Before an event leaves the process, values of keys that name a secret (password, token, cookie, authorization, api_key and the like),
+  Bearer and Basic credentials, email addresses and card numbers are replaced with `[redacted]` markers. The server scrubs again before
+  it stores anything.
+- Breadcrumbs are limited to the latest 50, and the event's extra data to the server's 20 KB.
+- A failed send never raises into your app.
+
+## Tests
+
+```bash
+python3 -m unittest
+```

aperioflow-0.1.0/README.md

@@ -0,0 +1,67 @@
+# AperioFlow for Python
+
+Report errors from Python 3.8 or later to an AperioFlow project. No dependencies: events go to your project's ingest URL with
+`urllib`.
+
+Not on PyPI yet. Until it is, copy the `aperioflow` folder into your project.
+
+## Set up
+
+Open the project in AperioFlow, choose **Set up reporting** and copy the ingest URL.
+
+```python
+import aperioflow
+
+aperioflow.init(
+    "https://app.aperioflow.co.uk/ingest/YOUR_KEY",
+    release="1.4.0",          # optional, groups events by release and finds regressions
+    environment="production",  # optional
+)
+```
+
+After `init`, uncaught exceptions are reported through `sys.excepthook`; the previous hook still runs, so the traceback is printed and
+the program exits as before (`capture_uncaught=False` turns that off).
+
+## Report errors yourself
+
+```python
+try:
+    charge_card(order)
+except Exception as exc:
+    aperioflow.capture_exception(exc, fingerprint="card-charge", extra={"order_id": order.id})
+
+aperioflow.capture_message("Queue is backing up", level="warning")
+aperioflow.add_breadcrumb("Started nightly import", category="job")
+aperioflow.set_tag("region", "eu-west-2")
+aperioflow.set_user(id=user.id)  # only the id is sent
+```
+
+`capture_exception()` with no argument reports the exception being handled. Sends wait for the answer (5 seconds at most); pass
+`background=True` to `init` to send on a thread, and call `aperioflow._client.flush()` before the program exits.
+
+## Options
+
+| Option | What it does |
+| --- | --- |
+| `ingest_url` | Required. The project's ingest URL. |
+| `release`, `environment` | Sent with every event. |
+| `sample_rate` | 0 to 1 (default 1). The share of events sent. |
+| `before_send(event)` | Change an event, or return `None` to drop it. |
+| `capture_uncaught` | Default `True`. |
+| `timeout`, `background` | How long one send may take (default 5 seconds), and whether to send on a thread. |
+
+## Privacy
+
+- Nothing about the user, the machine or its IP address is collected on its own. A user id is sent only when you call `set_user`, and
+  only the id, whatever else you pass.
+- Before an event leaves the process, values of keys that name a secret (password, token, cookie, authorization, api_key and the like),
+  Bearer and Basic credentials, email addresses and card numbers are replaced with `[redacted]` markers. The server scrubs again before
+  it stores anything.
+- Breadcrumbs are limited to the latest 50, and the event's extra data to the server's 20 KB.
+- A failed send never raises into your app.
+
+## Tests
+
+```bash
+python3 -m unittest
+```

aperioflow-0.1.0/aperioflow/__init__.py

@@ -0,0 +1,264 @@
+"""AperioFlow error reporting for Python. No dependencies: it posts events to your project's ingest URL with urllib.
+
+    import aperioflow
+    aperioflow.init(ingest_url="https://app.aperioflow.co.uk/ingest/YOUR_KEY", release="1.4.0", environment="production")
+    try:
+        ...
+    except Exception as exc:
+        aperioflow.capture_exception(exc)
+
+It never collects the IP address or anything about the user on its own: a user id is sent only when you call set_user(id=...).
+Obvious secrets (password, token, cookie, authorization and similar keys, Bearer credentials, email addresses, card numbers) are
+taken out before an event leaves the process; the server scrubs again before it stores anything.
+"""
+
+from __future__ import annotations
+
+import datetime as _dt
+import json as _json
+import random as _random
+import re as _re
+import sys as _sys
+import threading as _threading
+import traceback as _traceback
+import urllib.request as _request
+
+__all__ = [
+    "init", "close", "capture_exception", "capture_message", "add_breadcrumb", "set_user", "set_tag", "Client",
+    "scrub_text", "scrub_value", "is_secret_key", "MAX_BREADCRUMBS",
+]
+
+SDK_NAME = "aperioflow.python"
+SDK_VERSION = "0.1.0"
+MAX_BREADCRUMBS = 50
+_MAX_MESSAGE = 10000
+_MAX_STACK = 50000
+_MAX_CONTEXT_BYTES = 20000
+_LEVELS = {"fatal", "error", "warning", "info"}
+
+# ---------- client-side scrubbing of obvious secrets ----------
+
+_SECRET_PARTS = ("password", "passwd", "secret", "token", "authorization", "cookie", "apikey", "privatekey", "sessionid", "csrf")
+_SECRET_EXACT = {"auth", "session", "pin", "otp", "jwt"}
+_PAIR = _re.compile(r"([A-Za-z0-9_.-]{1,100})=([^&\s#;\"',]+)")
+_AUTH = _re.compile(r"\b(Bearer|Basic|Token)(\s+)[A-Za-z0-9._~+/=-]{8,}", _re.IGNORECASE)
+_EMAIL = _re.compile(r"[A-Za-z0-9._%+-]+@[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)*\.[A-Za-z]{2,}")
+_CARD = _re.compile(r"(?<![\d.])[2-6](?:[ -]?\d){12,18}(?![\d.])")
+
+
+def is_secret_key(key) -> bool:
+    k = _re.sub(r"[-_\s]", "", str(key).lower())
+    return k in _SECRET_EXACT or any(part in k for part in _SECRET_PARTS)
+
+
+def _luhn(digits: str) -> bool:
+    total = 0
+    for i, ch in enumerate(reversed(digits)):
+        d = int(ch)
+        if i % 2:
+            d = d * 2 - 9 if d * 2 > 9 else d * 2
+        total += d
+    return total % 10 == 0
+
+
+def scrub_text(text):
+    if not isinstance(text, str):
+        return text
+    text = _PAIR.sub(lambda m: f"{m.group(1)}=[redacted]" if is_secret_key(m.group(1)) else m.group(0), text)
+    text = _AUTH.sub(lambda m: f"{m.group(1)}{m.group(2)}[redacted token]", text)
+    text = _EMAIL.sub("[redacted email]", text)
+    return _CARD.sub(lambda m: "[redacted card]" if _luhn(_re.sub(r"\D", "", m.group(0))) else m.group(0), text)
+
+
+def scrub_value(value, depth: int = 0):
+    if isinstance(value, str):
+        return scrub_text(value)
+    if depth > 10:
+        return "[redacted]"
+    if isinstance(value, dict):
+        return {
+            k: ("[redacted]" if is_secret_key(k) and v not in (None, "") else scrub_value(v, depth + 1))
+            for k, v in value.items()
+        }
+    if isinstance(value, (list, tuple)):
+        return [scrub_value(v, depth + 1) for v in value]
+    return value
+
+
+def _clip(value, limit):
+    return value[:limit] if isinstance(value, str) and len(value) > limit else value
+
+
+def _http_transport(timeout: float):
+    def send(url: str, event: dict) -> None:
+        data = _json.dumps(event, default=str).encode("utf-8")
+        req = _request.Request(url, data=data, method="POST", headers={"Content-Type": "application/json"})
+        with _request.urlopen(req, timeout=timeout) as res:  # noqa: S310 - the URL is the project's own ingest address
+            res.read()
+
+    return send
+
+
+class Client:
+    """A client with its own settings. Most apps use the module functions, which share one client."""
+
+    def __init__(self, ingest_url=None, release=None, environment=None, sample_rate=1.0, before_send=None,
+                 platform="python", transport=None, timeout=5.0, rand=None, background=False):
+        self.ingest_url = ingest_url
+        self.release = release
+        self.environment = environment
+        self.sample_rate = min(1.0, max(0.0, float(sample_rate)))
+        self.before_send = before_send
+        self.platform = platform
+        self.transport = transport or _http_transport(timeout)
+        self.rand = rand or _random.random
+        self.background = background
+        self._breadcrumbs: list = []
+        self._user = None
+        self._tags: dict = {}
+        self._lock = _threading.Lock()
+        self._threads: list = []
+
+    def add_breadcrumb(self, message=None, category=None, level=None, data=None):
+        crumb = scrub_value({"category": category, "message": _clip(message, 500), "level": level, "data": data})
+        crumb = {"timestamp": _dt.datetime.now(_dt.timezone.utc).isoformat(), **{k: v for k, v in crumb.items() if v is not None}}
+        with self._lock:
+            self._breadcrumbs.append(crumb)
+            del self._breadcrumbs[:-MAX_BREADCRUMBS]
+
+    def set_user(self, id=None, **_ignored):  # noqa: A002 - "id" is the public name
+        """Only an id is kept: no name, email or IP address, whatever else is passed."""
+        self._user = {"id": str(id)[:200]} if id is not None else None
+
+    def set_tag(self, key, value):
+        if isinstance(key, str) and key:
+            self._tags[key[:100]] = str(value)[:200]
+
+    def build(self, base: dict, level=None, fingerprint=None, url=None, extra=None) -> dict:
+        context = {}
+        with self._lock:
+            if self._breadcrumbs:
+                context["breadcrumbs"] = list(self._breadcrumbs)
+        if self._user:
+            context["user"] = dict(self._user)
+        if self._tags:
+            context["tags"] = dict(self._tags)
+        if isinstance(extra, dict):
+            context["extra"] = extra
+        event = dict(base)
+        event["level"] = level if level in _LEVELS else base.get("level", "error")
+        event["platform"] = self.platform
+        if self.release:
+            event["release"] = str(self.release)[:200]
+        if self.environment:
+            event["environment"] = str(self.environment)[:100]
+        if fingerprint:
+            event["fingerprint"] = str(fingerprint)[:200]
+        if url:
+            event["url"] = _re.split(r"[?#]", str(url))[0][:2000]
+        event["message"] = _clip(scrub_text(event.get("message") or ""), _MAX_MESSAGE) or "(no message)"
+        if event.get("stack"):
+            event["stack"] = _clip(scrub_text(event["stack"]), _MAX_STACK)
+        if context:
+            context = scrub_value(context)
+            # Keep within the server's 20 KB: the oldest breadcrumbs go first, then the extra data.
+            while len(_json.dumps(context, default=str)) > _MAX_CONTEXT_BYTES and context.get("breadcrumbs"):
+                context["breadcrumbs"].pop(0)
+            if len(_json.dumps(context, default=str)) > _MAX_CONTEXT_BYTES:
+                context.pop("extra", None)
+            event["context"] = context
+        return event
+
+    def _send(self, event: dict) -> bool:
+        if not self.ingest_url or self.rand() >= self.sample_rate:
+            return False
+        if self.before_send:
+            try:
+                event = self.before_send(event)
+            except Exception:  # noqa: BLE001 - reporting must never break the app
+                return False
+            if not event:
+                return False
+
+        def deliver():
+            try:
+                self.transport(self.ingest_url, event)
+                return True
+            except Exception:  # noqa: BLE001 - reporting must never break the app
+                return False
+
+        if self.background:
+            thread = _threading.Thread(target=deliver, daemon=True)
+            thread.start()
+            self._threads.append(thread)
+            return True
+        return deliver()
+
+    def capture_exception(self, exc=None, level=None, fingerprint=None, url=None, extra=None) -> bool:
+        if exc is None:
+            exc = _sys.exc_info()[1]
+        if exc is None:
+            return False
+        stack = "".join(_traceback.format_exception(type(exc), exc, exc.__traceback__))
+        base = {"type": type(exc).__name__, "message": str(exc) or type(exc).__name__, "stack": stack}
+        return self._send(self.build(base, level=level, fingerprint=fingerprint, url=url, extra=extra))
+
+    def capture_message(self, message, level="info", fingerprint=None, url=None, extra=None) -> bool:
+        return self._send(self.build({"message": str(message), "level": "info"}, level=level, fingerprint=fingerprint, url=url, extra=extra))
+
+    def flush(self, timeout: float = 2.0) -> None:
+        for thread in list(self._threads):
+            thread.join(timeout)
+        self._threads = [t for t in self._threads if t.is_alive()]
+
+
+_client = Client()
+_previous_hook = None
+
+
+def init(ingest_url, release=None, environment=None, sample_rate=1.0, before_send=None, capture_uncaught=True, **kwargs) -> Client:
+    """Sets up the shared client. capture_uncaught (default True) reports uncaught exceptions through sys.excepthook, then calls the
+    previous hook, so the program still prints the traceback and exits as it would have."""
+    global _client, _previous_hook
+    close()
+    _client = Client(ingest_url=ingest_url, release=release, environment=environment, sample_rate=sample_rate, before_send=before_send, **kwargs)
+    if capture_uncaught:
+        _previous_hook = _sys.excepthook
+
+        def hook(exc_type, exc, tb):
+            try:
+                _client.capture_exception(exc, level="fatal")
+                _client.flush()
+            finally:
+                (_previous_hook or _sys.__excepthook__)(exc_type, exc, tb)
+
+        _sys.excepthook = hook
+    return _client
+
+
+def close() -> None:
+    """Puts back the excepthook init replaced."""
+    global _previous_hook
+    if _previous_hook is not None:
+        _sys.excepthook = _previous_hook
+        _previous_hook = None
+
+
+def capture_exception(exc=None, **kwargs) -> bool:
+    return _client.capture_exception(exc, **kwargs)
+
+
+def capture_message(message, level="info", **kwargs) -> bool:
+    return _client.capture_message(message, level=level, **kwargs)
+
+
+def add_breadcrumb(message=None, category=None, level=None, data=None) -> None:
+    _client.add_breadcrumb(message=message, category=category, level=level, data=data)
+
+
+def set_user(id=None, **kwargs) -> None:  # noqa: A002
+    _client.set_user(id=id, **kwargs)
+
+
+def set_tag(key, value) -> None:
+    _client.set_tag(key, value)

aperioflow-0.1.0/aperioflow.egg-info/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: aperioflow
+Version: 0.1.0
+Summary: Report errors from Python to AperioFlow. No dependencies.
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# AperioFlow for Python
+
+Report errors from Python 3.8 or later to an AperioFlow project. No dependencies: events go to your project's ingest URL with
+`urllib`.
+
+Not on PyPI yet. Until it is, copy the `aperioflow` folder into your project.
+
+## Set up
+
+Open the project in AperioFlow, choose **Set up reporting** and copy the ingest URL.
+
+```python
+import aperioflow
+
+aperioflow.init(
+    "https://app.aperioflow.co.uk/ingest/YOUR_KEY",
+    release="1.4.0",          # optional, groups events by release and finds regressions
+    environment="production",  # optional
+)
+```
+
+After `init`, uncaught exceptions are reported through `sys.excepthook`; the previous hook still runs, so the traceback is printed and
+the program exits as before (`capture_uncaught=False` turns that off).
+
+## Report errors yourself
+
+```python
+try:
+    charge_card(order)
+except Exception as exc:
+    aperioflow.capture_exception(exc, fingerprint="card-charge", extra={"order_id": order.id})
+
+aperioflow.capture_message("Queue is backing up", level="warning")
+aperioflow.add_breadcrumb("Started nightly import", category="job")
+aperioflow.set_tag("region", "eu-west-2")
+aperioflow.set_user(id=user.id)  # only the id is sent
+```
+
+`capture_exception()` with no argument reports the exception being handled. Sends wait for the answer (5 seconds at most); pass
+`background=True` to `init` to send on a thread, and call `aperioflow._client.flush()` before the program exits.
+
+## Options
+
+| Option | What it does |
+| --- | --- |
+| `ingest_url` | Required. The project's ingest URL. |
+| `release`, `environment` | Sent with every event. |
+| `sample_rate` | 0 to 1 (default 1). The share of events sent. |
+| `before_send(event)` | Change an event, or return `None` to drop it. |
+| `capture_uncaught` | Default `True`. |
+| `timeout`, `background` | How long one send may take (default 5 seconds), and whether to send on a thread. |
+
+## Privacy
+
+- Nothing about the user, the machine or its IP address is collected on its own. A user id is sent only when you call `set_user`, and
+  only the id, whatever else you pass.
+- Before an event leaves the process, values of keys that name a secret (password, token, cookie, authorization, api_key and the like),
+  Bearer and Basic credentials, email addresses and card numbers are replaced with `[redacted]` markers. The server scrubs again before
+  it stores anything.
+- Breadcrumbs are limited to the latest 50, and the event's extra data to the server's 20 KB.
+- A failed send never raises into your app.
+
+## Tests
+
+```bash
+python3 -m unittest
+```

aperioflow-0.1.0/aperioflow.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+README.md
+pyproject.toml
+aperioflow/__init__.py
+aperioflow.egg-info/PKG-INFO
+aperioflow.egg-info/SOURCES.txt
+aperioflow.egg-info/dependency_links.txt
+aperioflow.egg-info/top_level.txt
+tests/test_aperioflow.py

aperioflow-0.1.0/aperioflow.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aperioflow-0.1.0/aperioflow.egg-info/top_level.txt

@@ -0,0 +1 @@
+aperioflow

aperioflow-0.1.0/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aperioflow"
+version = "0.1.0"
+description = "Report errors from Python to AperioFlow. No dependencies."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+classifiers = ["Programming Language :: Python :: 3", "License :: OSI Approved :: MIT License"]
+
+[tool.setuptools]
+packages = ["aperioflow"]

aperioflow-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aperioflow-0.1.0/tests/test_aperioflow.py

@@ -0,0 +1,171 @@
+import json
+import sys
+import threading
+import unittest
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+import aperioflow
+from aperioflow import MAX_BREADCRUMBS, Client, is_secret_key, scrub_text, scrub_value
+
+URL = "https://app.aperioflow.co.uk/ingest/ik_test"
+
+
+def collector():
+    sent = []
+    return sent, lambda url, event: sent.append((url, event))
+
+
+class CaptureTests(unittest.TestCase):
+    def test_exception_shape(self):
+        sent, transport = collector()
+        client = Client(ingest_url=URL, release="1.4.0", environment="production", transport=transport)
+        try:
+            raise ValueError("bad value")
+        except ValueError as exc:
+            self.assertTrue(client.capture_exception(exc))
+        url, event = sent[0]
+        self.assertEqual(url, URL)
+        self.assertEqual(event["type"], "ValueError")
+        self.assertEqual(event["message"], "bad value")
+        self.assertEqual(event["level"], "error")
+        self.assertEqual(event["platform"], "python")
+        self.assertEqual(event["release"], "1.4.0")
+        self.assertEqual(event["environment"], "production")
+        self.assertIn("ValueError: bad value", event["stack"])
+        self.assertNotIn("context", event, "nothing about the user or the machine is added on its own")
+
+    def test_current_exception_and_message(self):
+        sent, transport = collector()
+        client = Client(ingest_url=URL, transport=transport)
+        try:
+            1 / 0
+        except ZeroDivisionError:
+            client.capture_exception()
+        client.capture_message("Disk nearly full", level="warning", fingerprint="disk", url="https://a.example/p?q=1#x")
+        self.assertEqual(sent[0][1]["type"], "ZeroDivisionError")
+        self.assertEqual((sent[1][1]["level"], sent[1][1]["fingerprint"], sent[1][1]["url"]), ("warning", "disk", "https://a.example/p"))
+        self.assertFalse(client.capture_exception(None))
+
+    def test_breadcrumbs_and_user_id_only(self):
+        sent, transport = collector()
+        client = Client(ingest_url=URL, transport=transport)
+        for i in range(60):
+            client.add_breadcrumb(f"step {i}", category="nav")
+        client.set_user(id=42, email="jo@example.com", ip_address="203.0.113.1")
+        client.capture_message("m")
+        context = sent[0][1]["context"]
+        self.assertEqual(len(context["breadcrumbs"]), MAX_BREADCRUMBS)
+        self.assertEqual(context["breadcrumbs"][0]["message"], "step 10")
+        self.assertEqual(context["user"], {"id": "42"})
+        client.set_user(None)
+        client.capture_message("m2")
+        self.assertNotIn("user", sent[1][1]["context"])
+
+    def test_secrets_are_scrubbed(self):
+        self.assertTrue(is_secret_key("Authorization") and is_secret_key("api_key") and is_secret_key("Set-Cookie"))
+        self.assertFalse(is_secret_key("user"))
+        self.assertEqual(scrub_text("login?user=bo&password=hunter2"), "login?user=bo&password=[redacted]")
+        self.assertEqual(scrub_text("Bearer abcdefgh12345678"), "Bearer [redacted token]")
+        self.assertEqual(scrub_text("for jo@example.com card 4111 1111 1111 1111"), "for [redacted email] card [redacted card]")
+        self.assertEqual(scrub_text("order 4111111111111112"), "order 4111111111111112")
+        self.assertEqual(scrub_value({"headers": {"cookie": "a=b", "accept": "x"}, "list": [{"token": "t"}]}),
+                         {"headers": {"cookie": "[redacted]", "accept": "x"}, "list": [{"token": "[redacted]"}]})
+        sent, transport = collector()
+        client = Client(ingest_url=URL, transport=transport)
+        client.add_breadcrumb("POST /login", data={"password": "p", "email": "a@b.co"})
+        client.capture_exception(RuntimeError("Failed for jo@example.com"), extra={"session": "abc", "ok": 1})
+        event = sent[0][1]
+        self.assertEqual(event["message"], "Failed for [redacted email]")
+        self.assertEqual(event["context"]["breadcrumbs"][0]["data"], {"password": "[redacted]", "email": "[redacted email]"})
+        self.assertEqual(event["context"]["extra"], {"session": "[redacted]", "ok": 1})
+        self.assertNotIn("jo@example.com", json.dumps(event))
+
+    def test_sample_rate_and_before_send(self):
+        sent, transport = collector()
+        value = [0.7]
+        client = Client(ingest_url=URL, transport=transport, sample_rate=0.5, rand=lambda: value[0])
+        self.assertFalse(client.capture_message("dropped"))
+        value[0] = 0.2
+        self.assertTrue(client.capture_message("kept"))
+        edited = Client(ingest_url=URL, transport=transport, before_send=lambda e: None if e["message"] == "drop me" else {**e, "message": e["message"] + "!"})
+        self.assertFalse(edited.capture_message("drop me"))
+        edited.capture_message("hi")
+
+        def boom(_event):
+            raise RuntimeError("x")
+
+        self.assertFalse(Client(ingest_url=URL, transport=transport, before_send=boom).capture_message("lost"))
+        self.assertEqual([e["message"] for _, e in sent], ["kept", "hi!"])
+
+    def test_failures_never_raise_and_context_is_limited(self):
+        def offline(_url, _event):
+            raise OSError("offline")
+
+        self.assertFalse(Client(ingest_url=URL, transport=offline).capture_message("m"))
+        self.assertFalse(Client().capture_message("no url"))
+        sent, transport = collector()
+        big = Client(ingest_url=URL, transport=transport)
+        for _ in range(50):
+            big.add_breadcrumb("x" * 490)
+        big.capture_message("m")
+        context = sent[0][1]["context"]
+        self.assertLessEqual(len(json.dumps(context)), 20000)
+        self.assertLess(len(context["breadcrumbs"]), 50)
+
+
+class HookTests(unittest.TestCase):
+    def tearDown(self):
+        aperioflow.close()
+
+    def test_init_reports_uncaught_exceptions_and_close_restores_the_hook(self):
+        sent, transport = collector()
+        previous_calls = []
+        original = sys.excepthook
+        sys.excepthook = lambda *args: previous_calls.append(args[0])
+        try:
+            aperioflow.init(URL, release="r1", transport=transport)
+            try:
+                raise KeyError("missing")
+            except KeyError:
+                sys.excepthook(*sys.exc_info())
+            self.assertEqual(sent[0][1]["type"], "KeyError")
+            self.assertEqual(sent[0][1]["level"], "fatal")
+            self.assertEqual(previous_calls, [KeyError], "the previous hook still runs")
+            aperioflow.close()
+            self.assertIsNot(sys.excepthook, None)
+            self.assertEqual(sys.excepthook.__name__, "<lambda>")
+        finally:
+            sys.excepthook = original
+
+
+class HttpTransportTests(unittest.TestCase):
+    def test_posts_json_to_the_ingest_url(self):
+        received = []
+
+        class Handler(BaseHTTPRequestHandler):
+            def do_POST(self):  # noqa: N802
+                body = self.rfile.read(int(self.headers["Content-Length"]))
+                received.append((self.path, self.headers["Content-Type"], json.loads(body)))
+                self.send_response(202)
+                self.end_headers()
+                self.wfile.write(b'{"accepted":1}')
+
+            def log_message(self, *args):
+                pass
+
+        server = HTTPServer(("127.0.0.1", 0), Handler)
+        thread = threading.Thread(target=server.serve_forever, daemon=True)
+        thread.start()
+        try:
+            client = Client(ingest_url=f"http://127.0.0.1:{server.server_port}/ingest/ik_test", background=True)
+            self.assertTrue(client.capture_message("over http"))
+            client.flush(5)
+        finally:
+            server.shutdown()
+        self.assertEqual(received[0][0], "/ingest/ik_test")
+        self.assertEqual(received[0][1], "application/json")
+        self.assertEqual(received[0][2]["message"], "over http")
+
+
+if __name__ == "__main__":
+    unittest.main()