devalerts 0.1.4__tar.gz → 0.2.0__tar.gz

{devalerts-0.1.4 → devalerts-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devalerts
-Version: 0.1.4
+Version: 0.2.0
 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
@@ -28,8 +28,12 @@ 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)
 
@@ -73,7 +77,13 @@ chat instead of a log file nobody's watching.
 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:
+4. Verify it's wired up correctly before touching any code:
+
+   ```
+   uv run devalerts test --bot-token 123456:ABC-DEF... --chat-id 123456789
+   ```
+
+5. In your app, as early as possible:
 
 ```python
 import devalerts
@@ -103,13 +113,48 @@ 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)
+
+Pass `--json` for machine-readable output. Silence a noisy group without
+touching code — the `ID` column accepts any unique prefix:
+
+```
+uv run devalerts mute abc12345
+uv run devalerts unmute abc12345
+uv run devalerts clear abc12345   # or: devalerts clear --all
 ```
-  ID        TYPE          LOCATION                            LAST SEEN TOTAL   STATUS
-  ────────────────────────────────────────────────────────────────────────────────────
-  a1b2c3d4  ValueError    app/orders.py:42                     2m ago       14   ● limited
-  9f8e7d6c  KeyError      app/handlers/webhook.py:88            just now      1   ● sending
 
-  2 error groups, 1 currently rate-limited.
+Unmuting resends the next occurrence with the accumulated skip count, same
+as a rate-limit window expiring.
+
+Error groups that keep piling up while suppressed are chronic: each such
+resend doubles the effective `rate_limit_seconds` for that group (capped at
+8x), so a crash loop backs itself off instead of paging you every window
+forever. A group that goes quiet and reappears once resets to the base rate
+immediately. The dashboard shows the active multiplier (`● sending ×4`).
+
+## Context: hostname and tags
+
+Every alert automatically includes the sending host, so you can tell which
+process/server it came from when one bot serves several:
+
+```python
+devalerts.init(bot_token="...", chat_id=123456789, tags={"env": "production"})
+```
+
+```
+🔴 ValueError: boom
+🖥️ prod-web-2 (env=production)
+```
+
+Add ad-hoc tags to a single call — they override `init()`'s tags on a key
+collision:
+
+```python
+devalerts.report(extra={"request_id": "abc123"})
+
+@devalerts.capture(extra={"job": "nightly-sync"})
+def run_job(): ...
 ```
 
 ## Manually reporting a caught exception
@@ -151,11 +196,30 @@ 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.
 
-## devalerts vs. a full error tracker
+## Celery
+
+Same problem as ASGI apps: `init()`'s excepthook never sees exceptions raised
+inside a task, because Celery catches them itself to record the task's
+`FAILURE` state. Call `init_celery()` in addition to `init()`:
 
-If you already run Sentry/Rollbar/etc., keep using it — this isn't a
-replacement. devalerts is for the side project, internal tool, or small
-service that doesn't have (and doesn't want) that infrastructure yet:
+```python
+devalerts.init(bot_token="...", chat_id=123456789)
+devalerts.init_celery()
+```
+
+This connects to Celery's `task_failure` signal (fired once a task has
+genuinely failed — retries exhausted or none configured, so retried tasks
+don't spam an alert per attempt) and reports through the same
+grouping/rate-limiting/redaction path as everything else, tagged with the
+task name and id automatically. Requires Celery to already be installed in
+the worker process — it's imported lazily, not a devalerts dependency.
+
+## 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 |
 |--------------------------|---------------------|-----------------------|
@@ -165,14 +229,66 @@ service that doesn't have (and doesn't want) that infrastructure yet:
 | 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 — call [`init_celery()`](#celery) in addition to `init()` to catch
+exceptions raised inside tasks, which the excepthook alone won't see.
+
+**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.
+- If Telegram delivery fails after retrying, the alert (already redacted, if
+  `redact=True`) is appended to `~/.devalerts/failed.log` instead of being
+  dropped — clean it up like any other local log file.
+
 ## 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.
-- Basic secret redaction only (a few common token patterns) — do not rely
-  on this for sensitive production data.
-- No automated test suite — verified manually during implementation only.
+
+## 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
 

devalerts-0.2.0/README.md

@@ -0,0 +1,268 @@
+# 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. Verify it's wired up correctly before touching any code:
+
+   ```
+   uv run devalerts test --bot-token 123456:ABC-DEF... --chat-id 123456789
+   ```
+
+5. 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)
+
+Pass `--json` for machine-readable output. Silence a noisy group without
+touching code — the `ID` column accepts any unique prefix:
+
+```
+uv run devalerts mute abc12345
+uv run devalerts unmute abc12345
+uv run devalerts clear abc12345   # or: devalerts clear --all
+```
+
+Unmuting resends the next occurrence with the accumulated skip count, same
+as a rate-limit window expiring.
+
+Error groups that keep piling up while suppressed are chronic: each such
+resend doubles the effective `rate_limit_seconds` for that group (capped at
+8x), so a crash loop backs itself off instead of paging you every window
+forever. A group that goes quiet and reappears once resets to the base rate
+immediately. The dashboard shows the active multiplier (`● sending ×4`).
+
+## Context: hostname and tags
+
+Every alert automatically includes the sending host, so you can tell which
+process/server it came from when one bot serves several:
+
+```python
+devalerts.init(bot_token="...", chat_id=123456789, tags={"env": "production"})
+```
+
+```
+🔴 ValueError: boom
+🖥️ prod-web-2 (env=production)
+```
+
+Add ad-hoc tags to a single call — they override `init()`'s tags on a key
+collision:
+
+```python
+devalerts.report(extra={"request_id": "abc123"})
+
+@devalerts.capture(extra={"job": "nightly-sync"})
+def run_job(): ...
+```
+
+## 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.
+
+## Celery
+
+Same problem as ASGI apps: `init()`'s excepthook never sees exceptions raised
+inside a task, because Celery catches them itself to record the task's
+`FAILURE` state. Call `init_celery()` in addition to `init()`:
+
+```python
+devalerts.init(bot_token="...", chat_id=123456789)
+devalerts.init_celery()
+```
+
+This connects to Celery's `task_failure` signal (fired once a task has
+genuinely failed — retries exhausted or none configured, so retried tasks
+don't spam an alert per attempt) and reports through the same
+grouping/rate-limiting/redaction path as everything else, tagged with the
+task name and id automatically. Requires Celery to already be installed in
+the worker process — it's imported lazily, not a devalerts dependency.
+
+## 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 — call [`init_celery()`](#celery) in addition to `init()` to catch
+exceptions raised inside tasks, which the excepthook alone won't see.
+
+**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.
+- If Telegram delivery fails after retrying, the alert (already redacted, if
+  `redact=True`) is appended to `~/.devalerts/failed.log` instead of being
+  dropped — clean it up like any other local log file.
+
+## 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.4 → devalerts-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "devalerts"
-version = "0.1.4"
+version = "0.2.0"
 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"
@@ -43,8 +43,20 @@ Repository = "https://github.com/sslinNn/devalerts"
 devalerts = "devalerts.cli:main"
 
 [build-system]
-requires = ["uv_build>=0.10.2,<0.11.0"]
+requires = ["uv_build>=0.10.2,<0.12.0"]
 build-backend = "uv_build"
 
 [dependency-groups]
-dev = []
+dev = [
+    "celery>=5.3.0",
+    "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.4 → devalerts-0.2.0}/src/devalerts/__init__.py

@@ -5,29 +5,61 @@ 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 ._celery import init_celery
 from ._store import _DEFAULT_RATE_LIMIT_SECONDS, _fingerprint, _should_send
 from ._telegram import _send_telegram_message
 
-__all__: list[str] = ["init", "report", "capture", "ASGIMiddleware"]
+__all__: list[str] = ["init", "report", "capture", "ASGIMiddleware", "init_celery"]
 
-_state = {
+_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
+    tags: dict[str, str]
+    # 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": None,
-    "prev_threading_excepthook": None,
+    "tags": {},
+    "prev_excepthook": sys.excepthook,
+    "prev_threading_excepthook": threading.excepthook,
 }
 
 
-def _send_exception(exc_type, exc_value, tb) -> None:
+def _send_exception(
+    exc_type, exc_value, tb, extra: dict[str, str] | None = None
+) -> 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"])
+    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)
+    tags = {**_state["tags"], **(extra or {})}
+    message = _format_alert(exc_type, exc_value, tb, skipped=skipped, tags=tags)
     if _state["redact"]:
         message = _redact(message)
     _send_telegram_message(_state["bot_token"], _state["chat_id"], message)
@@ -38,7 +70,10 @@ def _excepthook(exc_type, exc_value, tb) -> None:
         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)
+            print(
+                f"devalerts: internal error while sending alert: {error}",
+                file=sys.stderr,
+            )
     _state["prev_excepthook"](exc_type, exc_value, tb)
 
 
@@ -46,22 +81,26 @@ 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)
+        print(
+            f"devalerts: internal error while sending alert: {error}", file=sys.stderr
+        )
     _state["prev_threading_excepthook"](args)
 
 
 def init(
     bot_token: str,
-    chat_id,
+    chat_id: int | str,
     *,
     redact: bool = True,
     rate_limit_seconds: int = _DEFAULT_RATE_LIMIT_SECONDS,
+    tags: dict[str, str] | None = None,
 ) -> 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
+    _state["tags"] = tags or {}
     # 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".
@@ -73,15 +112,19 @@ def init(
     threading.excepthook = _threading_excepthook
 
 
-def report(exc: BaseException | None = None) -> None:
+def report(
+    exc: BaseException | None = None, *, extra: dict[str, str] | 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")
+            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)
+    _send_exception(exc_type, exc_value, tb, extra=extra)
 
 
 class capture(contextlib.ContextDecorator):
@@ -89,12 +132,15 @@ class capture(contextlib.ContextDecorator):
     function, then re-raise it. Use ``@capture()`` on a function instead of wrapping
     its body in a manual ``try/except`` or ``with`` block."""
 
+    def __init__(self, *, extra: dict[str, str] | None = None) -> None:
+        self._extra = extra
+
     def __enter__(self) -> "capture":
         return self
 
-    def __exit__(self, exc_type, exc_value, tb) -> bool:
+    def __exit__(self, exc_type, exc_value, tb) -> Literal[False]:
         if exc_type is not None:
-            _send_exception(exc_type, exc_value, tb)
+            _send_exception(exc_type, exc_value, tb, extra=self._extra)
         return False
 
 

{devalerts-0.1.4 → devalerts-0.2.0}/src/devalerts/_alert.py

@@ -3,13 +3,27 @@
 from __future__ import annotations
 
 import re
+import socket
 import traceback
 
 _MAX_MESSAGE_LENGTH = 4096
 
 
-def _format_alert(exc_type, exc_value, tb, skipped: int = 0) -> str:
-    header = f"\U0001F534 {exc_type.__name__}: {exc_value}"
+def _format_context(tags: dict[str, str] | None) -> str:
+    try:
+        hostname = socket.gethostname()
+    except OSError:
+        hostname = "unknown-host"
+    line = f"🖥️ {hostname}"
+    if tags:
+        line += " (" + ", ".join(f"{key}={value}" for key, value in tags.items()) + ")"
+    return line
+
+
+def _format_alert(
+    exc_type, exc_value, tb, skipped: int = 0, tags: dict[str, str] | None = None
+) -> str:
+    header = f"\U0001f534 {exc_type.__name__}: {exc_value}\n{_format_context(tags)}"
     if skipped:
         header += f"\n⚠️ Повторилась ещё {skipped} раз(а) с последнего алерта"
     body = "".join(traceback.format_exception(exc_type, exc_value, tb))