Sentry Node.js

https://docs.sentry.io/platforms/javascript/guides/node
Admin
Sentry for Node.js is an error monitoring and performance tracking platform that captures...
Tokens:86,995
Snippets:777
Trust Score:10
Update:1 week ago
Show doc for...
Tokens:
Raw
### Sentry.init with example DSN and tracesSampleRate

Source: https://docs.sentry.io/platforms/javascript/guides/node/tracing/trace-propagation

Initializes the Sentry Node SDK with a placeholder DSN and enables tracing by setting tracesSampleRate to 1. Use this when you want to start with a sample DSN before replacing it with your own.

```JavaScript
Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  tracesSampleRate: 1,
});

```

--------------------------------

### startInactiveSpan usage example (JavaScript)

Source: https://docs.sentry.io/platforms/javascript/guides/node/apis

JavaScript example showing how to use Sentry.startInactiveSpan. The returned span must be ended manually with span.end().

```javascript
const span = Sentry.startInactiveSpan({ name: "my-span" });
doSomething();
span.end();
```

--------------------------------

### startSession

Source: https://docs.sentry.io/platforms/javascript/guides/node/enriching-events/identify-user

Starts a new session for tracking release health.

```APIDOC
## Function: startSession

### Description
Starts a new session.

### Method
function

### Signature
`function startSession(): Session`

### Parameters
None

### Returns
- **Session** - The newly started session.
```

--------------------------------

### startSpan usage examples (JavaScript)

Source: https://docs.sentry.io/platforms/javascript/guides/node/apis

JavaScript examples showing synchronous and asynchronous usage of Sentry.startSpan. The span is automatically ended when the callback returns.

```javascript
// Synchronous example
Sentry.startSpan({ name: "my-span" }, (span) => {
  measureThis();
});

// Asynchronous example
const status = await Sentry.startSpan(
  { name: "my-span" },
  async (span) => {
    const status = await doSomething();
    return status;
  },
);
```

--------------------------------

### startNewTrace

Source: https://docs.sentry.io/platforms/javascript/guides/node/configuration/apis

Starts a new trace that is active in the provided callback.

```APIDOC
## startNewTrace

### Description
Start a new trace that is active in the provided callback.

### Method
function

### Signature
`function startNewTrace<T>(callback: () => T): T`

### Parameters

#### callback

`() => T` - The callback to start a new trace for.

### Response
Returns the value returned by the callback.

```

--------------------------------

### startNewTrace

Source: https://docs.sentry.io/platforms/javascript/guides/node/enriching-events/identify-user

Starts a new trace that is active in the provided callback.

```APIDOC
## startNewTrace

### Description
Start a new trace that is active in the provided callback.

### Method
Function

### Signature
`function startNewTrace<T>(callback: () => T): T`

### Parameters

#### callback (() => T) - Required
- The callback in which the new trace is active.

### Response
Returns the return value of the callback.

```

--------------------------------

### Start a new trace with Sentry.startNewTrace

Source: https://docs.sentry.io/platforms/javascript/guides/node/tracing/trace-propagation/custom-instrumentation

Use Sentry.startNewTrace to start a new trace that is not connected to the current distributed trace. The trace remains valid for the duration of the callback, and after the callback ends, the SDK resumes the previous trace if available.

```JavaScript
myButton.addEventListener("click", async () => {

  Sentry.startNewTrace(() => {
    Sentry.startSpan(
      { op: "ui.interaction.click", name: "fetch click" },
      async () => {
        await fetch("http://example.com");
      },
    );
  });

});
```

--------------------------------

### startSpanManual usage example

Source: https://docs.sentry.io/platforms/javascript/guides/node/apis

Example of using Sentry.startSpanManual to create a span that must be ended manually. The callback receives the span and returns a value.

```javascript
const status = await Sentry.startSpanManual(
  { name: "my-span" },
  async (span) => {
    const status = await doSomething();
    span.end();
    return status;
  },
);
```

--------------------------------

### Start a synchronous span with Sentry.startSpan()

Source: https://docs.sentry.io/platforms/javascript/guides/node/tracing/instrumentation/custom-instrumentation

