devalerts 0.2.3__tar.gz → 0.4.0__tar.gz

{devalerts-0.2.3 → devalerts-0.4.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: devalerts
-Version: 0.2.3
-Summary: Send unhandled Python exceptions straight to a Telegram chat. No backend, no account, no database — just your own bot token.
+Version: 0.4.0
+Summary: Send unhandled Python exceptions straight to a Telegram chat (or Slack). No backend, no account, no database — just your own bot token or webhook URL.
 Keywords: telegram,error-tracking,exception-monitoring,alerts,logging,monitoring,asgi
 Author: sslinNn
 Author-email: sslinNn <morison1991@mail.ru>
@@ -28,7 +28,7 @@ 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/)
+[![PyPI Downloads](https://static.pepy.tech/personalized-badge/devalerts?period=total&units=INTERNATIONAL_SYSTEM&left_color=GREY&right_color=BLUE&left_text=downloads)](https://pepy.tech/projects/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)
@@ -37,9 +37,9 @@ Description-Content-Type: text/markdown
 
 [Русская версия](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.
+Send unhandled Python exceptions straight to a Telegram chat (or Slack) —
+the moment they happen, on your phone. No backend, no account, no database —
+just your own bot token or webhook URL.
 
 ```python
 import devalerts
@@ -139,6 +139,34 @@ resend doubles the effective `rate_limit_seconds` for that group (capped at
 forever. A group that goes quiet and reappears once resets to the base rate
 immediately. The dashboard shows the active multiplier (`● sending ×4`).
 
+## Crash streak badge
+
+`devalerts dashboard` also reports how long it's been since the last
+recorded incident (sent or suppressed by rate-limiting) — same idea as the
+classic "days since last workplace accident" sign, applied to your crashes:
+
+```
+🟢 14 days since the last incident.
+```
+
+Get the same number as a shareable SVG badge for your README:
+
+```
+uv run devalerts badge --out docs/streak.svg
+```
+
+![devalerts crash streak badge](https://raw.githubusercontent.com/sslinNn/devalerts/main/docs/streak-badge.svg)
+
+No hosting, no cron job built in — regenerate and commit it yourself,
+e.g. on a schedule with GitHub Actions:
+
+```yaml
+- run: uv run devalerts badge --out docs/streak.svg
+- run: git add docs/streak.svg && git commit -m "Update crash streak badge" || true
+```
+
+Pass `--label` to customize the left-hand text (default `"crash streak"`).
+
 ## Context: hostname and tags
 
 Every alert automatically includes the sending host, so you can tell which
@@ -232,6 +260,60 @@ 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.
 
+## Logged (not raised) exceptions
+
+`init()`'s excepthook only ever sees exceptions that stay unhandled — but most
+real errors are caught and logged instead: `logger.exception(...)` inside a
+`try/except` never propagates anywhere. Attach `LogHandler` to catch those too:
+
+```python
+import logging
+
+logging.getLogger().addHandler(devalerts.LogHandler())
+```
+
+A record with `exc_info` (`logger.exception()`, or `logger.error(...,
+exc_info=True)`) is reported like a full exception alert — grouped by the
+same fingerprint an unhandled instance of it would use, so logging it and
+then re-raising sends one alert, not two. A plain `logger.error("message")`
+with no exception attached is reported as a short text alert, grouped by
+logger name + level + message. Defaults to `level=logging.ERROR`; pass
+`extra={...}` for tags added to every alert from this handler.
+
+## Blame
+
+Curious *who* wrote the line that just blew up? `blame=True` runs `git blame`
+on it and adds the author, short commit hash, and date to the alert:
+
+```python
+devalerts.init(bot_token="...", chat_id=123456789, blame=True)
+```
+
+```
+🕵️ blame: sslinNn · a1b2c3d · 2026-07-15 (3d ago)
+```
+
+Best-effort and silent about it — no git installed, no repo (a container
+image without `.git`), or the line isn't committed yet all just skip the
+line instead of failing the alert. Off by default; opt in with `blame=True`.
+
+## Slack
+
+Prefer Slack, or want both? Pass a Slack incoming webhook URL alongside or
+instead of `bot_token`/`chat_id` — every configured channel gets every alert:
+
+```python
+devalerts.init(slack_webhook_url="https://hooks.slack.com/services/...")
+```
+
+Create one at [api.slack.com/apps](https://api.slack.com/apps) → your app →
+**Incoming Webhooks**. Same grouping/rate-limiting/redaction/blame path as
+Telegram, formatted as Slack mrkdwn instead of HTML. Verify it's wired up:
+
+```
+uv run devalerts test --slack-webhook-url https://hooks.slack.com/services/...
+```
+
 ## Why not Sentry?
 
 If you already run Sentry/Rollbar/etc., keep using it — devalerts isn't a
@@ -265,22 +347,27 @@ Yes — `init()` installs both `sys.excepthook` and `threading.excepthook`.
 Yes — call [`init_celery()`](#celery) in addition to `init()` to catch
 exceptions raised inside tasks, which the excepthook alone won't see.
 
+**Catches exceptions I log but don't re-raise?**
+Yes — add [`LogHandler`](#logged-not-raised-exceptions) to a logger; the
+excepthook alone never sees a caught-and-logged exception.
+
 **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.
+- The only network calls devalerts makes are to `api.telegram.org` and/or
+  your configured Slack incoming webhook — 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.
+  from your process to your own Telegram bot / Slack webhook.
+- No accounts, no signup, no API key beyond the bot token / webhook URL 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
+- If 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.
 
@@ -293,7 +380,6 @@ paths.
 ## Roadmap
 
 - Web dashboard (hosted, optional — the local CLI dashboard stays either way)
-- Slack delivery
 - Discord delivery
 - Email delivery
 

{devalerts-0.2.3 → devalerts-0.4.0}/README.md

@@ -1,7 +1,7 @@
 # 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/)
+[![PyPI Downloads](https://static.pepy.tech/personalized-badge/devalerts?period=total&units=INTERNATIONAL_SYSTEM&left_color=GREY&right_color=BLUE&left_text=downloads)](https://pepy.tech/projects/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)
@@ -10,9 +10,9 @@
 
 [Русская версия](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.
+Send unhandled Python exceptions straight to a Telegram chat (or Slack) —
+the moment they happen, on your phone. No backend, no account, no database —
+just your own bot token or webhook URL.
 
 ```python
 import devalerts
@@ -112,6 +112,34 @@ resend doubles the effective `rate_limit_seconds` for that group (capped at
 forever. A group that goes quiet and reappears once resets to the base rate
 immediately. The dashboard shows the active multiplier (`● sending ×4`).
 
+## Crash streak badge
+
+`devalerts dashboard` also reports how long it's been since the last
+recorded incident (sent or suppressed by rate-limiting) — same idea as the
+classic "days since last workplace accident" sign, applied to your crashes:
+
+```
+🟢 14 days since the last incident.
+```
+
+Get the same number as a shareable SVG badge for your README:
+
+```
+uv run devalerts badge --out docs/streak.svg
+```
+
+![devalerts crash streak badge](https://raw.githubusercontent.com/sslinNn/devalerts/main/docs/streak-badge.svg)
+
+No hosting, no cron job built in — regenerate and commit it yourself,
+e.g. on a schedule with GitHub Actions:
+
+```yaml
+- run: uv run devalerts badge --out docs/streak.svg
+- run: git add docs/streak.svg && git commit -m "Update crash streak badge" || true
+```
+
+Pass `--label` to customize the left-hand text (default `"crash streak"`).
+
 ## Context: hostname and tags
 
 Every alert automatically includes the sending host, so you can tell which
@@ -205,6 +233,60 @@ 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.
 
+## Logged (not raised) exceptions
+
+`init()`'s excepthook only ever sees exceptions that stay unhandled — but most
+real errors are caught and logged instead: `logger.exception(...)` inside a
+`try/except` never propagates anywhere. Attach `LogHandler` to catch those too:
+
+```python
+import logging
+
+logging.getLogger().addHandler(devalerts.LogHandler())
+```
+
+A record with `exc_info` (`logger.exception()`, or `logger.error(...,
+exc_info=True)`) is reported like a full exception alert — grouped by the
+same fingerprint an unhandled instance of it would use, so logging it and
+then re-raising sends one alert, not two. A plain `logger.error("message")`
+with no exception attached is reported as a short text alert, grouped by
+logger name + level + message. Defaults to `level=logging.ERROR`; pass
+`extra={...}` for tags added to every alert from this handler.
+
+## Blame
+
+Curious *who* wrote the line that just blew up? `blame=True` runs `git blame`
+on it and adds the author, short commit hash, and date to the alert:
+
+```python
+devalerts.init(bot_token="...", chat_id=123456789, blame=True)
+```
+
+```
+🕵️ blame: sslinNn · a1b2c3d · 2026-07-15 (3d ago)
+```
+
+Best-effort and silent about it — no git installed, no repo (a container
+image without `.git`), or the line isn't committed yet all just skip the
+line instead of failing the alert. Off by default; opt in with `blame=True`.
+
+## Slack
+
+Prefer Slack, or want both? Pass a Slack incoming webhook URL alongside or
+instead of `bot_token`/`chat_id` — every configured channel gets every alert:
+
+```python
+devalerts.init(slack_webhook_url="https://hooks.slack.com/services/...")
+```
+
+Create one at [api.slack.com/apps](https://api.slack.com/apps) → your app →
+**Incoming Webhooks**. Same grouping/rate-limiting/redaction/blame path as
+Telegram, formatted as Slack mrkdwn instead of HTML. Verify it's wired up:
+
+```
+uv run devalerts test --slack-webhook-url https://hooks.slack.com/services/...
+```
+
 ## Why not Sentry?
 
 If you already run Sentry/Rollbar/etc., keep using it — devalerts isn't a
@@ -238,22 +320,27 @@ Yes — `init()` installs both `sys.excepthook` and `threading.excepthook`.
 Yes — call [`init_celery()`](#celery) in addition to `init()` to catch
 exceptions raised inside tasks, which the excepthook alone won't see.
 
+**Catches exceptions I log but don't re-raise?**
+Yes — add [`LogHandler`](#logged-not-raised-exceptions) to a logger; the
+excepthook alone never sees a caught-and-logged exception.
+
 **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.
+- The only network calls devalerts makes are to `api.telegram.org` and/or
+  your configured Slack incoming webhook — 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.
+  from your process to your own Telegram bot / Slack webhook.
+- No accounts, no signup, no API key beyond the bot token / webhook URL 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
+- If 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.
 
@@ -266,7 +353,6 @@ paths.
 ## Roadmap
 
 - Web dashboard (hosted, optional — the local CLI dashboard stays either way)
-- Slack delivery
 - Discord delivery
 - Email delivery
 

{devalerts-0.2.3 → devalerts-0.4.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "devalerts"
-version = "0.2.3"
-description = "Send unhandled Python exceptions straight to a Telegram chat. No backend, no account, no database — just your own bot token."
+version = "0.4.0"
+description = "Send unhandled Python exceptions straight to a Telegram chat (or Slack). No backend, no account, no database — just your own bot token or webhook URL."
 readme = "README.md"
 license = "MIT"
 license-files = ["LICENSE"]

{devalerts-0.2.3 → devalerts-0.4.0}/src/devalerts/__init__.py

@@ -1,19 +1,40 @@
-"""Send unhandled Python exceptions straight to a Telegram chat."""
+"""Send unhandled Python exceptions straight to a Telegram chat and/or Slack."""
 
 from __future__ import annotations
 
 import contextlib
+import logging
 import sys
 import threading
 from types import TracebackType
 from typing import Callable, Literal, Optional, TypedDict
 
-from ._alert import _format_alert, _redact
+from ._alert import (
+    _format_alert,
+    _format_alert_slack,
+    _format_log_alert,
+    _format_log_alert_slack,
+    _redact,
+)
+from ._blame import _git_blame_for_traceback
 from ._celery import init_celery
-from ._store import _DEFAULT_RATE_LIMIT_SECONDS, _fingerprint, _should_send
+from ._slack import _send_slack_message
+from ._store import (
+    _DEFAULT_RATE_LIMIT_SECONDS,
+    _fingerprint,
+    _fingerprint_log,
+    _should_send,
+)
 from ._telegram import _send_telegram_message
 
-__all__: list[str] = ["init", "report", "capture", "ASGIMiddleware", "init_celery"]
+__all__: list[str] = [
+    "init",
+    "report",
+    "capture",
+    "ASGIMiddleware",
+    "LogHandler",
+    "init_celery",
+]
 
 _ExceptHook = Callable[
     [type[BaseException], BaseException, Optional[TracebackType]], object
@@ -24,9 +45,11 @@ _ThreadingExceptHook = Callable[[threading.ExceptHookArgs], object]
 class _State(TypedDict):
     bot_token: str | None
     chat_id: int | str | None
+    slack_webhook_url: str | None
     redact: bool
     rate_limit_seconds: int
     tags: dict[str, str]
+    blame: bool
     # 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
@@ -38,31 +61,105 @@ class _State(TypedDict):
 _state: _State = {
     "bot_token": None,
     "chat_id": None,
+    "slack_webhook_url": None,
     "redact": True,
     "rate_limit_seconds": _DEFAULT_RATE_LIMIT_SECONDS,
     "tags": {},
+    "blame": False,
     "prev_excepthook": sys.excepthook,
     "prev_threading_excepthook": threading.excepthook,
 }
 
 
+def _configured() -> bool:
+    return bool(
+        (_state["bot_token"] and _state["chat_id"]) or _state["slack_webhook_url"]
+    )
+
+
+def _deliver(format_telegram, format_slack) -> None:
+    """Formats and sends to every channel init() configured -- each channel gets its
+    own formatting call since Telegram (HTML) and Slack (mrkdwn) need different
+    markup, but both share the same fingerprint/dedup decision made by the caller."""
+    if _state["bot_token"] and _state["chat_id"]:
+        message = format_telegram()
+        if _state["redact"]:
+            message = _redact(message)
+        _send_telegram_message(_state["bot_token"], _state["chat_id"], message)
+    if _state["slack_webhook_url"]:
+        message = format_slack()
+        if _state["redact"]:
+            message = _redact(message)
+        _send_slack_message(_state["slack_webhook_url"], message)
+
+
 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:
+    if not _configured():
         print("devalerts: init() was not called, dropping alert", file=sys.stderr)
         return
     fingerprint, location = _fingerprint(exc_type, tb)
-    send, skipped = _should_send(
+    send, skipped, is_new = _should_send(
         fingerprint, exc_type.__name__, location, _state["rate_limit_seconds"]
     )
     if not send:
         return
     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)
+    blame = _git_blame_for_traceback(tb) if _state["blame"] else None
+    _deliver(
+        lambda: _format_alert(
+            exc_type,
+            exc_value,
+            tb,
+            skipped=skipped,
+            tags=tags,
+            blame=blame,
+            is_new=is_new,
+        ),
+        lambda: _format_alert_slack(
+            exc_type,
+            exc_value,
+            tb,
+            skipped=skipped,
+            tags=tags,
+            blame=blame,
+            is_new=is_new,
+        ),
+    )
+
+
+def _send_log(record: logging.LogRecord, extra: dict[str, str] | None = None) -> None:
+    if not _configured():
+        print("devalerts: init() was not called, dropping alert", file=sys.stderr)
+        return
+    fingerprint, location = _fingerprint_log(
+        record.name, record.levelno, str(record.msg), record.pathname, record.lineno
+    )
+    send, skipped, is_new = _should_send(
+        fingerprint, record.name, location, _state["rate_limit_seconds"]
+    )
+    if not send:
+        return
+    tags = {**_state["tags"], **(extra or {})}
+    _deliver(
+        lambda: _format_log_alert(
+            record.name,
+            record.levelname,
+            record.getMessage(),
+            skipped=skipped,
+            tags=tags,
+            is_new=is_new,
+        ),
+        lambda: _format_log_alert_slack(
+            record.name,
+            record.levelname,
+            record.getMessage(),
+            skipped=skipped,
+            tags=tags,
+            is_new=is_new,
+        ),
+    )
 
 
 def _excepthook(exc_type, exc_value, tb) -> None:
@@ -88,19 +185,33 @@ def _threading_excepthook(args) -> None:
 
 
 def init(
-    bot_token: str,
-    chat_id: int | str,
+    bot_token: str | None = None,
+    chat_id: int | str | None = None,
     *,
+    slack_webhook_url: str | None = None,
     redact: bool = True,
     rate_limit_seconds: int = _DEFAULT_RATE_LIMIT_SECONDS,
     tags: dict[str, str] | None = None,
+    blame: bool = False,
 ) -> None:
-    """Install a global exception hook that sends unhandled exceptions to Telegram."""
+    """Install a global exception hook that sends unhandled exceptions to Telegram
+    and/or Slack. Requires ``bot_token``+``chat_id``, ``slack_webhook_url``, or both
+    -- configured channels all receive every alert.
+
+    ``blame=True`` runs ``git blame`` on the line that raised and adds the
+    author/commit/date to the alert -- best-effort, silently skipped if
+    there's no git repo (e.g. a container image without ``.git``)."""
+    if bool(bot_token) != bool(chat_id):
+        raise ValueError("bot_token and chat_id must be given together")
+    if not bot_token and not slack_webhook_url:
+        raise ValueError("init() requires bot_token+chat_id and/or slack_webhook_url")
     _state["bot_token"] = bot_token
     _state["chat_id"] = chat_id
+    _state["slack_webhook_url"] = slack_webhook_url
     _state["redact"] = redact
     _state["rate_limit_seconds"] = rate_limit_seconds
     _state["tags"] = tags or {}
+    _state["blame"] = blame
     # 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".
@@ -185,3 +296,39 @@ class ASGIMiddleware:
                 target=_send_exception, args=(exc_type, exc_value, tb), daemon=True
             ).start()
             raise
+
+
+class LogHandler(logging.Handler):
+    """logging.Handler: report ERROR+ log records to every channel init()
+    configured -- catches exceptions
+    that are logged and swallowed (``logger.exception(...)``) rather than left to
+    propagate to ``sys.excepthook``, which never sees them.
+
+    Usage::
+
+        logging.getLogger().addHandler(devalerts.LogHandler())
+
+    A record with ``exc_info`` (``logger.exception()``, or
+    ``logger.error(..., exc_info=True)``) is reported the same way an unhandled
+    instance of that exception would be -- same fingerprint, so logging it and then
+    re-raising sends one alert, not two. A plain ``logger.error("message")`` with no
+    exception is reported as a short text alert, grouped by logger name + level +
+    message.
+    """
+
+    def __init__(
+        self, level: int = logging.ERROR, *, extra: dict[str, str] | None = None
+    ) -> None:
+        super().__init__(level=level)
+        self._extra = extra
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            tags = {"logger": record.name, **(self._extra or {})}
+            if record.exc_info and record.exc_info[0] is not None:
+                exc_type, exc_value, tb = record.exc_info
+                _send_exception(exc_type, exc_value, tb, extra=tags)
+            else:
+                _send_log(record, extra=tags)
+        except Exception:  # noqa: BLE001 - a logging handler must never raise
+            self.handleError(record)

devalerts-0.4.0/src/devalerts/_alert.py

@@ -0,0 +1,152 @@
+"""Alert message formatting and secret redaction."""
+
+from __future__ import annotations
+
+import re
+import socket
+import traceback
+
+_MAX_MESSAGE_LENGTH = 4096
+
+
+def _escape_html(text: str) -> str:
+    """Escapes &, <, > -- required by both Telegram's HTML parse mode and Slack's
+    mrkdwn, which use the same three characters for their own markup."""
+    return text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+
+
+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,
+    blame: str | None = None,
+    is_new: bool = False,
+) -> str:
+    header = f"\U0001f534 {exc_type.__name__}: {exc_value}\n{_format_context(tags)}"
+    if is_new:
+        header = f"🆕 New error\n{header}"
+    if blame:
+        header += f"\n🕵️ blame: {blame}"
+    if skipped:
+        header += f"\n⚠️ Повторилась ещё {skipped} раз(а) с последнего алерта"
+    body = "".join(traceback.format_exception(exc_type, exc_value, tb))
+
+    if len(header) + 2 + len(body) > _MAX_MESSAGE_LENGTH:
+        marker = "\n\n...(truncated)...\n"
+        # ponytail: header itself can exceed the limit if exc_value's str() is huge
+        # (e.g. a validation error echoing a large payload) — keep can go negative,
+        # so clamp it; the header itself gets hard-truncated as a backstop. The "2"
+        # accounts for the "\n\n" separator joined in below.
+        keep = max(_MAX_MESSAGE_LENGTH - len(header) - 2 - len(marker), 0)
+        body = f"{marker}{body[-keep:]}" if keep else ""
+        header = header[:_MAX_MESSAGE_LENGTH]
+
+    # Budgeted above against the plain text -- Telegram's 4096-char limit
+    # applies to the parsed (tag-stripped) text, not the raw HTML we send.
+    escaped_header = _escape_html(header)
+    if not body:
+        return escaped_header
+    return (
+        f"{escaped_header}\n\n<blockquote expandable>{_escape_html(body)}</blockquote>"
+    )
+
+
+def _format_alert_slack(
+    exc_type,
+    exc_value,
+    tb,
+    skipped: int = 0,
+    tags: dict[str, str] | None = None,
+    blame: str | None = None,
+    is_new: bool = False,
+) -> str:
+    header = f"*\U0001f534 {exc_type.__name__}: {exc_value}*\n{_format_context(tags)}"
+    if is_new:
+        header = f"🆕 New error\n{header}"
+    if blame:
+        header += f"\n🕵️ blame: {blame}"
+    if skipped:
+        header += f"\n⚠️ Повторилась ещё {skipped} раз(а) с последнего алерта"
+    body = "".join(traceback.format_exception(exc_type, exc_value, tb))
+
+    fence = "```"
+    if len(header) + 2 + len(fence) * 2 + len(body) > _MAX_MESSAGE_LENGTH:
+        marker = "\n\n...(truncated)...\n"
+        keep = max(
+            _MAX_MESSAGE_LENGTH - len(header) - 2 - len(fence) * 2 - len(marker), 0
+        )
+        body = f"{marker}{body[-keep:]}" if keep else ""
+        header = header[:_MAX_MESSAGE_LENGTH]
+
+    escaped_header = _escape_html(header)
+    if not body:
+        return escaped_header
+    return f"{escaped_header}\n\n{fence}{_escape_html(body)}{fence}"
+
+
+def _format_log_alert_slack(
+    logger_name: str,
+    level_name: str,
+    message: str,
+    skipped: int = 0,
+    tags: dict[str, str] | None = None,
+    is_new: bool = False,
+) -> str:
+    header = (
+        f"*\U0001f534 {logger_name} ({level_name}): {message}*\n{_format_context(tags)}"
+    )
+    if is_new:
+        header = f"🆕 New error\n{header}"
+    if skipped:
+        header += f"\n⚠️ Повторилась ещё {skipped} раз(а) с последнего алерта"
+    return _escape_html(header[:_MAX_MESSAGE_LENGTH])
+
+
+def _format_log_alert(
+    logger_name: str,
+    level_name: str,
+    message: str,
+    skipped: int = 0,
+    tags: dict[str, str] | None = None,
+    is_new: bool = False,
+) -> str:
+    header = (
+        f"\U0001f534 {logger_name} ({level_name}): {message}\n{_format_context(tags)}"
+    )
+    if is_new:
+        header = f"🆕 New error\n{header}"
+    if skipped:
+        header += f"\n⚠️ Повторилась ещё {skipped} раз(а) с последнего алерта"
+    return _escape_html(header[:_MAX_MESSAGE_LENGTH])
+
+
+# ponytail: fixed pattern list, not exhaustive — catches common
+# token/key shapes only. Upgrade to entropy-based detection if
+# real users report leaked secrets slipping through.
+_REDACT_PATTERNS = [
+    (re.compile(r"AKIA[0-9A-Z]{16}"), "[REDACTED]"),
+    (re.compile(r"Bearer\s+[A-Za-z0-9\-_.]+", re.IGNORECASE), "Bearer [REDACTED]"),
+    (
+        re.compile(r"(?i)(api[_-]?key|secret|token|password)\s*[=:]\s*\S+"),
+        r"\1=[REDACTED]",
+    ),
+]
+
+
+def _redact(text: str) -> str:
+    for pattern, replacement in _REDACT_PATTERNS:
+        text = pattern.sub(replacement, text)
+    return text

devalerts-0.4.0/src/devalerts/_badge.py

@@ -0,0 +1,55 @@
+"""Crash-streak SVG badge rendering for `devalerts badge` -- no network call,
+no shields.io dependency, just a hand-rolled flat badge."""
+
+from __future__ import annotations
+
+from xml.sax.saxutils import escape
+
+_BAND_COLORS = {
+    "grey": "#9f9f9f",
+    "red": "#e05d44",
+    "yellow": "#dfb317",
+    "green": "#4c1",
+}
+
+
+def _streak_band(days: int | None) -> str:
+    if days is None:
+        return "grey"
+    if days < 1:
+        return "red"
+    if days < 7:
+        return "yellow"
+    return "green"
+
+
+def _streak_text(days: int | None) -> str:
+    if days is None:
+        return "no incidents yet"
+    if days < 1:
+        return "today"
+    return f"{days} day{'' if days == 1 else 's'}"
+
+
+def _render_badge(label: str, days: int | None) -> str:
+    """Flat shields.io-style badge. Character width is a fixed-per-glyph
+    approximation, not real font metrics -- fine for a README image, not
+    meant to be pixel-perfect."""
+    value = _streak_text(days)
+    color = _BAND_COLORS[_streak_band(days)]
+    label_width = 10 + 7 * len(label)
+    value_width = 10 + 7 * len(value)
+    width = label_width + value_width
+    height = 20
+    label_esc = escape(label)
+    value_esc = escape(value)
+    return (
+        f'<svg xmlns="http://www.w3.org/2000/svg" width="{width}" height="{height}">'
+        f'<rect width="{label_width}" height="{height}" fill="#555"/>'
+        f'<rect x="{label_width}" width="{value_width}" height="{height}" fill="{color}"/>'
+        f'<g fill="#fff" font-family="Verdana,Geneva,sans-serif" font-size="11">'
+        f'<text x="{label_width / 2}" y="14" text-anchor="middle">{label_esc}</text>'
+        f'<text x="{label_width + value_width / 2}" y="14" text-anchor="middle">'
+        f"{value_esc}</text>"
+        f"</g></svg>"
+    )

devalerts-0.4.0/src/devalerts/_blame.py

@@ -0,0 +1,82 @@
+"""Best-effort ``git blame`` lookup for the line that raised. Never raises --
+returns None on any failure (no git installed, not a repo, uncommitted line,
+timeout, ...)."""
+
+from __future__ import annotations
+
+import subprocess
+import time
+import traceback
+from pathlib import Path
+from types import TracebackType
+
+_TIMEOUT_SECONDS = 2
+
+
+def _relative_time(seconds_ago: float) -> str:
+    seconds_ago = max(seconds_ago, 0)
+    minutes = seconds_ago / 60
+    if minutes < 1:
+        return "just now"
+    if minutes < 60:
+        return f"{int(minutes)}m ago"
+    hours = minutes / 60
+    if hours < 24:
+        return f"{int(hours)}h ago"
+    days = hours / 24
+    if days < 30:
+        return f"{int(days)}d ago"
+    months = days / 30
+    if months < 12:
+        return f"{int(months)}mo ago"
+    return f"{int(months / 12)}y ago"
+
+
+def _git_blame(filename: str, lineno: int) -> str | None:
+    try:
+        result = subprocess.run(
+            [
+                "git",
+                "-C",
+                str(Path(filename).parent),
+                "blame",
+                "-L",
+                f"{lineno},{lineno}",
+                "--porcelain",
+                "--",
+                filename,
+            ],
+            capture_output=True,
+            text=True,
+            timeout=_TIMEOUT_SECONDS,
+        )
+        if result.returncode != 0 or not result.stdout:
+            return None
+        lines = result.stdout.splitlines()
+        sha = lines[0].split()[0]
+        author: str | None = None
+        author_time: int | None = None
+        for line in lines[1:]:
+            if line.startswith("author "):
+                author = line[len("author ") :]
+            elif line.startswith("author-time "):
+                author_time = int(line[len("author-time ") :])
+            elif line.startswith("\t"):
+                break
+        if not author or author_time is None or author == "Not Committed Yet":
+            return None
+        date = time.strftime("%Y-%m-%d", time.localtime(author_time))
+        age = _relative_time(time.time() - author_time)
+        return f"{author} · {sha[:7]} · {date} ({age})"
+    except Exception:  # noqa: BLE001 - best-effort, must never raise
+        return None
+
+
+def _git_blame_for_traceback(tb: TracebackType | None) -> str | None:
+    frames = traceback.extract_tb(tb)
+    if not frames:
+        return None
+    lineno = frames[-1].lineno
+    if lineno is None:
+        return None
+    return _git_blame(frames[-1].filename, lineno)

devalerts-0.4.0/src/devalerts/_slack.py

@@ -0,0 +1,42 @@
+"""Slack incoming-webhook delivery -- retries transient failures, logs to the
+same local fallback file Telegram delivery uses if every attempt fails. Never
+raises."""
+
+from __future__ import annotations
+
+import json
+import sys
+import time
+import urllib.error
+import urllib.request
+
+from ._telegram import _log_failed_delivery
+
+_TIMEOUT_SECONDS = 5
+_MAX_ATTEMPTS = 2
+_RETRY_BACKOFF_SECONDS = 1.0
+
+
+def _send_slack_message(webhook_url: str, text: str) -> bool:
+    payload = json.dumps({"text": text}).encode("utf-8")
+    last_error: Exception | None = None
+
+    for attempt in range(_MAX_ATTEMPTS):
+        request = urllib.request.Request(
+            webhook_url,
+            data=payload,
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        try:
+            urllib.request.urlopen(request, timeout=_TIMEOUT_SECONDS)
+            return True
+        except (urllib.error.URLError, OSError, ValueError) as error:
+            last_error = error
+
+        if attempt < _MAX_ATTEMPTS - 1:
+            time.sleep(_RETRY_BACKOFF_SECONDS)
+
+    print(f"devalerts: failed to send Slack alert: {last_error}", file=sys.stderr)
+    _log_failed_delivery(text)
+    return False

{devalerts-0.2.3 → devalerts-0.4.0}/src/devalerts/_store.py

@@ -24,6 +24,14 @@ def _fingerprint(exc_type, tb) -> tuple[str, str]:
     return hashlib.sha1(raw.encode("utf-8")).hexdigest()[:16], location
 
 
+def _fingerprint_log(
+    logger_name: str, level: int, msg: str, pathname: str, lineno: int
+) -> tuple[str, str]:
+    location = f"{pathname}:{lineno}"
+    raw = f"{logger_name}:{level}:{msg}:{location}"
+    return hashlib.sha1(raw.encode("utf-8")).hexdigest()[:16], location
+
+
 def _get_connection() -> sqlite3.Connection:
     _DB_PATH.parent.mkdir(parents=True, exist_ok=True)
     conn = sqlite3.connect(_DB_PATH, timeout=5)
@@ -62,7 +70,7 @@ def _get_connection() -> sqlite3.Connection:
 
 def _should_send(
     fingerprint: str, exc_type_name: str, location: str, rate_limit_seconds: int
-) -> tuple[bool, int]:
+) -> tuple[bool, int, bool]:
     now = time.time()
     try:
         conn = _get_connection()
@@ -73,6 +81,7 @@ def _should_send(
                     "FROM error_groups WHERE fingerprint = ?",
                     (fingerprint,),
                 ).fetchone()
+                is_new = row is None
                 muted = bool(row[2]) if row else False
                 multiplier = row[3] if row else 1
                 effective_window = rate_limit_seconds * multiplier
@@ -130,7 +139,7 @@ def _should_send(
                     "DELETE FROM error_groups WHERE last_seen < ?",
                     (now - _RETENTION_SECONDS,),
                 )
-            return send, skipped
+            return send, skipped, is_new
         finally:
             conn.close()
     except (sqlite3.Error, OSError) as error:
@@ -140,7 +149,19 @@ def _should_send(
             f"devalerts: dedup/rate-limit state error, sending anyway: {error}",
             file=sys.stderr,
         )
-        return True, 0
+        return True, 0, True
+
+
+def _last_incident() -> float | None:
+    """Unix timestamp of the most recent occurrence across all groups (sent or
+    suppressed -- last_seen is updated either way), or None if the state DB
+    has no groups recorded (fresh install, or everything cleared)."""
+    conn = _get_connection()
+    try:
+        row = conn.execute("SELECT MAX(last_seen) FROM error_groups").fetchone()
+    finally:
+        conn.close()
+    return row[0]
 
 
 def _match_fingerprints(prefix: str) -> list[str]:

{devalerts-0.2.3 → devalerts-0.4.0}/src/devalerts/cli.py

@@ -1,5 +1,7 @@
 """CLI: `devalerts dashboard` reports grouped/rate-limited errors from the local
-state DB; `devalerts test` sends a one-off message to verify bot_token/chat_id."""
+state DB; `devalerts test` sends a one-off message to verify bot_token/chat_id
+and/or slack_webhook_url; `devalerts badge` renders a 'days since last
+incident' SVG badge."""
 
 from __future__ import annotations
 
@@ -10,12 +12,16 @@ import sqlite3
 import sys
 import time
 from importlib.metadata import version as _pkg_version
+from pathlib import Path
 
+from ._badge import _render_badge, _streak_band
+from ._slack import _send_slack_message
 from ._store import (
     _DB_PATH,
     _DEFAULT_RATE_LIMIT_SECONDS,
     _clear,
     _clear_all,
+    _last_incident,
     _match_fingerprints,
     _set_muted,
 )
@@ -52,6 +58,23 @@ def _relative_time(ts: float, now: float) -> str:
     return f"{int(delta // 86400)}d ago"
 
 
+def _streak_line(last_incident: float, now: float, unicode_ok: bool) -> str:
+    days = int((now - last_incident) // 86400)
+    band = _streak_band(days)
+    icons = (
+        {"red": "🔴", "yellow": "🟡", "green": "🟢"}
+        if unicode_ok
+        else {"red": "[RESET]", "yellow": "[WARN]", "green": "[OK]"}
+    )
+    if band == "red":
+        return (
+            f"{icons['red']} New incident {_relative_time(last_incident, now)}"
+            " — streak reset to 0 days."
+        )
+    plural = "" if days == 1 else "s"
+    return f"{icons[band]} {days} day{plural} since the last incident."
+
+
 def _color_enabled() -> bool:
     if os.environ.get("NO_COLOR") is not None or not sys.stdout.isatty():
         return False
@@ -155,6 +178,9 @@ def _dashboard(as_json: bool = False) -> int:
     ellipsis = "…" if unicode_ok else "..."
     times_char = "×" if unicode_ok else "x"
 
+    print(_streak_line(rows[0][3], now, unicode_ok))
+    print()
+
     style = _Style(_color_enabled())
     type_width = max(len("TYPE"), *(len(r[1]) for r in rows))
 
@@ -253,16 +279,53 @@ def _clear_command(prefix: str | None, clear_all: bool) -> int:
     return 0
 
 
-def _test(bot_token: str, chat_id: str) -> int:
-    ok = _send_telegram_message(
-        bot_token,
-        chat_id,
-        "✅ devalerts test message -- bot_token and chat_id are wired up correctly.",
-    )
+def _badge_command(out: str | None, label: str) -> int:
+    incident = _last_incident()
+    days = int((time.time() - incident) // 86400) if incident is not None else None
+    svg = _render_badge(label, days)
+    if out:
+        Path(out).write_text(svg, encoding="utf-8")
+        print(f"Wrote badge to {out}.")
+    else:
+        print(svg)
+    return 0
+
+
+def _test(
+    bot_token: str | None, chat_id: str | None, slack_webhook_url: str | None
+) -> int:
+    if bool(bot_token) != bool(chat_id):
+        print("--bot-token and --chat-id must be given together.", file=sys.stderr)
+        return 1
+    if not bot_token and not slack_webhook_url:
+        print(
+            "Provide --bot-token/--chat-id and/or --slack-webhook-url.",
+            file=sys.stderr,
+        )
+        return 1
+    ok = True
+    if bot_token and chat_id:
+        ok = (
+            _send_telegram_message(
+                bot_token,
+                chat_id,
+                "✅ devalerts test message -- bot_token and chat_id are wired up "
+                "correctly.",
+            )
+            and ok
+        )
+    if slack_webhook_url:
+        ok = (
+            _send_slack_message(
+                slack_webhook_url,
+                "✅ devalerts test message -- slack_webhook_url is wired up correctly.",
+            )
+            and ok
+        )
     if not ok:
         print("Failed to send test message (see error above).", file=sys.stderr)
         return 1
-    print("Test message sent -- check your Telegram chat.")
+    print("Test message sent -- check your chat.")
     return 0
 
 
@@ -279,10 +342,12 @@ def main(argv: list[str] | None = None) -> int:
         "--json", action="store_true", help="Output as JSON instead of a table"
     )
     test_parser = subparsers.add_parser(
-        "test", help="Send a test message to verify bot_token/chat_id"
+        "test",
+        help="Send a test message to verify bot_token/chat_id and/or slack_webhook_url",
     )
-    test_parser.add_argument("--bot-token", required=True)
-    test_parser.add_argument("--chat-id", required=True)
+    test_parser.add_argument("--bot-token")
+    test_parser.add_argument("--chat-id")
+    test_parser.add_argument("--slack-webhook-url")
     mute_parser = subparsers.add_parser("mute", help="Silence a specific error group")
     mute_parser.add_argument(
         "fingerprint", help="Fingerprint or unique prefix (dashboard ID column)"
@@ -301,18 +366,31 @@ def main(argv: list[str] | None = None) -> int:
     clear_target.add_argument(
         "--all", action="store_true", help="Delete all error groups"
     )
+    badge_parser = subparsers.add_parser(
+        "badge", help="Print or write an SVG 'days since last incident' badge"
+    )
+    badge_parser.add_argument(
+        "--out", help="Write the SVG to this path instead of stdout"
+    )
+    badge_parser.add_argument(
+        "--label",
+        default="crash streak",
+        help="Badge label text (default: 'crash streak')",
+    )
     args = parser.parse_args(argv)
 
     if args.command == "dashboard":
         return _dashboard(as_json=args.json)
     if args.command == "test":
-        return _test(args.bot_token, args.chat_id)
+        return _test(args.bot_token, args.chat_id, args.slack_webhook_url)
     if args.command == "mute":
         return _mute_command(args.fingerprint, muted=True)
     if args.command == "unmute":
         return _mute_command(args.fingerprint, muted=False)
     if args.command == "clear":
         return _clear_command(args.fingerprint, args.all)
+    if args.command == "badge":
+        return _badge_command(args.out, args.label)
     return 1
 
 

devalerts-0.2.3/src/devalerts/_alert.py

@@ -1,71 +0,0 @@
-"""Alert message formatting and secret redaction."""
-
-from __future__ import annotations
-
-import re
-import socket
-import traceback
-
-_MAX_MESSAGE_LENGTH = 4096
-
-
-def _escape_html(text: str) -> str:
-    return text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
-
-
-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))
-
-    if len(header) + 2 + len(body) > _MAX_MESSAGE_LENGTH:
-        marker = "\n\n...(truncated)...\n"
-        # ponytail: header itself can exceed the limit if exc_value's str() is huge
-        # (e.g. a validation error echoing a large payload) — keep can go negative,
-        # so clamp it; the header itself gets hard-truncated as a backstop. The "2"
-        # accounts for the "\n\n" separator joined in below.
-        keep = max(_MAX_MESSAGE_LENGTH - len(header) - 2 - len(marker), 0)
-        body = f"{marker}{body[-keep:]}" if keep else ""
-        header = header[:_MAX_MESSAGE_LENGTH]
-
-    # Budgeted above against the plain text -- Telegram's 4096-char limit
-    # applies to the parsed (tag-stripped) text, not the raw HTML we send.
-    escaped_header = _escape_html(header)
-    if not body:
-        return escaped_header
-    return (
-        f"{escaped_header}\n\n<blockquote expandable>{_escape_html(body)}</blockquote>"
-    )
-
-
-# ponytail: fixed pattern list, not exhaustive — catches common
-# token/key shapes only. Upgrade to entropy-based detection if
-# real users report leaked secrets slipping through.
-_REDACT_PATTERNS = [
-    (re.compile(r"AKIA[0-9A-Z]{16}"), "[REDACTED]"),
-    (re.compile(r"Bearer\s+[A-Za-z0-9\-_.]+", re.IGNORECASE), "Bearer [REDACTED]"),
-    (
-        re.compile(r"(?i)(api[_-]?key|secret|token|password)\s*[=:]\s*\S+"),
-        r"\1=[REDACTED]",
-    ),
-]
-
-
-def _redact(text: str) -> str:
-    for pattern, replacement in _REDACT_PATTERNS:
-        text = pattern.sub(replacement, text)
-    return text