Node.js error monitoring: alerts in Telegram, Discord and Pushover

One npm package for servers, workers and command-line tools on Node.js 18 and later: uncaught errors, Express, winston and pino, with TypeScript types. Every new error lands in the chat you already read: the first occurrence at once, with its stack, 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 npm and create the client once with the key from an environment variable. It reports uncaught exceptions and unhandled rejections by itself; add the Express error handler after your routes, or a transport to winston or pino, and report anything you catch yourself with one call.

Terminal

npm install bugsradar

bugsradar.js

import { BugsRadar } from 'bugsradar';
import { expressErrorHandler } from 'bugsradar/express';

export const bugsRadar = new BugsRadar({
  apiKey: process.env.BUGSRADAR_KEY,
  environment: process.env.NODE_ENV,
});
// Uncaught exceptions and unhandled rejections are reported by the client itself

app.use(expressErrorHandler(bugsRadar)); // after your routes

// Anything you catch yourself
bugsRadar.sendException(error, { module: 'Orders' });

Reports leave through a background queue: 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 Error object seen twice - by Express and by winston, say - is sent once.
When the server asks to slow down, the client waits; network failures are retried.
ESM and CommonJS, TypeScript types, Node.js 18 and later.

Integration docs →

Your framework, your logger

Each integration has its own page in the docs.

Uncaught errors

Uncaught exceptions and unhandled rejections are reported by the client itself; the process then exits with code 1, as it would without BugsRadar. Uncaught errors →

Express

An error handler that reports every unhandled error of a request with its method and path, then passes it on to your own handler. Express docs →

winston

A transport next to the ones you already have: entries at error and above, with the Error object as the exception. winston docs →

pino

A transport that runs in pino's worker thread: error and fatal entries, with the error in err as the exception. pino docs →

Direct calls

sendException for anything you catch yourself, or the full event with a message template and properties. Direct calls →

Jobs and command-line tools

flush() waits for the queued reports before a short-lived process exits. Before the process exits →

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 the browser. The API key is secret, so the package is for Node.js on your servers: not for React, Angular, Vue or Next.js client components, and not for an Electron app you ship to others.

Questions developers ask

Which Node.js versions are supported?

Node.js 18 and later, ESM and CommonJS, with TypeScript types in the package.

Does it slow down my requests?

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

Does it catch unhandled promise rejections?

Yes. In Node.js 15 and later an unhandled rejection becomes an uncaught exception, so it is reported the same way. BugsRadar waits up to shutdownTimeout for the report to leave, then the process exits with code 1, as it would without BugsRadar.

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 Node.js alert in a few minutes

Start free Integration docs

Next: BugsRadar for Python →