townhouse 0.4.0__tar.gz

townhouse-0.4.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: townhouse
+Version: 0.4.0
+Summary: Townhouse error tracking for Python: FastAPI, Starlette, Flask, Django, logging and plain scripts
+Author: Townhouse
+License: MIT
+Project-URL: Homepage, https://townhouse.dev
+Keywords: townhouse,error tracking,monitoring,fastapi,flask,django
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: FastAPI
+Classifier: Framework :: Flask
+Classifier: Framework :: Django
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: fastapi; extra == "test"
+Requires-Dist: httpx; extra == "test"
+Requires-Dist: flask; extra == "test"
+Requires-Dist: django; extra == "test"
+
+# townhouse (Python)
+
+Error tracking for Python apps, sent to Townhouse: errors grouped into problems, linked to the part of your app they
+break, and fixable with your own model.
+
+```bash
+pip install townhouse
+```
+
+```python
+import os, townhouse
+townhouse.init(key=os.environ["TOWNHOUSE_KEY"], release=os.environ.get("GIT_SHA"), environment="production")
+```
+
+`TOWNHOUSE_KEY` is your project's ingest key (`gh_live_...`), from the Townhouse app. A DSN works too:
+`townhouse.init(dsn="https://gh_live_xxx@api.townhouse.dev/<projectId>")`.
+
+## Frameworks
+
+FastAPI and Starlette:
+
+```python
+from townhouse.integrations.asgi import TownhouseMiddleware
+app.add_middleware(TownhouseMiddleware)
+```
+
+Flask:
+
+```python
+from townhouse.integrations.flask import init_app
+init_app(app)
+```
+
+Django (`settings.py`):
+
+```python
+MIDDLEWARE = ["townhouse.integrations.django.TownhouseMiddleware", *MIDDLEWARE]
+```
+
+Logging (log lines become breadcrumbs, `ERROR` and above become events):
+
+```python
+import logging
+from townhouse.integrations.logging import TownhouseHandler
+logging.getLogger().addHandler(TownhouseHandler())
+```
+
+## What it sends
+
+- Uncaught exceptions from the main thread and other threads, with the process exiting as it would have.
+- Unhandled view or endpoint exceptions and 5xx responses, with the route pattern.
+- Frames ordered outermost first, marked in-app for your own files and not for installed packages.
+- Emails and tokens masked, secret-looking fields redacted, query strings dropped, and only four request headers kept.
+- Batches gzipped from a background thread, flushed at exit. No dependencies outside the standard library.
+
+Manual capture: `townhouse.capture_exception(exc)`, `townhouse.capture_message("text", "warning")`,
+`townhouse.add_breadcrumb("query", "SELECT orders")`, `townhouse.set_tag("tenant", "acme")`, `townhouse.set_user("u_123")`.
+
+## Developing and testing
+
+The tests cover the client and the FastAPI, Flask and Django integrations, so they need those frameworks. Install the
+package in editable mode with its `test` extra, then run pytest from this folder:
+
+```bash
+python3 -m venv .venv && . .venv/bin/activate
+pip install -e ".[test]"
+python -m pytest -q
+```

townhouse-0.4.0/README.md

@@ -0,0 +1,68 @@
+# townhouse (Python)
+
+Error tracking for Python apps, sent to Townhouse: errors grouped into problems, linked to the part of your app they
+break, and fixable with your own model.
+
+```bash
+pip install townhouse
+```
+
+```python
+import os, townhouse
+townhouse.init(key=os.environ["TOWNHOUSE_KEY"], release=os.environ.get("GIT_SHA"), environment="production")
+```
+
+`TOWNHOUSE_KEY` is your project's ingest key (`gh_live_...`), from the Townhouse app. A DSN works too:
+`townhouse.init(dsn="https://gh_live_xxx@api.townhouse.dev/<projectId>")`.
+
+## Frameworks
+
+FastAPI and Starlette:
+
+```python
+from townhouse.integrations.asgi import TownhouseMiddleware
+app.add_middleware(TownhouseMiddleware)
+```
+
+Flask:
+
+```python
+from townhouse.integrations.flask import init_app
+init_app(app)
+```
+
+Django (`settings.py`):
+
+```python
+MIDDLEWARE = ["townhouse.integrations.django.TownhouseMiddleware", *MIDDLEWARE]
+```
+
+Logging (log lines become breadcrumbs, `ERROR` and above become events):
+
+```python
+import logging
+from townhouse.integrations.logging import TownhouseHandler
+logging.getLogger().addHandler(TownhouseHandler())
+```
+
+## What it sends
+
+- Uncaught exceptions from the main thread and other threads, with the process exiting as it would have.
+- Unhandled view or endpoint exceptions and 5xx responses, with the route pattern.
+- Frames ordered outermost first, marked in-app for your own files and not for installed packages.
+- Emails and tokens masked, secret-looking fields redacted, query strings dropped, and only four request headers kept.
+- Batches gzipped from a background thread, flushed at exit. No dependencies outside the standard library.
+
+Manual capture: `townhouse.capture_exception(exc)`, `townhouse.capture_message("text", "warning")`,
+`townhouse.add_breadcrumb("query", "SELECT orders")`, `townhouse.set_tag("tenant", "acme")`, `townhouse.set_user("u_123")`.
+
+## Developing and testing
+
+The tests cover the client and the FastAPI, Flask and Django integrations, so they need those frameworks. Install the
+package in editable mode with its `test` extra, then run pytest from this folder:
+
+```bash
+python3 -m venv .venv && . .venv/bin/activate
+pip install -e ".[test]"
+python -m pytest -q
+```