Starts a synchronous span with Sentry.startSpan(). The span is automatically ended when the callback completes. Only the name option is required.

```javascript
const result = Sentry.startSpan({ name: "Important Function" }, () => {
  return expensiveFunction();
});
```

--------------------------------

### Import Sentry and use setTag

Source: https://docs.sentry.io/platforms/javascript/guides/node/apis

Shows how to import the Sentry SDK and call the setTag API to add a tag to events. The example uses the @sentry/browser package.

```JavaScript
import * as Sentry from "@sentry/browser";

Sentry.setTag("tag", "value");

```

--------------------------------

### Sentry.setTag

Source: https://docs.sentry.io/platforms/javascript/guides/node/enriching-events/identify-user

Example usage of the setTag API from the Sentry SDK.

```APIDOC
## [SDK] Sentry.setTag

### Description
Sets a tag on the current scope. Tags are key-value pairs that are used to filter and group events in Sentry.

### Method
setTag

### Parameters
- **tag** (string) - Required - The tag key.
- **value** (string) - Required - The tag value.

### Request Example
```javascript
import * as Sentry from "@sentry/browser";
Sentry.setTag("tag", "value");
```

### Response
No return value.
```

--------------------------------

### setCurrentClient(client: Client): void

Source: https://docs.sentry.io/platforms/javascript/guides/node/enriching-events/identify-user

Makes the given client the current client. Not needed if using `init()`, only for manual client setup.

```typescript
function setCurrentClient(client: Client): void

```

--------------------------------

### startNewTrace signature

Source: https://docs.sentry.io/platforms/javascript/guides/node/apis

Signature for Sentry.startNewTrace. Starts a new trace that is active in the provided callback.

```typescript
function startNewTrace<T>(callback: () => T): T
```

--------------------------------

### init

Source: https://docs.sentry.io/platforms/javascript/guides/node/configuration/apis

Initializes the Sentry SDK with the provided options.

```APIDOC
## init(options: InitOptions): Client | undefined

### Description
Initializes the SDK with the given options. See the Options documentation for the options you can pass to `init`.

### Method
Function

### Signature
`function init(options: InitOptions): Client | undefined`

### Parameters
- **options** (InitOptions) - Required - The configuration options for the SDK.

### Returns
- **Client | undefined** - The initialized client, or `undefined` if initialization failed.

```

--------------------------------

### Set span attributes when starting a span

Source: https://docs.sentry.io/platforms/javascript/guides/node/tracing/instrumentation

Use Sentry.startSpan to set attributes at span creation. Attributes can be string, number, boolean, or arrays of these types. The example sets 'payment.provider' and later sets additional attributes on the span.

```javascript
await Sentry.startSpan(
  {
    name: "Charge payment provider",
    op: "payment.charge",
    attributes: {
      "payment.provider": provider.name,
    },
  },
  async (span) => {
    const result = await provider.charge(order);
    span.setAttribute("payment.retry_count", result.retryCount);
    span.setAttribute("payment.outcome", result.outcome);
    return result;
  },
);
```

--------------------------------

### init(options: InitOptions): Client | undefined

Source: https://docs.sentry.io/platforms/javascript/guides/node/enriching-events/identify-user

Initializes the SDK with the given options. See the Options documentation for available options.

```typescript
function init(options: InitOptions): Client | undefined

```

--------------------------------

### init(options: InitOptions): Client | undefined

Source: https://docs.sentry.io/platforms/javascript/guides/node/apis

Initializes the Sentry SDK with the provided options.

```APIDOC
## [FUNCTION] init(options: InitOptions): Client | undefined

### Description
Initializes the SDK with the given options.

### Method
function

### Endpoint
init(options: InitOptions): Client | undefined

### Parameters
#### Function Parameters
- **options** (InitOptions) - Required - Options to configure the SDK. See Options for details.

### Response
#### Success Response
- **Client | undefined** - The initialized client, or undefined if initialization failed.
```

--------------------------------

### Scope-specific event processor example

Source: https://docs.sentry.io/platforms/javascript/guides/node/apis

