Pluggable Integrations
Pluggable integrations are integrations that can be additionally enabled to provide specific features. They're documented so you can understand what they do and enable them, if needed.
To enable pluggable integrations, install the package @sentry/integrations
.
npm install --save @sentry/integrations
After installation, you can import the integration and provide a new instance with your config to the integrations
option.
import { captureConsoleIntegration } from "@sentry/integrations";
Sentry.init({
dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
integrations: [captureConsoleIntegration()],
});
Import name: captureConsoleIntegration
This integration captures all Console API
calls and redirects them to Sentry using captureMessage
call. It then re-triggers to preserve default native behavior.
Available options:
{
levels: string[]; // an array of methods that should be captured, defaults to ['log', 'info', 'warn', 'error', 'debug', 'assert']
}
Import name: dedupeIntegration
This integration deduplicates certain events. It can be helpful if you're receiving many duplicate errors. Be aware that we will only compare stack traces and fingerprints.
Import name: debugIntegration
This integration allows you to inspect the contents of the processed event and hint
object that will be passed to beforeSend
or beforeSendTransaction
. It will always run as the last integration, no matter when it was registered.
Note that this is different than setting debug: true
in your Sentry.init
options, which will enable debug logging in the console.
Available options:
{
debugger: boolean; // trigger DevTools debugger instead of using console.log
// stringify event before passing it to console.log
stringify: boolean;
}
Import name: extraErrorDataIntegration
This integration extracts all non-native attributes from the error
object and attaches them to the event as the extra
data.
Available options:
{
// limit of how deep the object serializer should go. Anything deeper than limit will
// be replaced with standard Node.js REPL notation of [Object], [Array], [Function] or
// a primitive value. Defaults to 3.
depth: number;
}
Import name: rewriteFramesIntegration
This integration allows you to apply a transformation to each frame of the stack trace. In the streamlined scenario, it can be used to change the name of the file frame it originates from, or it can be fed with an iterated function to apply any arbitrary transformation.
On Windows machines, you have to use Unix paths and skip the volume letter in the root
option to make it work. For example, C:\\Program Files\\Apache\\www
won't work, however, /Program Files/Apache/www
will.
import * as Sentry from "@sentry/node";
import { rewriteFramesIntegration } from "@sentry/integrations";
Sentry.init({
dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
integrations: [rewriteFramesIntegration(
{
// root path that will be stripped from the current frame's filename by the default iteratee if the filename is an absolute path
root: string;
// a custom prefix that will be used by the default iteratee (default: `app://`)
prefix: string;
// function that takes the frame, applies a transformation, and returns it
iteratee: (frame) => frame;
}
)],
});
For example, if the full path to your file is /www/src/app/file.js
:
Usage | Path in Stack Trace | Description |
---|---|---|
RewriteFrames() | app:///file.js | The default behavior is to replace the absolute path, except the filename, and prefix it with the default prefix (app:/// ). |
RewriteFrames({prefix: 'foo/'}) | foo/file.js | Prefix foo/ is used instead of the default prefix app:/// . |
RewriteFrames({root: '/www'}) | app:///src/app/file.js | root is defined as /www , so only that part is trimmed from beginning of the path. |
(New in version 7.48.0)
The Sentry tRPC middleware helps make sure your transactions related to RPCs are well-named. Additionally, it can attach RPC input via the attachRpcInput
option.
import { initTRPC } from "@trpc/server";
import * as Sentry from "@sentry/node";
const t = initTRPC.context().create();
const sentryMiddleware = t.middleware(
Sentry.Handlers.trpcMiddleware({
attachRpcInput: true,
})
);
const sentrifiedProcedure = t.procedure.use(sentryMiddleware);
Our documentation is open source and available on GitHub. Your contributions are welcome, whether fixing a typo (drat!) or suggesting an update ("yeah, this would be better").
- Package:
- npm:@sentry/node
- Version:
- 7.110.0
- Repository:
- https://github.com/getsentry/sentry-javascript