devalerts 0.1.3__tar.gz → 0.1.5__tar.gz

devalerts-0.1.5/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 sslinNn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

devalerts-0.1.5/PKG-INFO

@@ -0,0 +1,226 @@
+Metadata-Version: 2.4
+Name: devalerts
+Version: 0.1.5
+Summary: Send unhandled Python exceptions straight to a Telegram chat. No backend, no account, no database — just your own bot token.
+Keywords: telegram,error-tracking,exception-monitoring,alerts,logging,monitoring,asgi
+Author: sslinNn
+Author-email: sslinNn <morison1991@mail.ru>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Topic :: System :: Monitoring
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Project-URL: Homepage, https://github.com/sslinNn/devalerts
+Project-URL: Repository, https://github.com/sslinNn/devalerts
+Project-URL: Bug Tracker, https://github.com/sslinNn/devalerts/issues
+Description-Content-Type: text/markdown
+
+# devalerts
+
+[![PyPI](https://img.shields.io/pypi/v/devalerts)](https://pypi.org/project/devalerts/)
+[![Downloads](https://img.shields.io/pypi/dm/devalerts)](https://pypi.org/project/devalerts/)
+[![Python versions](https://img.shields.io/pypi/pyversions/devalerts)](https://pypi.org/project/devalerts/)
+[![License: MIT](https://img.shields.io/pypi/l/devalerts)](LICENSE)
+[![Tests](https://img.shields.io/github/actions/workflow/status/sslinNn/devalerts/test.yml?branch=main&label=tests)](https://github.com/sslinNn/devalerts/actions/workflows/test.yml)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![mypy](https://img.shields.io/badge/mypy-checked-blue)](https://mypy-lang.org/)
+
+[Русская версия](README.ru.md)
+
+Send unhandled Python exceptions straight to a Telegram chat — the moment
+they happen, on your phone. No backend, no account, no database — just your
+own bot token.
+
+```python
+import devalerts
+
+devalerts.init(bot_token="123456:ABC-DEF...", chat_id=123456789)
+```
+
+That's the whole setup. Two minutes with [@BotFather](https://t.me/BotFather)
+and every unhandled crash — including ones raised in threads — lands in your
+chat instead of a log file nobody's watching.
+
+## Why devalerts
+
+- **Zero infrastructure.** No SaaS signup, no ingestion server, no API key
+  to manage beyond your own Telegram bot token. State lives in a local
+  SQLite file you already own.
+- **One line to install, one line to wire up.** `init()` installs the hook
+  and gets out of the way.
+- **Not spam.** Errors are grouped by fingerprint and rate-limited per
+  group, so a crash loop sends one message, not a thousand.
+- **Framework-aware.** Ships an ASGI middleware for FastAPI/Starlette apps,
+  where the default excepthook would never even see a request error.
+- **Small and typed.** No dependencies, ships `py.typed`, ~450 lines total —
+  short enough to read in one sitting before you trust it with your errors.
+
+## Install
+
+    uv add devalerts
+
+(or `pip install devalerts` if you're not using uv)
+
+## Usage
+
+1. Create a bot with [@BotFather](https://t.me/BotFather) and get its token.
+2. Message your bot once (or add it to a group) so it's allowed to message you back.
+3. Get your chat id — message [@userinfobot](https://t.me/userinfobot), or call
+   `https://api.telegram.org/bot<TOKEN>/getUpdates` after step 2 and read `message.chat.id`.
+4. In your app, as early as possible:
+
+```python
+import devalerts
+
+devalerts.init(bot_token="123456:ABC-DEF...", chat_id=123456789)
+```
+
+That's it — any unhandled exception (including ones raised in threads) now
+also lands in your Telegram chat.
+
+## Grouping, rate limiting, and the dashboard
+
+Exceptions are grouped by fingerprint (exception type + file + line where it
+was raised) in a local SQLite file (`~/.devalerts/state.db`). Each group
+sends at most one Telegram message per `rate_limit_seconds` (default 300);
+repeats inside that window are counted but not sent, and the next message
+for that group says how many were skipped. Old groups (untouched for 7 days)
+are pruned automatically. Configure the window via `init()`:
+
+```python
+devalerts.init(bot_token="...", chat_id=123456789, rate_limit_seconds=60)
+```
+
+See what's grouped and what's currently rate-limited:
+
+```
+uv run devalerts dashboard
+```
+
+![devalerts dashboard output](https://raw.githubusercontent.com/sslinNn/devalerts/main/docs/dashboard.svg)
+
+## Manually reporting a caught exception
+
+```python
+try:
+    risky_call()
+except Exception:
+    devalerts.report()  # sends the currently-handled exception
+```
+
+or:
+
+```python
+with devalerts.capture():
+    risky_call()  # reports on exception, then re-raises
+```
+
+`capture` also works as a decorator, so you don't need to touch a function's
+body at all:
+
+```python
+@devalerts.capture()
+def risky_call():
+    ...
+```
+
+## FastAPI / Starlette / any ASGI app
+
+`init()`'s excepthook won't see request errors — the framework already catches
+them internally to return a 500 response, so nothing "unhandled" ever reaches
+the process. Use the ASGI middleware instead:
+
+```python
+app.add_middleware(devalerts.ASGIMiddleware)
+```
+
+Only exceptions that actually escape as server errors get reported — routing
+404s and raised `HTTPException`s are already turned into responses by the
+framework before the middleware sees them.
+
+## Why not Sentry?
+
+If you already run Sentry/Rollbar/etc., keep using it — devalerts isn't a
+replacement. It's for the side project, internal tool, or small service that
+doesn't have (and doesn't want) that infrastructure: no account to create, no
+SDK to configure, no server to trust — just a bot token you already control.
+
+|                          | devalerts          | Sentry-style tracker |
+|--------------------------|---------------------|-----------------------|
+| Setup                    | one bot token       | account + project + SDK config |
+| Backend                  | none — Telegram only | hosted or self-hosted service |
+| Where alerts land        | your Telegram chat  | a web dashboard |
+| Grouping / rate limiting | yes, local SQLite   | yes, server-side |
+| Search, trends, releases | no                  | yes |
+
+## FAQ
+
+**Works with FastAPI / Starlette?**
+Yes — use [`ASGIMiddleware`](#fastapi--starlette--any-asgi-app), since the
+default excepthook never sees request errors.
+
+**Works with Docker?**
+Yes, nothing container-specific. Just make sure `~/.devalerts/` (the dedup
+state file) is either writable inside the container or a mounted volume if
+you want dedup state to survive restarts — it self-recreates otherwise.
+
+**Works with threads?**
+Yes — `init()` installs both `sys.excepthook` and `threading.excepthook`.
+
+**Works with Celery / background workers?**
+Yes, `init()` in the worker process the same way as in a web process. For
+tasks you catch yourself, use `report()` or `@devalerts.capture()`.
+
+**Works on Windows / Linux / macOS?**
+Yes — stdlib only (`urllib`, `sqlite3`, `threading`), no OS-specific code
+paths.
+
+## Privacy & Security
+
+- The only network call devalerts makes is to `api.telegram.org` — no
+  telemetry, no analytics, nothing else phones home.
+- No third-party server and no devalerts-run backend — messages go straight
+  from your process to your own Telegram bot.
+- No accounts, no signup, no API key beyond the bot token you create and
+  control yourself.
+- Basic secret redaction only (a few common token/key patterns) — do not
+  rely on this for sensitive production data; scrub what you can before it
+  ever reaches an exception message.
+
+## What this does NOT do (by design)
+
+- Grouping/rate limiting is local and in-process only (SQLite file, no
+  server) — the dashboard is a CLI table, not a web UI.
+- No backend, no accounts — each user runs their own bot.
+
+## Roadmap
+
+- Web dashboard (hosted, optional — the local CLI dashboard stays either way)
+- Slack delivery
+- Discord delivery
+- Email delivery
+
+## Development
+
+    uv sync --group dev
+    uv run pre-commit install
+
+`pre-commit` runs `ruff check`, `ruff format`, and `mypy` before each commit.
+Run the full check manually with:
+
+    uv run pytest
+    uv run pre-commit run --all-files
+
+## License
+
+MIT — see [LICENSE](LICENSE).

devalerts-0.1.5/README.md

@@ -0,0 +1,199 @@
+# devalerts
+
+[![PyPI](https://img.shields.io/pypi/v/devalerts)](https://pypi.org/project/devalerts/)
+[![Downloads](https://img.shields.io/pypi/dm/devalerts)](https://pypi.org/project/devalerts/)
+[![Python versions](https://img.shields.io/pypi/pyversions/devalerts)](https://pypi.org/project/devalerts/)
+[![License: MIT](https://img.shields.io/pypi/l/devalerts)](LICENSE)
+[![Tests](https://img.shields.io/github/actions/workflow/status/sslinNn/devalerts/test.yml?branch=main&label=tests)](https://github.com/sslinNn/devalerts/actions/workflows/test.yml)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![mypy](https://img.shields.io/badge/mypy-checked-blue)](https://mypy-lang.org/)
+
+[Русская версия](README.ru.md)
+
+Send unhandled Python exceptions straight to a Telegram chat — the moment
+they happen, on your phone. No backend, no account, no database — just your
+own bot token.
+
+```python
+import devalerts
+
+devalerts.init(bot_token="123456:ABC-DEF...", chat_id=123456789)
+```
+
+That's the whole setup. Two minutes with [@BotFather](https://t.me/BotFather)
+and every unhandled crash — including ones raised in threads — lands in your
+chat instead of a log file nobody's watching.
+
+## Why devalerts
+
+- **Zero infrastructure.** No SaaS signup, no ingestion server, no API key
+  to manage beyond your own Telegram bot token. State lives in a local
+  SQLite file you already own.
+- **One line to install, one line to wire up.** `init()` installs the hook
+  and gets out of the way.
+- **Not spam.** Errors are grouped by fingerprint and rate-limited per
+  group, so a crash loop sends one message, not a thousand.
+- **Framework-aware.** Ships an ASGI middleware for FastAPI/Starlette apps,
+  where the default excepthook would never even see a request error.
+- **Small and typed.** No dependencies, ships `py.typed`, ~450 lines total —
+  short enough to read in one sitting before you trust it with your errors.
+
+## Install
+
+    uv add devalerts
+
+(or `pip install devalerts` if you're not using uv)
+
+## Usage
+
+1. Create a bot with [@BotFather](https://t.me/BotFather) and get its token.
+2. Message your bot once (or add it to a group) so it's allowed to message you back.
+3. Get your chat id — message [@userinfobot](https://t.me/userinfobot), or call
+   `https://api.telegram.org/bot<TOKEN>/getUpdates` after step 2 and read `message.chat.id`.
+4. In your app, as early as possible:
+
+```python
+import devalerts
+
+devalerts.init(bot_token="123456:ABC-DEF...", chat_id=123456789)
+```
+
+That's it — any unhandled exception (including ones raised in threads) now
+also lands in your Telegram chat.
+
+## Grouping, rate limiting, and the dashboard
+
+Exceptions are grouped by fingerprint (exception type + file + line where it
+was raised) in a local SQLite file (`~/.devalerts/state.db`). Each group
+sends at most one Telegram message per `rate_limit_seconds` (default 300);
+repeats inside that window are counted but not sent, and the next message
+for that group says how many were skipped. Old groups (untouched for 7 days)
+are pruned automatically. Configure the window via `init()`:
+
+```python
+devalerts.init(bot_token="...", chat_id=123456789, rate_limit_seconds=60)
+```
+
+See what's grouped and what's currently rate-limited:
+
+```
+uv run devalerts dashboard
+```
+
+![devalerts dashboard output](https://raw.githubusercontent.com/sslinNn/devalerts/main/docs/dashboard.svg)
+
+## Manually reporting a caught exception
+
+```python
+try:
+    risky_call()
+except Exception:
+    devalerts.report()  # sends the currently-handled exception
+```
+
+or:
+
+```python
+with devalerts.capture():
+    risky_call()  # reports on exception, then re-raises
+```
+
+`capture` also works as a decorator, so you don't need to touch a function's
+body at all:
+
+```python
+@devalerts.capture()
+def risky_call():
+    ...
+```
+
+## FastAPI / Starlette / any ASGI app
+
+`init()`'s excepthook won't see request errors — the framework already catches
+them internally to return a 500 response, so nothing "unhandled" ever reaches
+the process. Use the ASGI middleware instead:
+
+```python
+app.add_middleware(devalerts.ASGIMiddleware)
+```
+
+Only exceptions that actually escape as server errors get reported — routing
+404s and raised `HTTPException`s are already turned into responses by the
+framework before the middleware sees them.
+
+## Why not Sentry?
+
+If you already run Sentry/Rollbar/etc., keep using it — devalerts isn't a
+replacement. It's for the side project, internal tool, or small service that
+doesn't have (and doesn't want) that infrastructure: no account to create, no
+SDK to configure, no server to trust — just a bot token you already control.
+
+|                          | devalerts          | Sentry-style tracker |
+|--------------------------|---------------------|-----------------------|
+| Setup                    | one bot token       | account + project + SDK config |
+| Backend                  | none — Telegram only | hosted or self-hosted service |
+| Where alerts land        | your Telegram chat  | a web dashboard |
+| Grouping / rate limiting | yes, local SQLite   | yes, server-side |
+| Search, trends, releases | no                  | yes |
+
+## FAQ
+
+**Works with FastAPI / Starlette?**
+Yes — use [`ASGIMiddleware`](#fastapi--starlette--any-asgi-app), since the
+default excepthook never sees request errors.
+
+**Works with Docker?**
+Yes, nothing container-specific. Just make sure `~/.devalerts/` (the dedup
+state file) is either writable inside the container or a mounted volume if
+you want dedup state to survive restarts — it self-recreates otherwise.
+
+**Works with threads?**
+Yes — `init()` installs both `sys.excepthook` and `threading.excepthook`.
+
+**Works with Celery / background workers?**
+Yes, `init()` in the worker process the same way as in a web process. For
+tasks you catch yourself, use `report()` or `@devalerts.capture()`.
+
+**Works on Windows / Linux / macOS?**
+Yes — stdlib only (`urllib`, `sqlite3`, `threading`), no OS-specific code
+paths.
+
+## Privacy & Security
+
+- The only network call devalerts makes is to `api.telegram.org` — no
+  telemetry, no analytics, nothing else phones home.
+- No third-party server and no devalerts-run backend — messages go straight
+  from your process to your own Telegram bot.
+- No accounts, no signup, no API key beyond the bot token you create and
+  control yourself.
+- Basic secret redaction only (a few common token/key patterns) — do not
+  rely on this for sensitive production data; scrub what you can before it
+  ever reaches an exception message.
+
+## What this does NOT do (by design)
+
+- Grouping/rate limiting is local and in-process only (SQLite file, no
+  server) — the dashboard is a CLI table, not a web UI.
+- No backend, no accounts — each user runs their own bot.
+
+## Roadmap
+
+- Web dashboard (hosted, optional — the local CLI dashboard stays either way)
+- Slack delivery
+- Discord delivery
+- Email delivery
+
+## Development
+
+    uv sync --group dev
+    uv run pre-commit install
+
+`pre-commit` runs `ruff check`, `ruff format`, and `mypy` before each commit.
+Run the full check manually with:
+
+    uv run pytest
+    uv run pre-commit run --all-files
+
+## License
+
+MIT — see [LICENSE](LICENSE).

devalerts-0.1.5/pyproject.toml

@@ -0,0 +1,61 @@
+[project]
+name = "devalerts"
+version = "0.1.5"
+description = "Send unhandled Python exceptions straight to a Telegram chat. No backend, no account, no database — just your own bot token."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "sslinNn", email = "morison1991@mail.ru" }
+]
+requires-python = ">=3.9"
+dependencies = []
+keywords = [
+    "telegram",
+    "error-tracking",
+    "exception-monitoring",
+    "alerts",
+    "logging",
+    "monitoring",
+    "asgi",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Debuggers",
+    "Topic :: System :: Monitoring",
+    "Typing :: Typed",
+]
+
+[project.urls]
+Homepage = "https://github.com/sslinNn/devalerts"
+Repository = "https://github.com/sslinNn/devalerts"
+"Bug Tracker" = "https://github.com/sslinNn/devalerts/issues"
+
+[project.scripts]
+devalerts = "devalerts.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.10.2,<0.12.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "mypy>=1.19.1",
+    "pre-commit>=4.3.0",
+    "pytest>=8.4.2",
+    "ruff>=0.15.22",
+]
+
+[tool.ruff]
+target-version = "py39"
+
+[tool.ruff.lint]
+extend-select = ["BLE"]

devalerts-0.1.5/src/devalerts/__init__.py

@@ -0,0 +1,162 @@
+"""Send unhandled Python exceptions straight to a Telegram chat."""
+
+from __future__ import annotations
+
+import contextlib
+import sys
+import threading
+from types import TracebackType
+from typing import Callable, Literal, Optional, TypedDict
+
+from ._alert import _format_alert, _redact
+from ._store import _DEFAULT_RATE_LIMIT_SECONDS, _fingerprint, _should_send
+from ._telegram import _send_telegram_message
+
+__all__: list[str] = ["init", "report", "capture", "ASGIMiddleware"]
+
+_ExceptHook = Callable[
+    [type[BaseException], BaseException, Optional[TracebackType]], object
+]
+_ThreadingExceptHook = Callable[[threading.ExceptHookArgs], object]
+
+
+class _State(TypedDict):
+    bot_token: str | None
+    chat_id: int | str | None
+    redact: bool
+    rate_limit_seconds: int
+    # Seeded with the real default hooks below (never None) -- _excepthook/
+    # _threading_excepthook can only ever fire after init() has replaced
+    # sys.excepthook/threading.excepthook, by which point these are always
+    # set, so keeping them non-Optional avoids an unreachable None check.
+    prev_excepthook: _ExceptHook
+    prev_threading_excepthook: _ThreadingExceptHook
+
+
+_state: _State = {
+    "bot_token": None,
+    "chat_id": None,
+    "redact": True,
+    "rate_limit_seconds": _DEFAULT_RATE_LIMIT_SECONDS,
+    "prev_excepthook": sys.excepthook,
+    "prev_threading_excepthook": threading.excepthook,
+}
+
+
+def _send_exception(exc_type, exc_value, tb) -> None:
+    if _state["bot_token"] is None or _state["chat_id"] is None:
+        print("devalerts: init() was not called, dropping alert", file=sys.stderr)
+        return
+    fingerprint, location = _fingerprint(exc_type, tb)
+    send, skipped = _should_send(
+        fingerprint, exc_type.__name__, location, _state["rate_limit_seconds"]
+    )
+    if not send:
+        return
+    message = _format_alert(exc_type, exc_value, tb, skipped=skipped)
+    if _state["redact"]:
+        message = _redact(message)
+    _send_telegram_message(_state["bot_token"], _state["chat_id"], message)
+
+
+def _excepthook(exc_type, exc_value, tb) -> None:
+    if exc_type is not KeyboardInterrupt:
+        try:
+            _send_exception(exc_type, exc_value, tb)
+        except Exception as error:  # noqa: BLE001 - crash handler must never raise
+            print(
+                f"devalerts: internal error while sending alert: {error}",
+                file=sys.stderr,
+            )
+    _state["prev_excepthook"](exc_type, exc_value, tb)
+
+
+def _threading_excepthook(args) -> None:
+    try:
+        _send_exception(args.exc_type, args.exc_value, args.exc_traceback)
+    except Exception as error:  # noqa: BLE001
+        print(
+            f"devalerts: internal error while sending alert: {error}", file=sys.stderr
+        )
+    _state["prev_threading_excepthook"](args)
+
+
+def init(
+    bot_token: str,
+    chat_id: int | str,
+    *,
+    redact: bool = True,
+    rate_limit_seconds: int = _DEFAULT_RATE_LIMIT_SECONDS,
+) -> None:
+    """Install a global exception hook that sends unhandled exceptions to Telegram."""
+    _state["bot_token"] = bot_token
+    _state["chat_id"] = chat_id
+    _state["redact"] = redact
+    _state["rate_limit_seconds"] = rate_limit_seconds
+    # ponytail: guard against calling init() twice capturing our own hook as
+    # "previous" -- that would make _excepthook chain to itself and recurse
+    # forever on the next crash, violating "must never raise".
+    if sys.excepthook is not _excepthook:
+        _state["prev_excepthook"] = sys.excepthook
+    if threading.excepthook is not _threading_excepthook:
+        _state["prev_threading_excepthook"] = threading.excepthook
+    sys.excepthook = _excepthook
+    threading.excepthook = _threading_excepthook
+
+
+def report(exc: BaseException | None = None) -> None:
+    """Manually send a caught exception to Telegram."""
+    if exc is None:
+        exc_type, exc_value, tb = sys.exc_info()
+        if exc_type is None:
+            raise RuntimeError(
+                "report() requires an active exception or an exc argument"
+            )
+    else:
+        exc_type, exc_value, tb = type(exc), exc, exc.__traceback__
+    _send_exception(exc_type, exc_value, tb)
+
+
+class capture(contextlib.ContextDecorator):
+    """Context manager / decorator: report any exception raised inside the block or
+    function, then re-raise it. Use ``@capture()`` on a function instead of wrapping
+    its body in a manual ``try/except`` or ``with`` block."""
+
+    def __enter__(self) -> "capture":
+        return self
+
+    def __exit__(self, exc_type, exc_value, tb) -> Literal[False]:
+        if exc_type is not None:
+            _send_exception(exc_type, exc_value, tb)
+        return False
+
+
+class ASGIMiddleware:
+    """ASGI middleware for FastAPI/Starlette (or any ASGI app): report any exception
+    that escapes a request, then re-raise it so the framework's own error handling
+    still runs unchanged.
+
+    Usage::
+
+        app.add_middleware(devalerts.ASGIMiddleware)
+
+    Only exceptions that actually reach here (unhandled server errors) get reported —
+    routing 404s and raised ``HTTPException``s are already turned into responses by
+    the framework before this middleware sees them, same as Sentry's ASGI integration.
+    """
+
+    def __init__(self, app) -> None:
+        self.app = app
+
+    async def __call__(self, scope, receive, send) -> None:
+        try:
+            await self.app(scope, receive, send)
+        except Exception:
+            exc_type, exc_value, tb = sys.exc_info()
+            # ponytail: fire-and-forget in a thread -- _send_exception is a
+            # blocking network call; awaiting it here would stall the event
+            # loop (and the error response) for up to _TIMEOUT_SECONDS.
+            threading.Thread(
+                target=_send_exception, args=(exc_type, exc_value, tb), daemon=True
+            ).start()
+            raise