Example of adding an event processor to a scope so it only applies to events captured within that scope. Uses `Sentry.withScope` and `scope.addEventProcessor`.

```javascript
Sentry.withScope((scope) => {
  scope.addEventProcessor((event) => {
    // this will only be applied to events captured within this scope
    return event;
  });

  Sentry.captureException(new Error("test"));
});
```

--------------------------------

### Start an asynchronous span with Sentry.startSpan()

Source: https://docs.sentry.io/platforms/javascript/guides/node/tracing/instrumentation/custom-instrumentation

Starts an asynchronous span with Sentry.startSpan(). The span is ended when the returned promise resolves or rejects. If the callback rejects, the span is marked as failed.

```javascript
const result = await Sentry.startSpan(
  { name: "Important Function" },
  async () => {
    const res = await doSomethingAsync();
    return updateRes(res);
  },
);
```

--------------------------------

### Sentry.init with placeholder DSN

Source: https://docs.sentry.io/platforms/javascript/guides/node/tracing/trace-propagation

Initializes Sentry with a placeholder DSN and enables tracing at full sample rate. Use this when you want to configure the SDK before replacing the DSN with your own.

```JavaScript
Sentry.init({
  dsn: "___PUBLIC_DSN___",
  tracesSampleRate: 1,
});

```

--------------------------------

### getFeedback()

Source: https://docs.sentry.io/platforms/javascript/guides/node/configuration/apis

Gets the feedback integration, if it has been added.

```APIDOC
## getFeedback()

### Description
Gets the feedback integration, if it has been added. This can be used to access the feedback integration in a type-safe way.

### Method
function

### Signature
`function getFeedback(): ReturnType<feedbackIntegration> | undefined`

### Returns
- **ReturnType<feedbackIntegration> | undefined** - The feedback integration if it has been added, otherwise undefined.
```

--------------------------------

### Initialize Sentry SDK in instrument.js

Source: https://docs.sentry.io/platforms/javascript/guides/node

Create a file named instrument.(js|mjs) in the root directory and add this code to import and initialize Sentry. It includes optional integrations for profiling and performance tracing, with tracesSampleRate and profileSessionSampleRate set to 1.0. The snippet shows the CommonJS version; an ESM variation is also available.

```javascript
const Sentry = require("@sentry/node");
// ___PRODUCT_OPTION_START___ profiling
const { nodeProfilingIntegration } = require("@sentry/profiling-node");
// ___PRODUCT_OPTION_END___ profiling

Sentry.init({
  dsn: "https://<key>@o<orgId>.ingest.sentry.io/<projectId>",
  // ___PRODUCT_OPTION_START___ profiling

  integrations: [
    // Add our Profiling integration
    nodeProfilingIntegration(),
  ],
  // ___PRODUCT_OPTION_END___ profiling
  // ___PRODUCT_OPTION_START___ performance

  // Set tracesSampleRate to 1.0 to capture 100%
  // of transactions for tracing.
  // We recommend adjusting this value in production
  // Learn more at
  // https://docs.sentry.io/platforms/javascript/guides/node/configuration/options/#tracesSampleRate
  tracesSampleRate: 1.0,
  // ___PRODUCT_OPTION_END___ performance
  // ___PRODUCT_OPTION_START___ profiling

  // Enable profiling for a percentage of sessions
  // Learn more at
  // https://docs.sentry.io/platforms/javascript/configuration/options/#profileSessionSampleRate
  profileSessionSampleRate: 1.0,
  // ___PRODUCT_OPTION_END___ profiling
});
```

--------------------------------

### init(options: InitOptions): Client | undefined

Source: https://docs.sentry.io/platforms/javascript/guides/node/apis

Initializes the Sentry SDK with the given options. See the Options documentation for available options.

```typescript
function init(options: InitOptions): Client | undefined
```

--------------------------------

### Sentry.init with prismaIntegration for Prisma v6 & v7

Source: https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/prisma

No configuration is required for Prisma versions 6 and 7; tracing is enabled by default. This snippet shows the standard Sentry initialization with the Prisma integration.

```javascript
Sentry.init({
  tracesSampleRate: 1.0,
  integrations: [Sentry.prismaIntegration()],
});
```

