Default Integrations

All of Sentry’s SDKs provide integrations, which extend functionality of the SDK.

System integrations are enabled by default to integrate into the standard library or the interpreter itself. They are documented so you can be both aware of what they do and disable them if they cause issues.

Enabled by Default

InboundFilters

Import name: Sentry.Integrations.InboundFilters

This integration allows you to ignore specific errors based on the type, message, or URLs in a given exception.

It ignores errors that start with Script error or Javascript error: Script error by default.

To configure this integration, use ignoreErrorsdenyUrls, and allowUrls SDK options directly. Keep in mind that denyURL and allowURL work only for captured exceptions, not raw message events.

FunctionToString

Import name: Sentry.Integrations.FunctionToString

This integration allows the SDK to provide original functions and method names, even when our error or breadcrumbs handlers wrap them.

TryCatch

Import name: Sentry.Integrations.TryCatch

This integration wraps native time and events APIs (setTimeoutsetIntervalrequestAnimationFrameaddEventListener/removeEventListener) in try/catch blocks to handle async exceptions.

Import name: Sentry.Integrations.Breadcrumbs

This integration wraps native APIs to capture breadcrumbs. By default, the Sentry SDK wraps all APIs.

Available options:

Copied
{
  // Log calls to `console.log`, `console.debug`, etc
  console: boolean;

  // Log all click and keypress events
  // - When an object with `serializeAttribute` key is provided,
  //   Breadcrumbs integration will look for given attribute(s) in DOM elements,
  //   while generating the breadcrumb trails.
  //   Matched elements will be followed by their custom attributes,
  //   instead of their `id`s or `class` names.
  dom: boolean | { serializeAttribute: string | string[] };

  // Log HTTP requests done with the Fetch API
  fetch: boolean;

  // Log calls to `history.pushState` and friends
  history: boolean;

  // Log whenever we send an event to the server
  sentry: boolean;

  // Log HTTP requests done with the XHR API
  xhr: boolean;
}

GlobalHandlers

Import name: Sentry.Integrations.GlobalHandlers

This integration attaches global handlers to capture uncaught exceptions and unhandled rejections.

Available options:

Copied
{
  onerror: boolean;
  onunhandledrejection: boolean;
}

LinkedErrors

Import name: Sentry.Integrations.LinkedErrors

This integration allows you to configure linked errors. They’ll be recursively read up to a specified limit and lookup will be performed by a specific key. By default, the Sentry SDK sets the limit to five and the key used is cause.

Available options:

Copied
{
  key: string;
  limit: number;
}

Here is a code example of how this could be implemented:

Copied
document
  .querySelector("#get-reviews-btn")
  .addEventListener("click", async event => {
    const movie = event.target.dataset.title;
    try {
      const reviews = await fetchMovieReviews(movie);
      renderMovieReviews(reviews);
    } catch (e) {
      const fetchError = new Error(`Failed to fetch reviews for: ${movie}`);
      fetchError.cause = e;
      Sentry.captureException(fetchError);
      renderMovieReviewsError(fetchError);
    }
  });

UserAgent

Import name: Sentry.Integrations.UserAgent

This integration attaches user-agent information to the event, which allows us to correctly catalog and tag them with specific OS, browser, and version information.

Dedupe

Import name: Sentry.Integrations.Dedupe

This integration deduplicates certain events. It can be helpful if you are receiving many duplicate errors. Note that Sentry will only compare stack traces and fingerprints. This integration is enabled by default for Browser.

Copied
import * as Sentry from "@sentry/browser";
import { Dedupe as DedupeIntegration } from "@sentry/integrations";

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  integrations: [new DedupeIntegration()],
});

Modifying System Integrations

To disable system integrations set defaultIntegrations: false when calling init().

To override their settings, provide a new instance with your config to integrations option. For example, to turn off browser capturing console calls: integrations: [new Sentry.Integrations.Breadcrumbs({ console: false })].

Removing an Integration

This example removes the default-enabled integration for adding breadcrumbs to the event:

Copied
Sentry.init({
  // ...

  integrations: function(integrations) {
    // integrations will be all default integrations
    return integrations.filter(function(integration) {
      return integration.name !== "Breadcrumbs";
    });
  },
});
Help improve this content
Our documentation is open source and available on GitHub. Your contributions are welcome, whether fixing a typo (drat!) to suggesting an update ("yeah, this would be better").