Angular integration guide

Add Bugsnag to your Angular projects to automatically capture and report errors in production.

New to Bugsnag? Create an account

Installation

npm

Install Bugsnag and the Bugsnag / Angular integration from the npm registry using npm or yarn:

npm install --save @bugsnag/js @bugsnag/plugin-angular
# or
yarn add @bugsnag/js @bugsnag/plugin-angular

Basic configuration

This documentation is for version 7 of the Bugsnag JavaScript notifier. If you are using older versions, we recommend upgrading to the latest release using our Upgrade guide. Documentation for the previous release can be found on our legacy pages.

Import Bugsnag:

import Bugsnag from '@bugsnag/js'
import { BugsnagErrorHandler } from '@bugsnag/plugin-angular'

The simplest way to configure Bugsnag is to provide your API key as a string:

Bugsnag.start('YOUR_API_KEY')

You can find your API key in Project Settings.

To specify any additional configuration options, supply an object instead:

Bugsnag.start({
  apiKey: 'YOUR_API_KEY',
  otherOptions: value
})

For information on values that can be set in the configuration object, see configuration options.

Integrate the Angular error handler in the entry point of your application (typically app.module.ts):

import { NgModule, ErrorHandler } from '@angular/core'
// ... other imports omitted for brevity

// create a factory which will return the Bugsnag error handler
export function errorHandlerFactory() {
  return new BugsnagErrorHandler()
}

@NgModule({
  /* Pass the BugsnagErrorHandler class along to the providers for your module */
  providers: [ { provide: ErrorHandler, useFactory: errorHandlerFactory } ]
  /* other properties passed to the decorator omitted for brevity */
})

In the dashboard, you’ll see errors reported with extra debugging info in an “Angular” tab. For example:

Angular error information in the dashboard

Reporting unhandled errors

After completing installation and basic configuration, unhandled exceptions and unhandled promise rejections will be reported and automatically appear on your Bugsnag dashboard.

Reporting handled errors

Sometimes it is useful to manually notify Bugsnag of a problem. To do this, call Bugsnag.notify(). For example:

try {
  something.risky()
} catch (e) {
  Bugsnag.notify(e)
}

Sending diagnostic data

Automatically captured diagnostics

Bugsnag will automatically capture the following data for every exception:

  • The current URL
  • Script content (if the error originated in an inline <script/> tag)
  • Browser name, version, user agent, locale and time
  • Operating system
  • Release stage (production, beta, staging, etc)

Attaching custom diagnostics

It can often be helpful to attach application-specific diagnostic data to error reports. This can be accomplished by setting a callback which will be invoked before any reports are sent to Bugsnag.

The following adds a map of data to the “company” tab on the Bugsnag dashboard for all captured events:

Bugsnag.start({
  onError: function (event) {
    event.addMetadata('company', {
      name: "Acme Co.",
      country: "uk"
    })
  }
})

For more information, see Customizing error reports.

Identifying users

In order to correlate errors with customer reports, or to see a list of users who experienced each error, it is helpful to capture and display user information on your Bugsnag dashboard.

You can set the user information of an error report using the user configuration property when Bugsnag starts or via an onError callback.

Bugsnag.start({
  onError: function (event) {
    event.setUser('3', 'bugs.nag@bugsnag.com', 'Bugs Nag')
  }
})

For information on doing so, see Adding user data.

Logging breadcrumbs

In order to understand what happened in your application before each crash, it can be helpful to leave short log statements that we call breadcrumbs. A configurable number of breadcrumbs are attached to each error report to help diagnose what events led to the error.

Automatically captured breadcrumbs

By default, Bugsnag captures the following events as breadcrumbs.

  • Clicks
  • Errors
  • Console logs, warnings, and errors
  • Page load, hide, and show
  • DOMContentLoaded events
  • Pop state
  • History push state and replace state
  • Hash change
  • HTTP requests

For more information or to disable particular classes of automatic breadcrumb generation see configuration options.

Attaching custom breadcrumbs

You can use the leaveBreadcrumb method to log potentially useful events in your own applications:

Bugsnag.leaveBreadcrumb('Button clicked')

Bugsnag will keep track of the time and order of the breadcrumbs and show them on your dashboard. Additional data can also be attached to breadcrumbs by providing the optional metadata parameter.

For more information and examples for how custom breadcrumbs can be integrated, see Customizing breadcrumbs.

Session tracking

Bugsnag tracks the number of “sessions” that happen within your application. This allows you to compare stability scores between releases and helps you to understand the quality of your releases.

Sessions are captured and reported by default. This behavior can be disabled using the autoTrackSessions configuration option.

In the browser, Bugsnag will automatically report a session each time:

  • The page loads
  • The URL changes via history.pushState() or history.replaceState()

For more information about manually controlling session tracking, see Capturing sessions.

Tracking releases

Configure your app version to see the release that each error was introduced in.

Bugsnag.start({ appVersion: '4.10.0' })

Then set up a build tool integration to enable linking to code in your source control provider from the releases dashboard, timeline annotations, and stack traces.

Legacy Angular support

The @bugsnag/plugin-angular package is only for Angular 2+ projects. To integrate Bugsnag with an Angular v1.x application, use the following snippet:

angular
  .module('exceptionOverride', [])
  .factory('$exceptionHandler', function () {
    return function (exception, cause) {
      Bugsnag.notify(exception, {
        onError: function (event) {
          event.addMetadata('angular', { cause: cause })
        }
      })
    }
  })

Next steps

  • View @bugsnag/js, the library powering Bugsnag for JavaScript, on GitHub
  • Get support for your questions and feature requests