--------------------------------

### Create AI request span with Sentry.startSpan

Source: https://docs.sentry.io/platforms/javascript/guides/node/agent-tracing/manual-instrumentation

Use this snippet to instrument a chat request to an LLM. Set the span op to 'gen_ai.chat' and name to 'chat o3-mini'. Map the provider response into span attributes, including usage tokens. Keep system prompts in 'gen_ai.system_instructions' and note that input tokens include cache-read/write tokens, output tokens include reasoning tokens.

```javascript
const messages = [
  { role: "user", parts: [{ type: "text", content: "Tell me a joke" }] },
];
const tools = [
  { name: "get_weather", description: "Get weather for a city" },
];

await Sentry.startSpan(
  {
    op: "gen_ai.chat",
    name: "chat o3-mini",
    attributes: {
      "gen_ai.operation.name": "chat",
      "gen_ai.request.model": "o3-mini",
      "gen_ai.provider.name": "openai",
      "gen_ai.agent.name": "Weather Agent", // when this call is under an agent
      "gen_ai.system_instructions": "You are a helpful assistant.",
      "gen_ai.tool.definitions": JSON.stringify(tools),
      "gen_ai.input.messages": JSON.stringify(messages),
    },
  },
  async (span) => {
    // Call your model provider; map its response into span attributes below
    const result = await yourLLMClient.chat({
      model: "o3-mini",
      messages,
    });

    span.setAttributes({
      "gen_ai.response.model": result.model,
      "gen_ai.response.id": result.id,
      "gen_ai.output.messages": JSON.stringify([
        {
          role: "assistant",
          parts: [{ type: "text", content: result.text }],
        },
      ]),
      "gen_ai.response.finish_reasons": JSON.stringify([
        result.finishReason,
      ]),
      "gen_ai.usage.input_tokens": result.usage.inputTokens,
      "gen_ai.usage.output_tokens": result.usage.outputTokens,
    });
    // If the provider reports cached tokens, record them as a subset of input tokens
    if (result.usage.cachedInputTokens != null) {
      span.setAttribute(
        "gen_ai.usage.cache_read.input_tokens",
        result.usage.cachedInputTokens,
      );
    }
    return result;
  },
);
```

--------------------------------

### getActiveSpan(): Span | undefined

Source: https://docs.sentry.io/platforms/javascript/guides/node/enriching-events/identify-user

Get the currently active span.

```APIDOC
## getActiveSpan(): Span | undefined

### Description
Get the currently active span.

### Method
function

### Signature
`getActiveSpan(): Span | undefined`

### Parameters
None

### Returns
- **Span | undefined** - The currently active span, or `undefined` if there is no active span.
```

--------------------------------

### Sentry.captureCheckIn()

Source: https://docs.sentry.io/platforms/javascript/guides/node/crons

Check-in monitoring allows you to track a job's progress by completing two check-ins: one at the start of your job and another at the end of your job. This two-step process allows Sentry to notify you if your job didn't start when expected (missed) or if it exceeded its maximum runtime (failed).

```APIDOC
## Sentry.captureCheckIn()

### Description
Check-in monitoring allows you to track a job's progress by completing two check-ins: one at the start of your job and another at the end of your job. This two-step process allows Sentry to notify you if your job didn't start when expected (missed) or if it exceeded its maximum runtime (failed).

### Method
`Sentry.captureCheckIn()`

### Parameters
- **checkInId** (string) - Optional - The ID of the check-in returned from the initial `in_progress` check-in. Required for subsequent check-ins to update the same check-in.
- **monitorSlug** (string) - Required - The unique slug of the monitor.
- **status** (string) - Required - The status of the check-in. Possible values: `"in_progress"`, `"ok"`, `"error"`.

### Request Example
```javascript
// 🟡 Notify Sentry your job is running:
const checkInId = Sentry.captureCheckIn({
  monitorSlug: "<monitor-slug>",
  status: "in_progress",
});

// Execute your scheduled task here...

