devalerts 0.1.3__tar.gz → 0.1.4__tar.gz

devalerts-0.1.4/LICENSE

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

devalerts-0.1.4/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: devalerts
+Version: 0.1.4
+Summary: Send unhandled Python exceptions straight to a Telegram chat. No backend, no account, no database — just your own bot token.
+Keywords: telegram,error-tracking,exception-monitoring,alerts,logging,monitoring,asgi
+Author: sslinNn
+Author-email: sslinNn <morison1991@mail.ru>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Topic :: System :: Monitoring
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Project-URL: Homepage, https://github.com/sslinNn/devalerts
+Project-URL: Repository, https://github.com/sslinNn/devalerts
+Project-URL: Bug Tracker, https://github.com/sslinNn/devalerts/issues
+Description-Content-Type: text/markdown
+
+# devalerts
+
+[![PyPI](https://img.shields.io/pypi/v/devalerts)](https://pypi.org/project/devalerts/)
+[![Python versions](https://img.shields.io/pypi/pyversions/devalerts)](https://pypi.org/project/devalerts/)
+[![License: MIT](https://img.shields.io/pypi/l/devalerts)](LICENSE)
+
+[Русская версия](README.ru.md)
+
+Send unhandled Python exceptions straight to a Telegram chat — the moment
+they happen, on your phone. No backend, no account, no database — just your
+own bot token.
+
+```python
+import devalerts
+
+devalerts.init(bot_token="123456:ABC-DEF...", chat_id=123456789)
+```
+
+That's the whole setup. Two minutes with [@BotFather](https://t.me/BotFather)
+and every unhandled crash — including ones raised in threads — lands in your
+chat instead of a log file nobody's watching.
+
+## Why devalerts
+
+- **Zero infrastructure.** No SaaS signup, no ingestion server, no API key
+  to manage beyond your own Telegram bot token. State lives in a local
+  SQLite file you already own.
+- **One line to install, one line to wire up.** `init()` installs the hook
+  and gets out of the way.
+- **Not spam.** Errors are grouped by fingerprint and rate-limited per
+  group, so a crash loop sends one message, not a thousand.
+- **Framework-aware.** Ships an ASGI middleware for FastAPI/Starlette apps,
+  where the default excepthook would never even see a request error.
+- **Small and typed.** No dependencies, ships `py.typed`, ~450 lines total —
+  short enough to read in one sitting before you trust it with your errors.
+
+## Install
+
+    uv add devalerts
+
+(or `pip install devalerts` if you're not using uv)
+
+## Usage
+
+1. Create a bot with [@BotFather](https://t.me/BotFather) and get its token.
+2. Message your bot once (or add it to a group) so it's allowed to message you back.
+3. Get your chat id — message [@userinfobot](https://t.me/userinfobot), or call
+   `https://api.telegram.org/bot<TOKEN>/getUpdates` after step 2 and read `message.chat.id`.
+4. In your app, as early as possible:
+
+```python
+import devalerts
+
+devalerts.init(bot_token="123456:ABC-DEF...", chat_id=123456789)
+```
+
+That's it — any unhandled exception (including ones raised in threads) now
+also lands in your Telegram chat.
+
+## Grouping, rate limiting, and the dashboard
+
+Exceptions are grouped by fingerprint (exception type + file + line where it
+was raised) in a local SQLite file (`~/.devalerts/state.db`). Each group
+sends at most one Telegram message per `rate_limit_seconds` (default 300);
+repeats inside that window are counted but not sent, and the next message
+for that group says how many were skipped. Old groups (untouched for 7 days)
+are pruned automatically. Configure the window via `init()`:
+
+```python
+devalerts.init(bot_token="...", chat_id=123456789, rate_limit_seconds=60)
+```
+
+See what's grouped and what's currently rate-limited:
+
+```
+uv run devalerts dashboard
+```
+
+```
+  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.
+```
+
+## 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.
+
+## devalerts vs. a full error tracker
+
+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:
+
+|                          | 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 |
+
+## 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.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

devalerts-0.1.4/README.md

@@ -0,0 +1,152 @@
+# devalerts
+
+[![PyPI](https://img.shields.io/pypi/v/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)
+
+[Русская версия](README.ru.md)
+
+Send unhandled Python exceptions straight to a Telegram chat — the moment
+they happen, on your phone. No backend, no account, no database — just your
+own bot token.
+
+```python
+import devalerts
+
+devalerts.init(bot_token="123456:ABC-DEF...", chat_id=123456789)
+```
+
+That's the whole setup. Two minutes with [@BotFather](https://t.me/BotFather)
+and every unhandled crash — including ones raised in threads — lands in your
+chat instead of a log file nobody's watching.
+
+## Why devalerts
+
+- **Zero infrastructure.** No SaaS signup, no ingestion server, no API key
+  to manage beyond your own Telegram bot token. State lives in a local
+  SQLite file you already own.
+- **One line to install, one line to wire up.** `init()` installs the hook
+  and gets out of the way.
+- **Not spam.** Errors are grouped by fingerprint and rate-limited per
+  group, so a crash loop sends one message, not a thousand.
+- **Framework-aware.** Ships an ASGI middleware for FastAPI/Starlette apps,
+  where the default excepthook would never even see a request error.
+- **Small and typed.** No dependencies, ships `py.typed`, ~450 lines total —
+  short enough to read in one sitting before you trust it with your errors.
+
+## Install
+
+    uv add devalerts
+
+(or `pip install devalerts` if you're not using uv)
+
+## Usage
+
+1. Create a bot with [@BotFather](https://t.me/BotFather) and get its token.
+2. Message your bot once (or add it to a group) so it's allowed to message you back.
+3. Get your chat id — message [@userinfobot](https://t.me/userinfobot), or call
+   `https://api.telegram.org/bot<TOKEN>/getUpdates` after step 2 and read `message.chat.id`.
+4. In your app, as early as possible:
+
+```python
+import devalerts
+
+devalerts.init(bot_token="123456:ABC-DEF...", chat_id=123456789)
+```
+
+That's it — any unhandled exception (including ones raised in threads) now
+also lands in your Telegram chat.
+
+## Grouping, rate limiting, and the dashboard
+
+Exceptions are grouped by fingerprint (exception type + file + line where it
+was raised) in a local SQLite file (`~/.devalerts/state.db`). Each group
+sends at most one Telegram message per `rate_limit_seconds` (default 300);
+repeats inside that window are counted but not sent, and the next message
+for that group says how many were skipped. Old groups (untouched for 7 days)
+are pruned automatically. Configure the window via `init()`:
+
+```python
+devalerts.init(bot_token="...", chat_id=123456789, rate_limit_seconds=60)
+```
+
+See what's grouped and what's currently rate-limited:
+
+```
+uv run devalerts dashboard
+```
+
+```
+  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.
+```
+
+## 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.
+
+## devalerts vs. a full error tracker
+
+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:
+
+|                          | 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 |
+
+## 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.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

devalerts-0.1.4/pyproject.toml

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

devalerts-0.1.4/src/devalerts/__init__.py

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

devalerts-0.1.4/src/devalerts/_alert.py

@@ -0,0 +1,44 @@
+"""Alert message formatting and secret redaction."""
+
+from __future__ import annotations
+
+import re
+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}"
+    if skipped:
+        header += f"\n⚠️ Повторилась ещё {skipped} раз(а) с последнего алерта"
+    body = "".join(traceback.format_exception(exc_type, exc_value, tb))
+    message = f"{header}\n\n{body}"
+    if len(message) <= _MAX_MESSAGE_LENGTH:
+        return message
+    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 and hard-truncate the final result as a backstop guarantee.
+    keep = max(_MAX_MESSAGE_LENGTH - len(header) - len(marker), 0)
+    truncated = f"{header}{marker}{body[-keep:]}" if keep else header
+    return truncated[:_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.1.4/src/devalerts/_store.py

@@ -0,0 +1,90 @@
+"""Local SQLite state: fingerprint-based grouping, dedup, and rate limiting."""
+
+from __future__ import annotations
+
+import hashlib
+import sqlite3
+import sys
+import time
+import traceback
+from pathlib import Path
+
+_DB_PATH = Path.home() / ".devalerts" / "state.db"
+_RETENTION_SECONDS = 7 * 24 * 3600
+_DEFAULT_RATE_LIMIT_SECONDS = 300
+
+
+def _fingerprint(exc_type, tb) -> tuple[str, str]:
+    frames = traceback.extract_tb(tb)
+    location = f"{frames[-1].filename}:{frames[-1].lineno}" if frames else "unknown"
+    raw = f"{exc_type.__name__}:{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)
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS error_groups (
+            fingerprint TEXT PRIMARY KEY,
+            exc_type TEXT NOT NULL,
+            location TEXT NOT NULL,
+            first_seen REAL NOT NULL,
+            last_seen REAL NOT NULL,
+            last_sent REAL,
+            count_since_last_sent INTEGER NOT NULL DEFAULT 0,
+            total_count INTEGER NOT NULL DEFAULT 0
+        )
+        """
+    )
+    return conn
+
+
+def _should_send(fingerprint: str, exc_type_name: str, location: str, rate_limit_seconds: int) -> tuple[bool, int]:
+    now = time.time()
+    try:
+        conn = _get_connection()
+        try:
+            with conn:
+                row = conn.execute(
+                    "SELECT last_sent, count_since_last_sent FROM error_groups WHERE fingerprint = ?",
+                    (fingerprint,),
+                ).fetchone()
+                if row is None or row[0] is None or now - row[0] >= rate_limit_seconds:
+                    send, skipped = True, (row[1] if row else 0)
+                    conn.execute(
+                        """
+                        INSERT INTO error_groups
+                            (fingerprint, exc_type, location, first_seen, last_seen,
+                             last_sent, count_since_last_sent, total_count)
+                        VALUES (?, ?, ?, ?, ?, ?, 0, 1)
+                        ON CONFLICT(fingerprint) DO UPDATE SET
+                            last_seen = excluded.last_seen,
+                            last_sent = excluded.last_sent,
+                            count_since_last_sent = 0,
+                            total_count = total_count + 1
+                        """,
+                        (fingerprint, exc_type_name, location, now, now, now),
+                    )
+                else:
+                    send, skipped = False, 0
+                    conn.execute(
+                        """
+                        UPDATE error_groups
+                        SET last_seen = ?, count_since_last_sent = count_since_last_sent + 1,
+                            total_count = total_count + 1
+                        WHERE fingerprint = ?
+                        """,
+                        (now, fingerprint),
+                    )
+                conn.execute("DELETE FROM error_groups WHERE last_seen < ?", (now - _RETENTION_SECONDS,))
+            return send, skipped
+        finally:
+            conn.close()
+    except (sqlite3.Error, OSError) as error:
+        # ponytail: dedup/rate-limit state must never block an alert -- fail
+        # open (send, as if this were the first occurrence) on any DB error.
+        print(f"devalerts: dedup/rate-limit state error, sending anyway: {error}", file=sys.stderr)
+        return True, 0