A standalone (Node.js) client for Rollbar

Rollbar notifier for Node.js

Node.js library for reporting exceptions and other messages to [Rollbar]( Requires a Rollbar account.
// include and initialize the rollbar library with your access token 
var rollbar = require("rollbar");
// record a generic message and send to rollbar 
rollbar.reportMessage("Hello world!");
// more is required to automatically detect and report errors. 
// keep reading for details. 
Be sure to replace ```POST_SERVER_ITEM_ACCESS_TOKEN``` with your project's ```post_server_item``` access token, which you can find in the interface.

Install using the node package manager, npm:

$ npm install --save rollbar
var express = require('express');
var rollbar = require('rollbar');
var app = express();
app.get('/', function(reqres) {
  // ... 
// Use the rollbar error handler to send exceptions to your rollbar account 

In your main application, require and initialize using your access_token::

var rollbar = require("rollbar");

Other options can be passed into the init() function using a second parameter. E.g.:

// Queue up and report messages/exceptions to rollbar every 5 seconds 
rollbar.init("POST_SERVER_ITEM_ACCESS_TOKEN", {handler: "setInterval", handlerInterval: 5});

When you are finished using rollbar, clean up any remaining items in the queue using the shutdown function:


Rollbar can be registered as a handler for any uncaught exceptions in your Node process:

var options = {
  // Call process.exit(1) when an uncaught exception occurs but after reporting all 
  // pending errors to Rollbar. 
  // Default: false 
  exitOnUncaughtException: true
rollbar.handleUncaughtExceptions("POST_SERVER_ITEM_ACCESS_TOKEN", options);

To report an exception that you have caught, use handleError or the full-powered handleErrorWithPayloadData:

var rollbar = require('rollbar');
try {
} catch (e) {
  // if you have a request object (or a function that returns one), pass it as the second arg 
  // see below for details about what the request object is expected to be 
  rollbar.handleError(e, request);
  // you can also pass a callback, which will be called upon success/failure 
  rollbar.handleError(e, function(err2) {
    if (err2) {
      // an error occurred 
    } else {
      // success 
  // if you have a request and a callback, pass the callback last 
  rollbar.handleError(e, request, callback);
  // to specify payload options - like extra data, or the level - use handleErrorWithPayloadData 
  rollbar.handleErrorWithPayloadData(e, {level: "warning", custom: {someKey: "arbitrary value"}});
  // can also take request and callback, like handleError: 
  rollbar.handleErrorWithPayloadData(e, {level: "info"}, request);
  rollbar.handleErrorWithPayloadData(e, {level: "info"}, callback);
  rollbar.handleErrorWithPayloadData(e, {level: "info"}, request, callback);

To report a string message, possibly along with additional context, use reportMessage or the full-powered reportMessageWithPayloadData.

var rollbar = require('rollbar');
// reports a string message at the default severity level ("error") 
rollbar.reportMessage("Timeout connecting to database");
// reports a string message at the level "info", along with a request and callback 
// only the first param is required 
// valid severity levels: "critical", "error", "warning", "info", "debug" 
rollbar.reportMessage("Response time exceeded threshold of 1s", "warning", request, callback);
// reports a string message along with additional data conforming to the Rollbar API Schema 
// documented here: 
// only the first two params are required 
rollbar.reportMessageWithPayloadData("Response time exceeded threshold of 1s", {
    level: "warning",
    custom: {
      threshold: 1,
      timeElapsed: 2.3
  }, request, callback);

If your Node.js application is responding to web requests, you can send data about the current request along with each report to Rollbar. This will allow you to replay requests, track events by browser, IP address, and much more.

handleError, reportMessage, handleErrorWithPayloadData, and reportMessageWithPayloadData all accept a request parameter as the second, third, third, and third arguments respectively. If it is a function, it will be called and the result used.

If you're using Express, just pass the express request object. If you're using something custom, pass an object with these keys (all optional):

  • headers: an object containing the request headers
  • protocol: the request protocol (e.g. "https")
  • url: the URL starting after the domain name (e.g. "/index.html?foo=bar")
  • method: the request method (e.g. "GET")
  • body: the request body as a string
  • route: an object containing a 'path' key, which will be used as the "context" for the event (e.g. {path: "home/index"})

Sensitive param names will be scrubbed from the request body and, if scrubHeaders is configured, headers. See the scrubFields and scrubHeaders configuration options for details.

If your application has authenticated users, you can track which user ("person" in Rollbar parlance) was associated with each event.

If you're using the Passport authentication library, this will happen automatically when you pass the request object (which will have "user" attached). Otherwise, attach one of these keys to the request object described in the previous section:

  • rollbar_person or user: an object like {id: "123", username: "foo", email: ""}. id is required, others are optional.
  • user_id: the user id as an integer or string, or a function which when called will return the user id

Note: in Rollbar, the id is used to uniquely identify a person; email and username are supplemental and will be overwritten whenever a new value is received for an existing id. The id is a string up to 40 characters long.

rollbar.init("access token", optionsObj) takes the following configuration options:

batchSize The max number of items sent to rollbar at a time.

Default: 10

branch The branch in your version control system for this code.

e.g. 'master'

codeVersion The version or revision of your code.

e.g. '868ff435d6a480929103452e5ebe8671c5c89f77'

endpoint The rollbar API base url.

Default: ''

environment The environment the code is running in, e.g. "production"

Default: 'unspecified'

handler The method that the notifier will use to report exceptions. Supported values:
  • setInterval -- all items that are queued up are sent to rollbar in batches in a setInterval callback
    • NOTE: using this mode will mean that items are queued internally before being sent. For applications that send a very large amount of items, it is possible to use up too much memory and crash the node process. If this starts to happen, try lowering the handlerInterval setting or switch to a different handler, e.g. 'nextTick'.
  • nextTick -- all items that are queued up are sent to rollbar in a process.nextTick callback
  • inline -- items are sent to rollbar as they are queued up, one at-a-time

Default: inline

handlerInterval If the handler is `setInterval`, this is the number of seconds between batch posts of items to rollbar.

Default: 3

host The hostname of the server the node.js process is running on.

Default: hostname returned from os.hostname()

root The path to your code, (not including any trailing slash) which will be used to link source files on Rollbar.

e.g. '/Users/bob/Development'

scrubFields List of field names to scrub out of the request body (POST params). Values will be replaced with asterisks. If overriding, make sure to list all fields you want to scrub, not just fields you want to add to the default. Param names are converted to lowercase before comparing against the scrub list.

Default: ['passwd', 'password', 'secret', 'confirm_password', 'password_confirmation']

scrubHeaders List of header names to scrub out of the request headers. Works like scrubFields.

Default: []

verbose Sets whether or not to log extra info/debug messages

Default: true

See the examples directory for more use cases.

The default configuration uses the inline handler which will cause errors to be reported to Rollbar at the time they occur. This works well for small applications but can quickly become a problem for high-throughput apps. For better performance, the setInterval handler is recommended since it queues up errors before sending them.

When using a handler besides inline, you should make sure to call rollbar.shutdown() in order to flush all errors before exiting.

If you have any questions, feedback, etc., drop us a line at

For bug reports, please open an issue on GitHub.

The project is hosted on GitHub. If you'd like to contribute a change:

  1. Fork it
  2. Create your feature branch (git checkout -b my-new-feature)
  3. Commit your changes (git commit -am 'Added some feature')
  4. Push to the branch (git push origin my-new-feature)
  5. Create a new Pull Request

We're using vows for testing. To run the tests, run: vows --spec test/*