// 🟢 Notify Sentry your job has completed successfully:
Sentry.captureCheckIn({
  // Make sure this variable is named `checkInId`
  checkInId,
  monitorSlug: "<monitor-slug>",
  status: "ok",
});
```

### Failure Example
```javascript
// 🔴 Notify Sentry your job has failed:
Sentry.captureCheckIn({
  // Make sure this variable is named `checkInId`
  checkInId,
  monitorSlug: "<monitor-slug>",
  status: "error",
});
```

```

--------------------------------

### pinoIntegration

Source: https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/pino

Documentation for the pinoIntegration function, including its options and usage examples.

```APIDOC
## pinoIntegration

### Description
Adds instrumentation for the `pino` library so that calls to the pino logger are captured as logs. Optionally, you can capture calls to the pino logger as errors.

### Import Name
`Sentry.pinoIntegration`

### Usage
```JavaScript
Sentry.init({
  integrations: [Sentry.pinoIntegration()],
});
```

### Options

#### `error`
Configure how pino logs are captured as Sentry errors.

##### `levels`
- Type: `Array<'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal'>`
- Default: `[]`
- Description: Levels that trigger capturing of events. When a pino log message is logged at one of these levels, it will be captured as a Sentry error event.

##### `handled`
- Type: `boolean`
- Default: `true`
- Description: By default, Sentry will mark captured errors as handled. Set this to `false` if you want to mark them as unhandled instead.

#### `log`
Configure how pino logs are captured as Sentry logs.

##### `levels`
- Type: `Array<'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal'>`
- Default: `["trace", "debug", "info", "warn", "error", "fatal"]`
- Description: Levels that trigger capturing of logs.

### Supported Versions
- `pino`: `>=8.0.0 <11`

### Examples

#### Send only info, error, and warn log levels to Sentry
```js
Sentry.init({
  integrations: [
    Sentry.pinoIntegration({ log: { levels: ["info", "warn", "error"] } }),
  ],
});
```

#### Send errors to Sentry
```js
Sentry.init({
  integrations: [
    Sentry.pinoIntegration({ error: { levels: ["warn", "error"] } }),
  ],
});
```
```

--------------------------------

### Sentry.showReportDialog

Source: https://docs.sentry.io/platforms/javascript/guides/node/user-feedback/configuration

Documentation for the Sentry.showReportDialog method, including all configurable options and callbacks.

```APIDOC
## Sentry.showReportDialog

### Description
Displays the Crash-Report modal to collect user feedback. All options can be passed through the `Sentry.showReportDialog` call.

### Method
`Sentry.showReportDialog`

### Parameters
- `eventId` (string) - Optional - Manually set the id of the event.
- `dsn` (string) - Optional - Manually set dsn to report to.
- `user` (object) - Optional - Manually set user data with keys listed below.
- `user.email` (string) - Optional - User's email address.
- `user.name` (string) - Optional - User's name.
- `lang` (string) - Optional - Override for Sentry's language code.
- `title` (string) - Optional - Title text. Default: "It looks like we're having issues."
- `subtitle` (string) - Optional - Subtitle text. Default: "Our team has been notified."
- `subtitle2` (string) - Optional - Secondary subtitle text. Default: "If you'd like to help, tell us what happened below." (Not visible on small screen resolutions.)
- `labelName` (string) - Optional - Label for name field. Default: "Name"
- `labelEmail` (string) - Optional - Label for email field. Default: "Email"
- `labelComments` (string) - Optional - Label for comments field. Default: "What happened?"
- `labelClose` (string) - Optional - Label for close button. Default: "Close"
- `labelSubmit` (string) - Optional - Label for submit button. Default: "Submit"
- `errorGeneric` (string) - Optional - Error message for generic submission failure. Default: "An unknown error occurred while submitting your report. Please try again."
- `errorFormEntry` (string) - Optional - Error message for invalid form fields. Default: "Some fields were invalid. Please correct the errors and try again."
- `successMessage` (string) - Optional - Success message after submission. Default: "Your feedback has been sent. Thank you!"
- `onLoad` (function) - Optional - Callback invoked when the widget opens.
- `onClose` (function) - Optional - Callback invoked when the widget closes. (Requires JS SDK version v7.82.0 or higher.)
- `onError` (function) - Optional - Callback that receives an `Error` if the dialog cannot be shown.

### Request Example
```javascript
Sentry.showReportDialog({
  eventId: '...',
  dsn: '...',
  user: {
    email: '...',
    name: '...'
  },
  lang: '...',
  title: '...',
  subtitle: '...',
  subtitle2: '...',
  labelName: '...',
  labelEmail: '...',
  labelComments: '...',
  labelClose: '...',
  labelSubmit: '...',
  errorGeneric: '...',
  errorFormEntry: '...',
  successMessage: '...',
  onLoad() {
    // Log an event to amplitude when the report dialog opens
    amplitude.logEvent("report_dialog_seen");
  },
  onClose() {
    // Refresh the page after the user closes the report dialog
    location.reload();
  },
  onError(error) {
    console.error(error.message);
    window.alert(
      "The report form could not load. Check your connection or ad blocker settings and try again.",
    );
  },
});
```

### Response
No return value is documented.

### Error Handling
The `onError` callback handles failures when opening the dialog, not errors when submitting a report. It receives an `Error` with one of these messages:
- `No event ID to show the report dialog for`: Neither the `eventId` option nor `Sentry.lastEventId()` provides an event ID.
- `Failed to load the report dialog script`: The script failed to load, for example, because of an ad blocker or network problem.
```

