devalerts 0.2.2__tar.gz → 0.3.0__tar.gz

{devalerts-0.2.2 → devalerts-0.3.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: devalerts
-Version: 0.2.2
-Summary: Send unhandled Python exceptions straight to a Telegram chat. No backend, no account, no database — just your own bot token.
+Version: 0.3.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
@@ -51,6 +51,8 @@ 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.
 
+![devalerts demo](https://raw.githubusercontent.com/sslinNn/devalerts/main/docs/demo.gif)
+
 ## Why devalerts
 
 - **Zero infrastructure.** No SaaS signup, no ingestion server, no API key
@@ -230,6 +232,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
@@ -263,22 +319,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.
 
@@ -291,7 +352,6 @@ paths.
 ## Roadmap
 
 - Web dashboard (hosted, optional — the local CLI dashboard stays either way)
-- Slack delivery
 - Discord delivery
 - Email delivery
 

{devalerts-0.2.2 → devalerts-0.3.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
@@ -24,6 +24,8 @@ 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.
 
+![devalerts demo](https://raw.githubusercontent.com/sslinNn/devalerts/main/docs/demo.gif)
+
 ## Why devalerts
 
 - **Zero infrastructure.** No SaaS signup, no ingestion server, no API key
@@ -203,6 +205,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
@@ -236,22 +292,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.
 
@@ -264,7 +325,6 @@ paths.
 ## Roadmap
 
 - Web dashboard (hosted, optional — the local CLI dashboard stays either way)
-- Slack delivery
 - Discord delivery
 - Email delivery
 

{devalerts-0.2.2 → devalerts-0.3.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "devalerts"
-version = "0.2.2"
-description = "Send unhandled Python exceptions straight to a Telegram chat. No backend, no account, no database — just your own bot token."
+version = "0.3.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.2 → devalerts-0.3.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.3.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.3.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.3.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.2 → devalerts-0.3.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,7 @@ def _should_send(
             f"devalerts: dedup/rate-limit state error, sending anyway: {error}",
             file=sys.stderr,
         )
-        return True, 0
+        return True, 0, True
 
 
 def _match_fingerprints(prefix: str) -> list[str]:

{devalerts-0.2.2 → devalerts-0.3.0}/src/devalerts/cli.py

@@ -1,5 +1,6 @@
 """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."""
 
 from __future__ import annotations
 
@@ -11,6 +12,7 @@ import sys
 import time
 from importlib.metadata import version as _pkg_version
 
+from ._slack import _send_slack_message
 from ._store import (
     _DB_PATH,
     _DEFAULT_RATE_LIMIT_SECONDS,
@@ -27,7 +29,7 @@ _LOCATION_WIDTH = 34
 def _supports_unicode() -> bool:
     encoding = getattr(sys.stdout, "encoding", None) or ""
     try:
-        "─●…".encode(encoding)
+        "─●…×".encode(encoding)
         return True
     except (LookupError, UnicodeEncodeError, TypeError):
         return False
@@ -153,6 +155,7 @@ def _dashboard(as_json: bool = False) -> int:
     sep_char = "─" if unicode_ok else "-"
     dot_char = "●" if unicode_ok else "*"
     ellipsis = "…" if unicode_ok else "..."
+    times_char = "×" if unicode_ok else "x"
 
     style = _Style(_color_enabled())
     type_width = max(len("TYPE"), *(len(r[1]) for r in rows))
@@ -178,7 +181,9 @@ def _dashboard(as_json: bool = False) -> int:
         muted,
         backoff_multiplier,
     ) in rows:
-        backoff_suffix = f" ×{backoff_multiplier}" if backoff_multiplier > 1 else ""
+        backoff_suffix = (
+            f" {times_char}{backoff_multiplier}" if backoff_multiplier > 1 else ""
+        )
         if muted:
             muted_count += 1
             status = style.dim(f"{dot_char} muted")
@@ -250,16 +255,41 @@ 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 _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
 
 
@@ -276,10 +306,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)"
@@ -303,7 +335,7 @@ def main(argv: list[str] | None = None) -> int:
     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":

devalerts-0.2.2/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