townhouse-0.4.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "townhouse"
+version = "0.4.0"
+description = "Townhouse error tracking for Python: FastAPI, Starlette, Flask, Django, logging and plain scripts"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Townhouse" }]
+keywords = ["townhouse", "error tracking", "monitoring", "fastapi", "flask", "django"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Framework :: FastAPI",
+  "Framework :: Flask",
+  "Framework :: Django",
+  "Topic :: System :: Monitoring",
+]
+dependencies = []
+
+[project.optional-dependencies]
+test = ["pytest>=8", "fastapi", "httpx", "flask", "django"]
+
+[project.urls]
+Homepage = "https://townhouse.dev"
+
+[tool.setuptools.packages.find]
+include = ["townhouse*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

townhouse-0.4.0/setup.cfg

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

townhouse-0.4.0/tests/test_client.py

@@ -0,0 +1,159 @@
+import logging
+import sys
+import threading
+
+import townhouse
+from townhouse.client import Client, scrub, scrub_string
+from townhouse.integrations.logging import TownhouseHandler
+
+
+def boom():
+    raise ValueError("card declined for jane@example.com with sk_live_abcdefghijklmnop")
+
+
+def test_envelope_matches_contract(capture):
+    cap, client = capture
+    try:
+        boom()
+    except ValueError as exc:
+        event_id = townhouse.capture_exception(exc, handled=False)
+    assert event_id
+    assert townhouse.flush()
+    assert len(cap.requests) == 1
+    req = cap.requests[0]
+    assert req["headers"]["x-townhouse-key"] == "gh_live_testkey1234"
+    assert req["headers"]["content-encoding"] == "gzip"
+    assert req["endpoint"] == "https://api.townhouse.dev/v1/ingest/events"
+    ev = cap.events[0]
+    assert ev["eventId"] == event_id
+    assert ev["timestamp"].endswith("Z")
+    assert ev["platform"] == "python"
+    assert ev["sdk"] == {"name": "townhouse.python", "version": townhouse.SDK_VERSION}
+    assert ev["release"] == "abc123" and ev["environment"] == "test"
+    ex = ev["exception"]
+    assert ex["type"] == "ValueError"
+    assert "[email]" in ex["value"] and "[redacted]" in ex["value"]
+    assert "jane@example.com" not in ex["stack"] and "sk_live_" not in ex["stack"]
+    assert ex["mechanism"] == {"handled": False, "type": "python"}
+    frames = ex["frames"]
+    assert frames[-1]["function"] == "boom", "innermost frame last"
+    assert frames[-1]["inApp"] is True
+    assert set(frames[-1]) >= {"filename", "function", "lineno", "colno", "inApp"}
+
+
+def test_scrub_redacts_secret_keys_and_values():
+    out = scrub({"password": "hunter2", "nested": {"api_key": "x", "note": "Bearer abcdefghijklmnop"}, "email": "a@b.co"})
+    assert out["password"] == "[redacted]"
+    assert out["nested"]["api_key"] == "[redacted]"
+    assert out["nested"]["note"] == "[redacted]"
+    assert out["email"] == "[email]"
+    assert scrub_string("ghp_" + "a" * 30) == "[redacted]"
+
+
+def test_message_breadcrumbs_tags_user_and_fingerprint(capture):
+    cap, client = capture
+    townhouse.add_breadcrumb("query", "SELECT * FROM orders WHERE email = 'x@y.com'")
+    townhouse.set_tag("tenant", "acme")
+    townhouse.set_user("u_1")
+    client.capture_message("Queue is backing up", "warning", tags={"queue": "emails"})
+    client.flush()
+    ev = cap.events[0]
+    assert ev["message"] == "Queue is backing up" and ev["level"] == "warning"
+    assert "exception" not in ev
+    assert ev["breadcrumbs"][0]["category"] == "query" and "[email]" in ev["breadcrumbs"][0]["message"]
+    assert ev["tags"] == {"tenant": "acme", "queue": "emails"}
+    assert ev["user"] == {"id": "u_1"}
+    try:
+        boom()
+    except ValueError as exc:
+        client.capture_exception(exc, fingerprint=["{{ default }}", "checkout"])
+    client.flush()
+    assert cap.events[-1]["fingerprint"] == ["{{ default }}", "checkout"]
+
+
+def test_dedupe_sampling_before_send_and_no_key():
+    sent = []
+    c = Client(key="gh_live_k", transport=lambda b, h, e: sent.append(b) or 202, start_thread=False)
+    for _ in range(3):
+        try:
+            boom()
+        except ValueError as exc:
+            c.capture_exception(exc)
+    c.flush()
+    assert len(sent) == 1, "identical errors within a second are sent once"
+    dropped = Client(key="gh_live_k", transport=lambda b, h, e: 202, start_thread=False, before_send=lambda ev, hint: None)
+    assert dropped.capture_message("x") is None
+    nokey = Client(key=None, transport=lambda b, h, e: 202, start_thread=False)
+    import os
+    os.environ.pop("TOWNHOUSE_KEY", None)
+    assert Client(key=None, transport=lambda b, h, e: 202, start_thread=False).capture_message("x") is None or nokey.key
+
+
+def test_failed_send_is_retried():
+    calls = {"n": 0}
+
+    def flaky(body, headers, endpoint):
+        calls["n"] += 1
+        return 503 if calls["n"] == 1 else 202
+
+    c = Client(key="gh_live_k", transport=flaky, start_thread=False)
+    c.capture_message("hello")
+    assert c.flush(1.0) is False or calls["n"] >= 1
+    assert c.flush(1.0) is True
+    assert calls["n"] == 2
+
+
+def test_dsn_sets_key_and_endpoint():
+    c = Client(dsn="https://gh_live_abc123@api.townhouse.dev/proj-1", start_thread=False, transport=lambda b, h, e: 202)
+    assert c.key == "gh_live_abc123"
+    assert c.endpoint == "https://api.townhouse.dev/v1/ingest/events"
+
+
+def test_excepthook_and_thread_hook_capture_uncaught():
+    sent = []
+    townhouse.close()
+    townhouse.init(key="gh_live_k", transport=lambda b, h, e: sent.append(b) or 202, start_thread=False)
+    seen = []
+    import townhouse as th
+    previous = th._previous_excepthook
+    th._previous_excepthook = lambda *a: seen.append(a)
+    try:
+        try:
+            raise RuntimeError("uncaught main")
+        except RuntimeError:
+            sys.excepthook(*sys.exc_info())
+        t = threading.Thread(target=boom)
+        t.start()
+        t.join()
+        th.flush()
+    finally:
+        th._previous_excepthook = previous
+        townhouse.close()
+    assert seen, "the previous hook still runs"
+    import gzip, json
+    events = [e for b in sent for e in json.loads(gzip.decompress(b))["events"]]
+    types = {e["exception"]["type"] for e in events}
+    assert {"RuntimeError", "ValueError"} <= types
+    main = next(e for e in events if e["exception"]["type"] == "RuntimeError")
+    assert main["level"] == "fatal" and main["exception"]["mechanism"]["handled"] is False
+
+
+def test_logging_handler(capture):
+    cap, client = capture
+    log = logging.getLogger("shop")
+    handler = TownhouseHandler()
+    log.addHandler(handler)
+    log.setLevel(logging.INFO)
+    try:
+        log.info("loading cart")
+        try:
+            boom()
+        except ValueError:
+            log.exception("checkout failed")
+        log.error("plain error line")
+        client.flush()
+    finally:
+        log.removeHandler(handler)
+    types = [e.get("exception", {}).get("type") or e.get("message") for e in cap.events]
+    assert "ValueError" in types and "plain error line" in types
+    assert any(b["message"] == "shop: loading cart" for b in cap.events[0]["breadcrumbs"])

townhouse-0.4.0/tests/test_frameworks.py

@@ -0,0 +1,101 @@
+import pytest
+
+import townhouse
+
+
+def test_fastapi_middleware_reports_exception_and_5xx_with_route(capture):
+    cap, client = capture
+    from fastapi import FastAPI
+    from fastapi.responses import JSONResponse
+    from fastapi.testclient import TestClient
+    from townhouse.integrations.asgi import TownhouseMiddleware
+
+    app = FastAPI()
+    app.add_middleware(TownhouseMiddleware)
+
+    @app.post("/orders/{order_id}")
+    def create(order_id: int):
+        raise KeyError("total")
+
+    @app.get("/health")
+    def health():
+        return JSONResponse({"ok": False}, status_code=503)
+
+    tc = TestClient(app, raise_server_exceptions=False)
+    assert tc.post("/orders/42?token=secret", headers={"user-agent": "pytest", "authorization": "Bearer abcdefghijkl"}).status_code == 500
+    assert tc.get("/health").status_code == 503
+    client.flush()
+    exc = next(e for e in cap.events if e["exception"]["type"] == "KeyError")
+    assert exc["request"]["method"] == "POST"
+    assert exc["request"]["url"] == "/orders/42", "query string stripped"
+    assert exc["request"]["route"] == "/orders/{order_id}"
+    assert exc["request"]["headers"] == {"user-agent": "pytest"}, "headers allowlisted"
+    assert exc["exception"]["mechanism"]["handled"] is False
+    http = next(e for e in cap.events if "503" in e["exception"]["value"])
+    assert http["tags"]["http.status"] == "503"
+
+
+def test_flask_integration_reports_exception_and_5xx(capture):
+    cap, client = capture
+    from flask import Flask
+    from townhouse.integrations.flask import init_app
+
+    app = Flask(__name__)
+    init_app(app)
+
+    @app.route("/orders/<int:order_id>", methods=["POST"])
+    def create(order_id):
+        raise ZeroDivisionError("division by zero")
+
+    @app.route("/down")
+    def down():
+        return "down", 502
+
+    tc = app.test_client()
+    assert tc.post("/orders/7").status_code == 500
+    assert tc.get("/down").status_code == 502
+    client.flush()
+    exc = next(e for e in cap.events if e["exception"]["type"] == "ZeroDivisionError")
+    assert exc["request"]["route"] == "/orders/<int:order_id>"
+    assert exc["request"]["url"] == "/orders/7"
+    assert exc["exception"]["frames"][-1]["function"] == "create"
+    assert sum(1 for e in cap.events if e["exception"]["type"] == "ZeroDivisionError") == 1, "not reported twice as a 5xx"
+    assert any("502" in e["exception"]["value"] for e in cap.events)
+
+
+def test_django_middleware_reports_exception_with_route(capture):
+    cap, client = capture
+    import django
+    from django.conf import settings
+
+    if not settings.configured:
+        settings.configure(
+            DEBUG=False,
+            SECRET_KEY="test",
+            ROOT_URLCONF=__name__,
+            ALLOWED_HOSTS=["testserver"],
+            MIDDLEWARE=["townhouse.integrations.django.TownhouseMiddleware"],
+            INSTALLED_APPS=[],
+        )
+        django.setup()
+    from django.test import Client as DjangoClient
+
+    resp = DjangoClient(raise_request_exception=False).get("/orders/9/")
+    assert resp.status_code == 500
+    client.flush()
+    exc = next(e for e in cap.events if e["exception"]["type"] == "LookupError")
+    assert exc["request"]["route"] == "/orders/<int:order_id>/"
+    assert exc["request"]["method"] == "GET"
+    assert exc["tags"]["handler"] == "django"
+
+
+def _django_view(request, order_id):
+    raise LookupError("order missing")
+
+
+try:
+    from django.urls import path
+
+    urlpatterns = [path("orders/<int:order_id>/", _django_view)]
+except Exception:  # pragma: no cover
+    urlpatterns = []

townhouse-0.4.0/townhouse/__init__.py

@@ -0,0 +1,101 @@
+"""Townhouse error tracking for Python.
+
+    import townhouse
+    townhouse.init(key="gh_live_...", release="1.4.2", environment="production")
+
+Uncaught exceptions (main thread and threads) are reported, with the process behaving as it would have. Framework
+integrations live in townhouse.integrations: FastAPI or Starlette, Flask, Django and logging.
+"""
+from __future__ import annotations
+
+import sys
+import threading
+from typing import Any, Dict, List, Optional
+
+from .client import SDK_VERSION, Client, scrub, scrub_string
+
+__all__ = [
+    "init", "get_client", "capture_exception", "capture_message", "add_breadcrumb", "set_tag", "set_user", "flush",
+    "close", "Client", "SDK_VERSION", "scrub", "scrub_string",
+]
+
+_client: Optional[Client] = None
+_previous_excepthook = None
+_previous_threading_hook = None
+
+
+def init(key: Optional[str] = None, *, dsn: Optional[str] = None, release: Optional[str] = None, environment: Optional[str] = None,
+         capture_uncaught: bool = True, **options: Any) -> Client:
+    """Start the client. Safe to call more than once; later calls return the existing client."""
+    global _client, _previous_excepthook, _previous_threading_hook
+    if _client is not None:
+        return _client
+    _client = Client(key=key, dsn=dsn, release=release, environment=environment, **options)
+    if capture_uncaught:
+        _previous_excepthook = sys.excepthook
+
+        def _excepthook(exc_type, exc, tb):  # type: ignore[no-untyped-def]
+            try:
+                if _client is not None and not issubclass(exc_type, KeyboardInterrupt):
+                    _client.capture_exception(exc, handled=False, mechanism="python", level="fatal")
+                    _client.flush(2.0)
+            finally:
+                (_previous_excepthook or sys.__excepthook__)(exc_type, exc, tb)
+
+        sys.excepthook = _excepthook
+        if hasattr(threading, "excepthook"):
+            _previous_threading_hook = threading.excepthook
+
+            def _thread_hook(args):  # type: ignore[no-untyped-def]
+                try:
+                    if _client is not None and args.exc_value is not None and not isinstance(args.exc_value, SystemExit):
+                        _client.capture_exception(args.exc_value, handled=False, mechanism="python", tags={"thread": getattr(args.thread, "name", None)})
+                finally:
+                    if _previous_threading_hook is not None:
+                        _previous_threading_hook(args)
+
+            threading.excepthook = _thread_hook
+    return _client
+
+
+def get_client() -> Optional[Client]:
+    return _client
+
+
+def capture_exception(exc: Optional[BaseException] = None, **kwargs: Any) -> Optional[str]:
+    return _client.capture_exception(exc, **kwargs) if _client else None
+
+
+def capture_message(message: str, level: str = "info", **kwargs: Any) -> Optional[str]:
+    return _client.capture_message(message, level, **kwargs) if _client else None
+
+
+def add_breadcrumb(category: str = "ui", message: Optional[str] = None, level: str = "info", data: Optional[Dict[str, Any]] = None) -> None:
+    if _client:
+        _client.add_breadcrumb(category, message, level, data)
+
+
+def set_tag(key: str, value: Any) -> None:
+    if _client:
+        _client.set_tag(key, value)
+
+
+def set_user(user_id: Optional[str]) -> None:
+    if _client:
+        _client.set_user(user_id)
+
+
+def flush(timeout: float = 5.0) -> bool:
+    return _client.flush(timeout) if _client else True
+
+
+def close() -> None:
+    """Stop the client and restore the hooks it installed."""
+    global _client
+    if _client is not None:
+        _client.close()
+    if _previous_excepthook is not None:
+        sys.excepthook = _previous_excepthook
+    if _previous_threading_hook is not None and hasattr(threading, "excepthook"):
+        threading.excepthook = _previous_threading_hook
+    _client = None

townhouse-0.4.0/townhouse/client.py

@@ -0,0 +1,401 @@
+"""Townhouse error tracking core for Python.
+
+Builds events exactly as the Townhouse errors contract (v1) describes, scrubs secrets and emails, and sends them in
+gzip batches from a background thread to POST /v1/ingest/events with the project ingest key in x-townhouse-key.
+Standard library only. Capture code never raises into the host application.
+"""
+from __future__ import annotations
+
+import atexit
+import datetime as _dt
+import gzip
+import json
+import linecache
+import os
+import platform as _platform
+import queue
+import random
+import re
+import socket
+import sys
+import threading
+import time
+import traceback
+import urllib.error
+import urllib.parse
+import urllib.request
+import uuid
+from typing import Any, Callable, Dict, List, Optional
+
+SDK_NAME = "townhouse.python"
+SDK_VERSION = "0.4.0"
+DEFAULT_ENDPOINT = "https://api.townhouse.dev/v1/ingest/events"
+
+LIMITS = {
+    "value": 2000,
+    "message": 2000,
+    "stack": 16000,
+    "frames": 100,
+    "tags": 50,
+    "breadcrumbs": 50,
+    "breadcrumb_message": 500,
+    "batch": 100,
+    "body_bytes": 900 * 1024,
+    "queue": 300,
+}
+LEVELS = ("fatal", "error", "warning", "info")
+MECHANISMS = ("onerror", "onunhandledrejection", "express", "nextjs", "python", "manual")
+HEADER_ALLOWLIST = ("user-agent", "referer", "accept-language", "content-type")
+
+SECRET_KEY = re.compile(r"pass(word|wd)?|secret|token|auth(orization)?|cookie|session|api[-_]?key|private[-_]?key|credential|signature|jwt|bearer|otp|\bpin\b|ssn|card[-_]?(number|no)|cvc|cvv", re.I)
+EMAIL = re.compile(r"[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}", re.I)
+SECRET_VALUES = [
+    re.compile(r"\bBearer\s+[A-Za-z0-9._~+/=-]{8,}", re.I),
+    re.compile(r"\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}"),
+    re.compile(r"\b(sk|rk|pk)_(live|test)_[A-Za-z0-9]{8,}"),
+    re.compile(r"\bsk-(ant-|proj-|or-)?[A-Za-z0-9_-]{16,}"),
+    re.compile(r"\bgh[pousr]_[A-Za-z0-9]{20,}"),
+    re.compile(r"\bgh_live_[A-Za-z0-9_-]{8,}"),
+    re.compile(r"\bxox[abprs]-[A-Za-z0-9-]{10,}"),
+    re.compile(r"\bAKIA[0-9A-Z]{16}\b"),
+    re.compile(r"\bAIza[0-9A-Za-z_-]{30,}"),
+    re.compile(r"\bre_[A-Za-z0-9]{16,}"),
+]
+_NOT_IN_APP = re.compile(r"site-packages|dist-packages|[\\/]lib[\\/]python\d|<frozen |[\\/]townhouse[\\/]|^<")
+
+
+def _now_iso() -> str:
+    return _dt.datetime.now(_dt.timezone.utc).isoformat(timespec="milliseconds").replace("+00:00", "Z")
+
+
+def scrub_string(value: Any, limit: Optional[int] = None) -> str:
+    s = str(value)
+    for pattern in SECRET_VALUES:
+        s = pattern.sub("[redacted]", s)
+    s = EMAIL.sub("[email]", s)
+    return s[:limit] if limit else s
+
+
+def scrub(value: Any, depth: int = 0) -> Any:
+    if value is None or isinstance(value, (bool, int, float)):
+        return value
+    if isinstance(value, str):
+        return scrub_string(value, 2000)
+    if depth > 5:
+        return "[depth]"
+    if isinstance(value, (list, tuple, set)):
+        return [scrub(v, depth + 1) for v in list(value)[:50]]
+    if isinstance(value, dict):
+        out = {}
+        for i, (k, v) in enumerate(value.items()):
+            if i >= 50:
+                break
+            out[str(k)] = "[redacted]" if SECRET_KEY.search(str(k)) else scrub(v, depth + 1)
+        return out
+    return scrub_string(repr(value), 2000)
+
+
+def path_only(url: Any) -> Optional[str]:
+    if url is None:
+        return None
+    try:
+        return urllib.parse.urlsplit(str(url)).path or "/"
+    except Exception:
+        return str(url).split("?")[0].split("#")[0]
+
+
+def pick_headers(headers: Any) -> Dict[str, str]:
+    out: Dict[str, str] = {}
+    if not headers:
+        return out
+    try:
+        items = {str(k).lower(): v for k, v in (headers.items() if hasattr(headers, "items") else headers)}
+    except Exception:
+        return out
+    for key in HEADER_ALLOWLIST:
+        v = items.get(key)
+        if v:
+            out[key] = scrub_string(v, 500)
+    return out
+
+
+def in_app(filename: str, app_roots: List[str]) -> bool:
+    if not filename or _NOT_IN_APP.search(filename):
+        return False
+    if app_roots:
+        return any(os.path.abspath(filename).startswith(root) for root in app_roots)
+    return True
+
+
+def frames_from_traceback(tb: Any, app_roots: List[str]) -> List[Dict[str, Any]]:
+    frames: List[Dict[str, Any]] = []
+    for frame_summary in traceback.extract_tb(tb):
+        filename = frame_summary.filename
+        rel = filename
+        for root in app_roots:
+            if os.path.abspath(filename).startswith(root):
+                rel = os.path.relpath(os.path.abspath(filename), root)
+                break
+        frames.append({
+            "filename": rel,
+            "function": frame_summary.name or "?",
+            "lineno": frame_summary.lineno or 0,
+            "colno": getattr(frame_summary, "colno", None) or 0,
+            "inApp": in_app(filename, app_roots),
+            "module": None,
+        })
+    # traceback.extract_tb is outermost first, innermost last, which is the contract order. Keep the innermost frames.
+    return frames[-LIMITS["frames"]:]
+
+
+class Client:
+    def __init__(
+        self,
+        key: Optional[str] = None,
+        dsn: Optional[str] = None,
+        endpoint: Optional[str] = None,
+        release: Optional[str] = None,
+        environment: Optional[str] = None,
+        server_name: Optional[str] = None,
+        sample_rate: float = 1.0,
+        before_send: Optional[Callable[[Dict[str, Any], Dict[str, Any]], Optional[Dict[str, Any]]]] = None,
+        fingerprint: Optional[List[str]] = None,
+        tags: Optional[Dict[str, str]] = None,
+        app_roots: Optional[List[str]] = None,
+        flush_interval: float = 2.0,
+        transport: Optional[Callable[[bytes, Dict[str, str], str], int]] = None,
+        debug: bool = False,
+        start_thread: bool = True,
+    ) -> None:
+        env = os.environ
+        dsn = dsn or env.get("TOWNHOUSE_DSN")
+        dsn_key = dsn_endpoint = None
+        if dsn:
+            try:
+                parts = urllib.parse.urlsplit(dsn)
+                dsn_key = urllib.parse.unquote(parts.username or "") or None
+                dsn_endpoint = f"{parts.scheme}://{parts.hostname}{(':' + str(parts.port)) if parts.port else ''}/v1/ingest/events"
+            except Exception:
+                pass
+        self.key = key or env.get("TOWNHOUSE_KEY") or env.get("TOWNHOUSE_API_KEY") or dsn_key
+        self.endpoint = endpoint or dsn_endpoint or env.get("TOWNHOUSE_ENDPOINT") or DEFAULT_ENDPOINT
+        rel = release or env.get("TOWNHOUSE_RELEASE") or env.get("GIT_COMMIT") or env.get("RAILWAY_GIT_COMMIT_SHA") or env.get("RENDER_GIT_COMMIT") or env.get("GITHUB_SHA") or env.get("SOURCE_VERSION")
+        self.release = rel[:12] if rel and re.fullmatch(r"[0-9a-f]{40}", rel) else rel
+        self.environment = environment or env.get("TOWNHOUSE_ENVIRONMENT") or env.get("ENVIRONMENT") or "production"
+        self.server_name = server_name or _safe(socket.gethostname)
+        self.sample_rate = sample_rate
+        self.before_send = before_send
+        self.fingerprint = fingerprint
+        self.tags: Dict[str, str] = {}
+        for k, v in (tags or {}).items():
+            self.set_tag(k, v)
+        self.app_roots = [os.path.abspath(r) for r in (app_roots or [os.getcwd()])]
+        self.flush_interval = flush_interval
+        self.transport = transport or self._http_transport
+        self.debug = debug
+        self.breadcrumbs: List[Dict[str, Any]] = []
+        self.user: Optional[Dict[str, str]] = None
+        self._lock = threading.Lock()
+        self._queue: "queue.Queue[Dict[str, Any]]" = queue.Queue(maxsize=LIMITS["queue"])
+        self._recent: Dict[str, float] = {}
+        self._wake = threading.Event()
+        self._stopped = False
+        self._thread: Optional[threading.Thread] = None
+        self.contexts = {
+            "runtime": {"name": _platform.python_implementation(), "version": _platform.python_version()},
+            "os": {"name": _platform.system(), "version": _platform.release()},
+        }
+        if start_thread:
+            self._thread = threading.Thread(target=self._run, name="townhouse-sender", daemon=True)
+            self._thread.start()
+            atexit.register(self.close)
+
+    # Public API -------------------------------------------------------------------------------------------------
+    def set_tag(self, key: str, value: Any) -> None:
+        if len(self.tags) < LIMITS["tags"] or key in self.tags:
+            self.tags[str(key)[:200]] = scrub_string(value, 200)
+
+    def set_user(self, user_id: Optional[str]) -> None:
+        self.user = None if user_id is None else {"id": str(user_id)[:128]}
+
+    def add_breadcrumb(self, category: str = "ui", message: Optional[str] = None, level: str = "info", data: Optional[Dict[str, Any]] = None) -> None:
+        crumb = {
+            "ts": _now_iso(),
+            "category": category if category in ("navigation", "http", "console", "ui", "query") else "ui",
+            "message": scrub_string(message, LIMITS["breadcrumb_message"]) if message is not None else None,
+            "level": level if level in LEVELS else "info",
+            "data": scrub(data) if data else None,
+        }
+        with self._lock:
+            self.breadcrumbs.append(crumb)
+            del self.breadcrumbs[: max(0, len(self.breadcrumbs) - LIMITS["breadcrumbs"])]
+
+    def capture_exception(self, exc: Optional[BaseException] = None, *, handled: bool = True, mechanism: str = "python", level: str = "error", request: Optional[Dict[str, Any]] = None, tags: Optional[Dict[str, Any]] = None, fingerprint: Optional[List[str]] = None) -> Optional[str]:
+        try:
+            if exc is None:
+                exc = sys.exc_info()[1]
+            if exc is None:
+                return None
+            event = self._build(exc=exc, handled=handled, mechanism=mechanism, level=level, request=request, tags=tags, fingerprint=fingerprint)
+            return self._enqueue(event, exc)
+        except Exception:
+            return None
+
+    def capture_message(self, message: str, level: str = "info", *, request: Optional[Dict[str, Any]] = None, tags: Optional[Dict[str, Any]] = None) -> Optional[str]:
+        try:
+            event = self._build(message=message, level=level, request=request, tags=tags)
+            return self._enqueue(event, None)
+        except Exception:
+            return None
+
+    def flush(self, timeout: float = 5.0) -> bool:
+        deadline = time.monotonic() + timeout
+        while not self._queue.empty() and time.monotonic() < deadline:
+            if not self._send_batch():
+                break
+        return self._queue.empty()
+
+    def close(self, timeout: float = 2.0) -> None:
+        if self._stopped:
+            return
+        self._stopped = True
+        self._wake.set()
+        _safe(lambda: self.flush(timeout))
+
+    # Internals --------------------------------------------------------------------------------------------------
+    def _build(self, exc: Optional[BaseException] = None, message: Optional[str] = None, handled: bool = True, mechanism: str = "python", level: str = "error", request: Optional[Dict[str, Any]] = None, tags: Optional[Dict[str, Any]] = None, fingerprint: Optional[List[str]] = None) -> Dict[str, Any]:
+        event: Dict[str, Any] = {
+            "eventId": str(uuid.uuid4()),
+            "timestamp": _now_iso(),
+            "sdk": {"name": SDK_NAME, "version": SDK_VERSION},
+            "platform": "python",
+            "environment": self.environment,
+            "release": self.release,
+            "serverName": self.server_name,
+            "level": level if level in LEVELS else "error",
+        }
+        if message is not None:
+            event["message"] = scrub_string(message, LIMITS["message"])
+        if exc is not None:
+            stack = "".join(traceback.format_exception(type(exc), exc, exc.__traceback__))
+            event["exception"] = {
+                "type": type(exc).__name__,
+                "value": scrub_string(str(exc), LIMITS["value"]),
+                "stack": scrub_string(stack, LIMITS["stack"]),
+                "frames": frames_from_traceback(exc.__traceback__, self.app_roots),
+                "mechanism": {"handled": bool(handled), "type": mechanism if mechanism in MECHANISMS else "python"},
+            }
+        if request:
+            event["request"] = {
+                "method": (request.get("method") or "").upper()[:10] or None,
+                "url": path_only(request.get("url")),
+                "route": path_only(request.get("route")) if request.get("route") else None,
+                "headers": pick_headers(request.get("headers")),
+            }
+        if self.user:
+            event["user"] = dict(self.user)
+        with self._lock:
+            event["breadcrumbs"] = list(self.breadcrumbs)
+        merged = dict(self.tags)
+        for k, v in (tags or {}).items():
+            if v is not None:
+                merged[str(k)[:200]] = scrub_string(v, 200)
+        event["tags"] = dict(list(merged.items())[: LIMITS["tags"]])
+        event["contexts"] = dict(self.contexts)
+        fp = fingerprint or self.fingerprint
+        if fp:
+            event["fingerprint"] = [str(x)[:200] for x in fp][:10]
+        return {k: v for k, v in event.items() if v is not None}
+
+    def _enqueue(self, event: Dict[str, Any], exc: Optional[BaseException]) -> Optional[str]:
+        if not self.key:
+            return None
+        if self.sample_rate < 1 and random.random() >= self.sample_rate:
+            return None
+        ex = event.get("exception") or {}
+        frames = ex.get("frames") or []
+        inner = frames[-1] if frames else {}
+        dedupe = f"{ex.get('type')}|{ex.get('value') or event.get('message')}|{inner.get('filename')}:{inner.get('lineno')}"
+        now = time.monotonic()
+        last = self._recent.get(dedupe)
+        if last is not None and now - last < 1.0:
+            return None
+        self._recent[dedupe] = now
+        if len(self._recent) > 300:
+            self._recent.pop(next(iter(self._recent)))
+        if self.before_send:
+            try:
+                event = self.before_send(event, {"original_exception": exc})
+            except Exception:
+                pass
+            if not event:
+                return None
+        try:
+            self._queue.put_nowait(event)
+        except queue.Full:
+            _safe(self._queue.get_nowait)
+            _safe(lambda: self._queue.put_nowait(event))
+        self._wake.set()
+        return event.get("eventId")
+
+    def _take_batch(self) -> List[Dict[str, Any]]:
+        batch: List[Dict[str, Any]] = []
+        size = 12
+        while len(batch) < LIMITS["batch"]:
+            try:
+                item = self._queue.get_nowait()
+            except queue.Empty:
+                break
+            item_size = len(json.dumps(item, default=str)) + 1
+            if batch and size + item_size > LIMITS["body_bytes"]:
+                _safe(lambda: self._queue.put_nowait(item))
+                break
+            batch.append(item)
+            size += item_size
+        return batch
+
+    def _send_batch(self) -> bool:
+        batch = self._take_batch()
+        if not batch:
+            return True
+        body = gzip.compress(json.dumps({"events": batch}, default=str).encode("utf-8"))
+        headers = {"content-type": "application/json", "content-encoding": "gzip", "x-townhouse-key": self.key or "", "user-agent": f"townhouse-python/{SDK_VERSION}"}
+        try:
+            status = self.transport(body, headers, self.endpoint)
+        except Exception:
+            status = 0
+        if status == 202 or 200 <= status < 300 or (400 <= status < 500 and status not in (408, 429)):
+            return True
+        for item in batch:
+            _safe(lambda item=item: self._queue.put_nowait(item))
+        return False
+
+    @staticmethod
+    def _http_transport(body: bytes, headers: Dict[str, str], endpoint: str) -> int:
+        req = urllib.request.Request(endpoint, data=body, headers=headers, method="POST")
+        try:
+            with urllib.request.urlopen(req, timeout=10) as res:
+                return res.status
+        except urllib.error.HTTPError as e:
+            return e.code
+        except Exception:
+            return 0
+
+    def _run(self) -> None:
+        while not self._stopped:
+            self._wake.wait(self.flush_interval)
+            self._wake.clear()
+            if self._stopped:
+                break
+            time.sleep(0.05)
+            while not self._queue.empty():
+                if not self._send_batch():
+                    time.sleep(min(30.0, self.flush_interval * 4))
+                    break
+
+
+def _safe(fn: Callable[[], Any], default: Any = None) -> Any:
+    try:
+        return fn()
+    except Exception:
+        return default

townhouse-0.4.0/townhouse/integrations/__init__.py

@@ -0,0 +1 @@
+"""Framework integrations: townhouse.integrations.asgi (FastAPI, Starlette), .flask, .django and .logging."""

townhouse-0.4.0/townhouse/integrations/asgi.py

@@ -0,0 +1,71 @@
+"""ASGI middleware for FastAPI, Starlette and any ASGI app.
+
+    import townhouse
+    from townhouse.integrations.asgi import TownhouseMiddleware
+    townhouse.init(key="gh_live_...")
+    app.add_middleware(TownhouseMiddleware)
+
+Reports unhandled exceptions and 5xx responses with the matched route (for example /orders/{order_id}), then re-raises
+so the framework's own error handling still runs.
+"""
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, Optional
+
+import townhouse
+
+
+def _route_of(scope: Dict[str, Any]) -> Optional[str]:
+    route = scope.get("route")
+    path = getattr(route, "path", None) or getattr(route, "path_format", None)
+    return path
+
+
+def _headers(scope: Dict[str, Any]) -> Dict[str, str]:
+    out: Dict[str, str] = {}
+    for k, v in scope.get("headers") or []:
+        try:
+            out[k.decode("latin-1").lower()] = v.decode("latin-1")
+        except Exception:
+            pass
+    return out
+
+
+class TownhouseMiddleware:
+    def __init__(self, app: Any, capture_status: int = 500) -> None:
+        self.app = app
+        self.capture_status = capture_status
+
+    async def __call__(self, scope: Dict[str, Any], receive: Any, send: Any) -> None:
+        if scope.get("type") != "http":
+            await self.app(scope, receive, send)
+            return
+        client = townhouse.get_client()
+        status: Dict[str, int] = {"code": 0}
+        started = time.monotonic()
+
+        async def _send(message: Dict[str, Any]) -> None:
+            if message.get("type") == "http.response.start":
+                status["code"] = int(message.get("status") or 0)
+            await send(message)
+
+        def _request() -> Dict[str, Any]:
+            return {"method": scope.get("method"), "url": scope.get("path"), "route": _route_of(scope), "headers": _headers(scope)}
+
+        try:
+            await self.app(scope, receive, _send)
+        except Exception as exc:
+            if client is not None:
+                client.capture_exception(exc, handled=False, mechanism="python", request=_request(), tags={"handler": "asgi"})
+            raise
+        finally:
+            if client is not None:
+                try:
+                    route = _route_of(scope) or scope.get("path")
+                    client.add_breadcrumb("http", f"{scope.get('method')} {route} {status['code']}", "error" if status["code"] >= 500 else "info", {"status": status["code"], "ms": int((time.monotonic() - started) * 1000)})
+                except Exception:
+                    pass
+        if client is not None and status["code"] >= self.capture_status:
+            err = RuntimeError(f"{scope.get('method')} {_route_of(scope) or scope.get('path')} responded {status['code']}")
+            client.capture_exception(err, handled=True, mechanism="python", request=_request(), tags={"handler": "asgi", "http.status": str(status["code"])})

townhouse-0.4.0/townhouse/integrations/django.py

@@ -0,0 +1,58 @@
+"""Django integration.
+
+settings.py:
+    MIDDLEWARE = ["townhouse.integrations.django.TownhouseMiddleware", *MIDDLEWARE]
+
+and call townhouse.init(key=...) in settings.py or wsgi.py. Reports unhandled view exceptions (through
+process_exception, so Django's own handling still runs) and 5xx responses, with the URL pattern as the route.
+"""
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Optional
+
+import townhouse
+
+
+def _route(request: Any) -> Optional[str]:
+    match = getattr(request, "resolver_match", None)
+    route = getattr(match, "route", None)
+    if route:
+        return "/" + route.lstrip("^").rstrip("$").lstrip("/")
+    return None
+
+
+def _request_ctx(request: Any) -> Dict[str, Any]:
+    headers = {k.lower(): v for k, v in getattr(request, "headers", {}).items()}
+    return {"method": request.method, "url": request.path, "route": _route(request), "headers": headers}
+
+
+class TownhouseMiddleware:
+    capture_status = 500
+
+    def __init__(self, get_response: Callable[[Any], Any]) -> None:
+        self.get_response = get_response
+
+    def __call__(self, request: Any) -> Any:
+        response = self.get_response(request)
+        client = townhouse.get_client()
+        try:
+            if client is not None:
+                ctx = _request_ctx(request)
+                client.add_breadcrumb("http", f"{ctx['method']} {ctx['route'] or ctx['url']} {response.status_code}", "error" if response.status_code >= 500 else "info", {"status": response.status_code})
+                if response.status_code >= self.capture_status and not getattr(request, "_townhouse_captured", False):
+                    err = RuntimeError(f"{ctx['method']} {ctx['route'] or ctx['url']} responded {response.status_code}")
+                    client.capture_exception(err, handled=True, mechanism="python", request=ctx, tags={"handler": "django", "http.status": str(response.status_code)})
+        except Exception:
+            pass
+        return response
+
+    def process_exception(self, request: Any, exception: BaseException) -> None:
+        client = townhouse.get_client()
+        if client is None:
+            return None
+        try:
+            client.capture_exception(exception, handled=False, mechanism="python", request=_request_ctx(request), tags={"handler": "django"})
+            request._townhouse_captured = True
+        except Exception:
+            pass
+        return None

townhouse-0.4.0/townhouse/integrations/flask.py

@@ -0,0 +1,52 @@
+"""Flask integration.
+
+    import townhouse
+    from townhouse.integrations.flask import init_app
+    townhouse.init(key="gh_live_...")
+    init_app(app)
+
+Uses Flask's got_request_exception signal, so your error handlers keep working, and reports 5xx responses with the URL
+rule (for example /orders/<int:order_id>).
+"""
+from __future__ import annotations
+
+from typing import Any, Dict
+
+import townhouse
+
+
+def _request_ctx() -> Dict[str, Any]:
+    from flask import request
+
+    rule = getattr(request, "url_rule", None)
+    return {"method": request.method, "url": request.path, "route": getattr(rule, "rule", None), "headers": dict(request.headers)}
+
+
+def init_app(app: Any, capture_status: int = 500) -> None:
+    from flask import got_request_exception, g
+
+    def _on_exception(sender: Any, exception: BaseException, **extra: Any) -> None:
+        client = townhouse.get_client()
+        if client is None:
+            return
+        try:
+            client.capture_exception(exception, handled=False, mechanism="python", request=_request_ctx(), tags={"handler": "flask"})
+            g._townhouse_captured = True
+        except Exception:
+            pass
+
+    got_request_exception.connect(_on_exception, app, weak=False)
+
+    @app.after_request
+    def _after(response: Any) -> Any:
+        client = townhouse.get_client()
+        try:
+            if client is not None:
+                ctx = _request_ctx()
+                client.add_breadcrumb("http", f"{ctx['method']} {ctx['route'] or ctx['url']} {response.status_code}", "error" if response.status_code >= 500 else "info", {"status": response.status_code})
+                if response.status_code >= capture_status and not getattr(g, "_townhouse_captured", False):
+                    err = RuntimeError(f"{ctx['method']} {ctx['route'] or ctx['url']} responded {response.status_code}")
+                    client.capture_exception(err, handled=True, mechanism="python", request=ctx, tags={"handler": "flask", "http.status": str(response.status_code)})
+        except Exception:
+            pass
+        return response

townhouse-0.4.0/townhouse/integrations/logging.py

@@ -0,0 +1,37 @@
+"""Logging integration: records log lines as breadcrumbs and reports ERROR records (and above) as events.
+
+    import logging, townhouse
+    from townhouse.integrations.logging import TownhouseHandler
+    townhouse.init(key="gh_live_...")
+    logging.getLogger().addHandler(TownhouseHandler())
+"""
+from __future__ import annotations
+
+import logging
+
+import townhouse
+
+
+class TownhouseHandler(logging.Handler):
+    def __init__(self, event_level: int = logging.ERROR, breadcrumb_level: int = logging.INFO) -> None:
+        super().__init__(level=min(event_level, breadcrumb_level))
+        self.event_level = event_level
+        self.breadcrumb_level = breadcrumb_level
+
+    def emit(self, record: logging.LogRecord) -> None:
+        client = townhouse.get_client()
+        if client is None or record.name.startswith("townhouse"):
+            return
+        try:
+            level = "fatal" if record.levelno >= logging.CRITICAL else "error" if record.levelno >= logging.ERROR else "warning" if record.levelno >= logging.WARNING else "info"
+            message = record.getMessage()
+            if record.levelno >= self.event_level:
+                tags = {"logger": record.name}
+                if record.exc_info and record.exc_info[1] is not None:
+                    client.capture_exception(record.exc_info[1], handled=True, mechanism="python", level=level, tags=tags)
+                else:
+                    client.capture_message(message, level, tags=tags)
+            elif record.levelno >= self.breadcrumb_level:
+                client.add_breadcrumb("console", f"{record.name}: {message}", level)
+        except Exception:
+            pass

townhouse-0.4.0/townhouse.egg-info/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: townhouse
+Version: 0.4.0
+Summary: Townhouse error tracking for Python: FastAPI, Starlette, Flask, Django, logging and plain scripts
+Author: Townhouse
+License: MIT
+Project-URL: Homepage, https://townhouse.dev
+Keywords: townhouse,error tracking,monitoring,fastapi,flask,django
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: FastAPI
+Classifier: Framework :: Flask
+Classifier: Framework :: Django
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: fastapi; extra == "test"
+Requires-Dist: httpx; extra == "test"
+Requires-Dist: flask; extra == "test"
+Requires-Dist: django; extra == "test"
+
+# townhouse (Python)
+
+Error tracking for Python apps, sent to Townhouse: errors grouped into problems, linked to the part of your app they
+break, and fixable with your own model.
+
+```bash
+pip install townhouse
+```
+
+```python
+import os, townhouse
+townhouse.init(key=os.environ["TOWNHOUSE_KEY"], release=os.environ.get("GIT_SHA"), environment="production")
+```
+
+`TOWNHOUSE_KEY` is your project's ingest key (`gh_live_...`), from the Townhouse app. A DSN works too:
+`townhouse.init(dsn="https://gh_live_xxx@api.townhouse.dev/<projectId>")`.
+
+## Frameworks
+
+FastAPI and Starlette:
+
+```python
+from townhouse.integrations.asgi import TownhouseMiddleware
+app.add_middleware(TownhouseMiddleware)
+```
+
+Flask:
+
+```python
+from townhouse.integrations.flask import init_app
+init_app(app)
+```
+
+Django (`settings.py`):
+
+```python
+MIDDLEWARE = ["townhouse.integrations.django.TownhouseMiddleware", *MIDDLEWARE]
+```
+
+Logging (log lines become breadcrumbs, `ERROR` and above become events):
+
+```python
+import logging
+from townhouse.integrations.logging import TownhouseHandler
+logging.getLogger().addHandler(TownhouseHandler())
+```
+
+## What it sends
+
+- Uncaught exceptions from the main thread and other threads, with the process exiting as it would have.
+- Unhandled view or endpoint exceptions and 5xx responses, with the route pattern.
+- Frames ordered outermost first, marked in-app for your own files and not for installed packages.
+- Emails and tokens masked, secret-looking fields redacted, query strings dropped, and only four request headers kept.
+- Batches gzipped from a background thread, flushed at exit. No dependencies outside the standard library.
+
+Manual capture: `townhouse.capture_exception(exc)`, `townhouse.capture_message("text", "warning")`,
+`townhouse.add_breadcrumb("query", "SELECT orders")`, `townhouse.set_tag("tenant", "acme")`, `townhouse.set_user("u_123")`.
+
+## Developing and testing
+
+The tests cover the client and the FastAPI, Flask and Django integrations, so they need those frameworks. Install the
+package in editable mode with its `test` extra, then run pytest from this folder:
+
+```bash
+python3 -m venv .venv && . .venv/bin/activate
+pip install -e ".[test]"
+python -m pytest -q
+```

townhouse-0.4.0/townhouse.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+tests/test_client.py
+tests/test_frameworks.py
+townhouse/__init__.py
+townhouse/client.py
+townhouse.egg-info/PKG-INFO
+townhouse.egg-info/SOURCES.txt
+townhouse.egg-info/dependency_links.txt
+townhouse.egg-info/requires.txt
+townhouse.egg-info/top_level.txt
+townhouse/integrations/__init__.py
+townhouse/integrations/asgi.py
+townhouse/integrations/django.py
+townhouse/integrations/flask.py
+townhouse/integrations/logging.py

townhouse-0.4.0/townhouse.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

townhouse-0.4.0/townhouse.egg-info/requires.txt

@@ -0,0 +1,7 @@
+
+[test]
+pytest>=8
+fastapi
+httpx
+flask
+django

townhouse-0.4.0/townhouse.egg-info/top_level.txt

@@ -0,0 +1 @@
+townhouse