Python error monitoring: alerts in Telegram, Discord and Pushover

One package from PyPI for Python 3.9 and later, with no dependencies: the standard logging module, loguru, uncaught exceptions, Django, Flask and FastAPI. Every new error lands in the chat you already read: the first occurrence at once, with its traceback, and repeats as a live count in that same message.

Start free Integration docs

Free plan · no event quotas · your events are never stored

Add it in a few minutes

Install bugsradar from PyPI and call init once, at the start of the program. It connects BugsRadar to logging and to uncaught exceptions and adds no handlers, so your logging setup works as before: records at ERROR and above go to your channels from every logger, and so does every exception that ends the program or a thread.

Terminal

pip install bugsradar

main.py

import os
import bugsradar

bugsradar.init(
    api_key=os.environ["BUGSRADAR_KEY"],
    environment="Production",
)

# From here on: logging at ERROR and above, uncaught exceptions and
# the unhandled errors of Django, Flask and FastAPI go to your channels
logger.exception("Order %s failed", order_id)

# Anything you catch yourself
bugsradar.send_exception(error, module="Orders")

Reports leave through a background thread: your code never waits for the network.
Repeats of the same error travel as one request with a count, so a crash loop costs a request every few seconds, not thousands per second.
The same exception object seen twice - logged and reported by hand - is sent once.
When the server asks to slow down, the client waits; network failures are retried.
Python 3.9 and later, no dependencies outside the standard library.

Integration docs →

Your logger, your framework

Each integration has its own page in the docs.

logging

Records at ERROR and above from every logger, with the format string as the message template, so failures of different orders are one error with a count. logging docs →

loguru

One sink added after your own loguru setup: the exception, its traceback and the values bound with logger.bind. loguru docs →

Django

Every unhandled exception of a view, logged by django.request. One init call in settings.py; your LOGGING setting stays as it is. Django docs →

Flask

Unhandled exceptions that Flask logs through app.logger. One init call next to Flask(__name__). Flask docs →

FastAPI

Unhandled exceptions logged by Uvicorn; an exception handler adds the path of the request, and the error still arrives once. FastAPI docs →

Uncaught exceptions

sys.excepthook and threading.excepthook: the exception that ends the program or a thread is reported, and the traceback is still printed. Uncaught exceptions →

Where the alerts go

Alerts go through your own Telegram bot, Discord webhook or Pushover application: you decide who reads the chat.

Telegram - a private chat, a group or a channel, through the bot you create with @BotFather; repeats are counted in the first message, without a new notification.
Discord - any text channel of your server, through a webhook; no bot to install, and the count of repeats is written into the first message too.
Pushover - push notifications on your phone or desktop, for one person or a whole delivery group; repeats arrive as short summaries.

Coming with Business: Slack, Microsoft Teams, Google Chat and PagerDuty.

An alert, not an archive

BugsRadar does one thing: it brings every new error to your chat. It is honest about what it leaves to other tools.

No history. Events are never stored, so there is no archive of past errors to search. Keep your logs for that.
No dashboard. There is no page that lists your errors; the chat is the interface. If you need to browse and search past errors, you need an error tracker next to BugsRadar - many teams run both.
Not for apps you ship to users. The API key is secret, so it belongs only in code that runs on your servers: not in a PyInstaller, PySide or PyQt build you give to others.

Questions developers ask

Which Python versions are supported?

Python 3.9 and later. The package has no dependencies outside the standard library; loguru is optional.

Does init change my logging setup?

No. init adds no handlers; records at ERROR and above reach BugsRadar from every logger whatever handlers you have. To leave logging alone, pass logging_level=None and add bugsradar.LoggingHandler() to the loggers you choose.

Does it slow down my code?

No. send and send_exception queue the event and return at once; reports leave through a background thread. Only flush() waits, for a script that is about to exit.

What happens when my app throws thousands of errors a minute?

The package folds repeats into one request with a count, and BugsRadar groups them on its side: you get the first occurrence at once, and that message keeps the count of the repeats. If errors come faster than your channel accepts, they are bundled into one message with a line per error.

Does BugsRadar store my errors?

No. An event stays in memory only until it is delivered to your channels; nothing is written to a database. BugsRadar keeps only what it needs to run: your email, your projects and the encrypted settings of your channels.

Pricing

Plans differ by features, not by volume: no event quotas and no per-seat fees on any plan. Free is 2 projects and 3 channels, Telegram, Discord and Pushover, every package and the HTTP endpoint, duplicate filtering and a live count of repeats. Pro, $5 per month or $50 per year, adds unlimited projects and channels and rules that route errors by level, module and environment. Compare the plans →

Your first Python alert in a few minutes

Start free Integration docs

Next: BugsRadar for Scripts →