--------------------------------

### getRootSpan(span: Span): Span

Source: https://docs.sentry.io/platforms/javascript/guides/node/enriching-events/identify-user

Get the root span of a span.

```APIDOC
## getRootSpan(span: Span): Span

### Description
Get the root span of a span.

### Method
function

### Signature
`getRootSpan(span: Span): Span`

### Parameters
- **span** (Span) - Required - The span to get the root span of.

### Returns
- **Span** - The root span of the given span.
```

--------------------------------

### Manual instrumentation with Sentry.instrumentTypeSafeClient

Source: https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/typesafe

Manually instruments a TypeSafe client when automatic instrumentation is not used. The first block imports the Sentry SDK. The second block imports TypeSafe classes, creates a client, wraps it with Sentry.instrumentTypeSafeClient, and calls systemOne. Use only one instrumentation approach per client.

```javascript
import * as Sentry from "<sdk-package-name>";
```

```javascript
import { TypeSafeClient, choice } from "@typesafe-ai/sdk";

const typesafe = new TypeSafeClient({ apiKey: "your-typesafe-api-key" });
const client = Sentry.instrumentTypeSafeClient(typesafe, {
  recordInputs: false,
  recordOutputs: false,
});

const result = await client.systemOne({
  state: "I was charged twice. Please refund the extra charge.",
  questions: {
    department: choice("Which team should handle this?", {
      billing: "Charges and refunds",
      technical: "Bugs and outages",
    }),
  },
});
```

--------------------------------

### Get root span: getRootSpan

Source: https://docs.sentry.io/platforms/javascript/guides/node/apis

Returns the root span of the given span.

```typescript
function getRootSpan(span: Span): Span
```

--------------------------------

### withMonitor(monitorSlug: string, callback: () => any, monitorConfig?: MonitorConfig): string

Source: https://docs.sentry.io/platforms/javascript/guides/node/apis

Wraps a callback with a cron monitor check-in and sends it to Sentry when the callback finishes.

```APIDOC
## withMonitor(monitorSlug: string, callback: () => any, monitorConfig?: MonitorConfig): string

### Description
Wraps a callback with a cron monitor check-in. The check-in will be sent to Sentry when the callback finishes.

### Parameters
- **monitorSlug** (string) - Required - The slug of the monitor.
- **callback** (() => any) - Required - The callback to wrap.
- **monitorConfig** (MonitorConfig) - Optional - Configuration for the monitor.

### MonitorConfig Object
- **schedule** ({ type: "crontab", value: string } | { type: "interval", value: number, unit: "year" | "month" | "day" | "hour" | "minute" }) - Required - The schedule of the monitor.
- **checkinMargin** (number) - Optional - The margin for check-in.
- **maxRuntime** (number) - Optional - The maximum runtime.
- **timezone** (string) - Optional - The timezone.
- **failureIssueThreshold** (number) - Optional - The failure issue threshold.
- **recoveryThreshold** (number) - Optional - The recovery threshold.

### Returns
- **string** - The check-in ID.
```

--------------------------------

### Sentry.rewriteFramesIntegration

Source: https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/rewriteframes

Configuration for the RewriteFrames integration in Sentry for Node.js, including options and usage examples.

```APIDOC
## [Sentry.rewriteFramesIntegration] [Sentry.rewriteFramesIntegration]

### Description
Allows you to apply a transformation to each frame of the stack trace. 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.

### Method
Integration initialization

### Endpoint
Sentry.rewriteFramesIntegration(options)

### Parameters
#### Options
- **root** (string) - Optional - Root path that will be stripped from the current frame's filename by the default iteratee if the filename is an absolute path.
- **prefix** (string) - Optional - A custom prefix that will be used by the default iteratee. Default: `app://`
- **iteratee** (function) - Optional - Function that takes the frame, applies a transformation, and returns it.

### Request Example
```javascript
import * as Sentry from "@sentry/node";

Sentry.init({
  dsn: "https://<key>@o<orgId>.ingest.sentry.io/<projectId>",
  integrations: [Sentry.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;
    }
  )],
});
```

### Response
#### Success Response
No explicit response is documented. The integration is configured during Sentry initialization.

### Usage Examples
For example, if the full path to your file is `/www/src/app/file.js`:

| Usage                                        | Path in Stack Trace      | Description                                                                                                                   |
| -------------------------------------------- | ------------------------ | ----------------------------------------------------------------------------------------------------------------------------- |
| `rewriteFramesIntegration()`                 | `app:///file.js`         | The default behavior is to replace the absolute path, except the filename, and prefix it with the default prefix (`app:///`). |
| `rewriteFramesIntegration({prefix: 'foo/'})` | `foo/file.js`            | Prefix `foo/` is used instead of the default prefix `app:///`.                                                                |
| `rewriteFramesIntegration({root: '/www'})`   | `app:///src/app/file.js` | `root` is defined as `/www`, so only that part is trimmed from the beginning of the path.                                     |
```

--------------------------------

### withMonitor

Source: https://docs.sentry.io/platforms/javascript/guides/node/configuration/apis

Documentation for the withMonitor function that wraps a callback with a cron monitor check in and sends it to Sentry when the callback finishes.

```APIDOC
## withMonitor

### Description
Wraps a callback with a cron monitor check in. The check in will be sent to Sentry when the callback finishes.

### Method
function

### Signature
function withMonitor(monitorSlug: string, callback: () => any, monitorConfig?: MonitorConfig): string

### Parameters
#### monitorSlug (required)
- **monitorSlug** (string) - Required - The slug of the monitor.

#### callback (required)
- **callback** (function) - Required - The callback to wrap.

#### monitorConfig (optional)
- **schedule** (object) - Required - The schedule of the monitor. Either `{ type: "crontab", value: string }` or `{ type: "interval", value: number, unit: "year" | "month" | "day" | "hour" | "minute" }`.
- **checkinMargin** (number) - Optional - The margin for the check in.
- **maxRuntime** (number) - Optional - The maximum runtime.
- **timezone** (string) - Optional - The timezone.
- **failureIssueThreshold** (number) - Optional - The failure issue threshold.
- **recoveryThreshold** (number) - Optional - The recovery threshold.

### Returns
- **string** - The check-in ID.
```

--------------------------------

### Configure eventLoopBlockIntegration in Sentry.init

Source: https://docs.sentry.io/platforms/javascript/guides/node/configuration/application-not-responding

Initializes Sentry with the eventLoopBlockIntegration from @sentry/node-native, setting a 1000ms threshold. Use this recommended integration to capture stack traces when the event loop is blocked. Requires the @sentry/node-native package.

```JavaScript
import * as Sentry from "@sentry/node";
import { eventLoopBlockIntegration } from "@sentry/node-native";

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  integrations: [eventLoopBlockIntegration({ threshold: 1000 })],
});
```
Tokens:
Raw