# Nest.js | Sentry for Nest.js

## [Prerequisites](https://docs.sentry.io/platforms/javascript/guides/nestjs.md#prerequisites)

You need:

* A Sentry [account](https://sentry.io/signup/) and [project](https://docs.sentry.io/product/projects.md)
* Your application up and running
* Node version `18.0.0` or above (>= `19.9.0` or `18.19.0` recommended)

Are you using Node version < 18.19.0 or < 19.9.0?

The required Node version will increase in the next major release of the SDK (v11) to support features that rely on [`TracingChannel`](https://nodejs.org/api/diagnostics_channel.html#class-tracingchannel).

* We strongly recommend upgrading to at least Node `18.19.0` or `19.9.0` to get the best support.
* While we may add features relying on `TracingChannel` in v10.x releases, they will have backwards compatibility for older Node versions.

See the following [issue on GitHub](https://github.com/getsentry/sentry-javascript/issues/17585) for more details.

## [Step 1: Install](https://docs.sentry.io/platforms/javascript/guides/nestjs.md#step-1-install)

Choose the features you want to configure, and this guide will show you how:

Error Monitoring\[ ]Logs\[ ]Tracing\[ ]Profiling

Want to learn more about these features?

* [**Issues**](https://docs.sentry.io/product/issues.md) (always enabled): Sentry's core error monitoring product that automatically reports errors, uncaught exceptions, and unhandled rejections. If you have something that looks like an exception, Sentry can capture it.
* [**Tracing**](https://docs.sentry.io/product/tracing.md): Track software performance while seeing the impact of errors across multiple systems. For example, distributed tracing allows you to follow a request from the frontend to the backend and back.
* [**Profiling**](https://docs.sentry.io/product/explore/profiling.md): Gain deeper insight than traditional tracing without custom instrumentation, letting you discover slow-to-execute or resource-intensive functions in your app.
* [**Logs**](https://docs.sentry.io/product/explore/logs.md): Centralize and analyze your application logs to correlate them with errors and performance issues. Search, filter, and visualize log data to understand what's happening in your applications.

### [Install the Sentry SDK](https://docs.sentry.io/platforms/javascript/guides/nestjs.md#install-the-sentry-sdk)

Run the command for your preferred package manager to add the Sentry SDK to your application:

```bash
npm install @sentry/nestjs --save
```

```bash
npm install @sentry/nestjs @sentry/profiling-node --save
```

## [Step 2: Configure](https://docs.sentry.io/platforms/javascript/guides/nestjs.md#step-2-configure)

### [Initialize the Sentry SDK](https://docs.sentry.io/platforms/javascript/guides/nestjs.md#initialize-the-sentry-sdk)

To import and initialize Sentry, create a file named `instrument.ts` in the root directory of your project and add the following code:

`instrument.ts`

```typescript
import * as Sentry from "@sentry/nestjs";
//  profiling
const { nodeProfilingIntegration } = require("@sentry/profiling-node");
//  profiling

// Ensure to call this before requiring any other modules!
Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  //  profiling
  integrations: [
    // Add our Profiling integration
    nodeProfilingIntegration(),
  ],
  //  profiling
  //  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/nestjs/configuration/options/#tracesSampleRate
  tracesSampleRate: 1.0,
  //  performance
  //  profiling

  // Set profilesSampleRate to 1.0 to profile 100%
  // of sampled transactions.
  // This is relative to tracesSampleRate
  // Learn more at
  // https://docs.sentry.io/platforms/javascript/guides/nestjs/configuration/options/#profilesSampleRate
  profilesSampleRate: 1.0,
  //  profiling
});
```

### [Apply Instrumentation to Your App](https://docs.sentry.io/platforms/javascript/guides/nestjs.md#apply-instrumentation-to-your-app)

Make sure to import the `instrument.ts` file before any other modules:

`main.ts`

```typescript
// Import this first!
import "./instrument";


// Now import other modules
import { NestFactory } from "@nestjs/core";
import { AppModule } from "./app.module";

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}

bootstrap();
```

Afterward, add the `SentryModule` as a root module to your main module:

`app.module.ts`

```typescript
import { Module } from "@nestjs/common";

import { SentryModule } from "@sentry/nestjs/setup";

import { AppController } from "./app.controller";
import { AppService } from "./app.service";

@Module({
  imports: [

    SentryModule.forRoot(),

    // ...other modules
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}
```

## [Step 3: Capture Nest.js Errors](https://docs.sentry.io/platforms/javascript/guides/nestjs.md#step-3-capture-nestjs-errors)

By default, Sentry only captures unhandled exceptions that aren't caught by an error filter. Additionally, `HttpException`s (including [derivatives](https://docs.nestjs.com/exception-filters#built-in-http-exceptions)) aren't captured by default because they mostly act as control flow vehicles.

To make sure Sentry captures all your app's errors, configure error handling based on how your application manages exceptions:

### [Using a Custom Global Filter](https://docs.sentry.io/platforms/javascript/guides/nestjs.md#using-a-custom-global-filter)

If you have a global catch-all exception filter, add a `@SentryExceptionCaptured()` decorator to the filter's `catch()` method:

```typescript
import { Catch, ExceptionFilter } from "@nestjs/common";

import { SentryExceptionCaptured } from "@sentry/nestjs";


@Catch()
export class YourCatchAllExceptionFilter implements ExceptionFilter {

  @SentryExceptionCaptured()

  catch(exception, host): void {
    // your implementation here
  }
}
```

### [Not Using a Custom Global Filter](https://docs.sentry.io/platforms/javascript/guides/nestjs.md#not-using-a-custom-global-filter)

If you don't have a global catch-all exception filter, add the `SentryGlobalFilter` to the providers of your main module, **before** any other exception filters:

```typescript
import { Module } from "@nestjs/common";

import { APP_FILTER } from "@nestjs/core";
import { SentryGlobalFilter } from "@sentry/nestjs/setup";


@Module({
  providers: [

    {
      provide: APP_FILTER,
      useClass: SentryGlobalFilter,
    },

    // ..other providers
  ],
})
export class AppModule {}
```

### [Using Error Filters for Specific Exception Types](https://docs.sentry.io/platforms/javascript/guides/nestjs.md#using-error-filters-for-specific-exception-types)

If you have error filters for specific types of exceptions (for example, `@Catch(HttpException)`) and you want to report these errors to Sentry, you need to capture them in the `catch()` handler using `Sentry.captureException()`:

```typescript
import { ArgumentsHost, BadRequestException, Catch } from "@nestjs/common";
import { BaseExceptionFilter } from "@nestjs/core";
import { ExampleException } from "./example.exception";

import * as Sentry from "@sentry/nestjs";


@Catch(ExampleException)
export class ExampleExceptionFilter extends BaseExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {

    Sentry.captureException(exception);

    return super.catch(new BadRequestException(exception.message), host);
  }
}
```

Are you using Microservices?

If you're using `@nestjs/microservices` make sure to handle errors in RPC contexts correctly by providing your own `RpcExceptionFilter` (see [Nest.js Microservices documentation](https://docs.nestjs.com/microservices/exception-filters)). `SentryGlobalFilter` in a [hybrid application](https://docs.nestjs.com/faq/hybrid-application) doesn't extend `BaseRpcExceptionFilter` since this depends on `@nestjs/microservices`.

Use `Sentry.captureException(exception)` in your custom filter in case you want to send these errors to Sentry:

```typescript
import { Catch, RpcExceptionFilter, ArgumentsHost } from "@nestjs/common";
import { Observable, throwError } from "rxjs";
import { RpcException } from "@nestjs/microservices";
import * as Sentry from "@sentry/nestjs";

@Catch(RpcException)
export class ExceptionFilter implements RpcExceptionFilter<RpcException> {
  catch(exception: RpcException, host: ArgumentsHost): Observable<any> {
    Sentry.captureException(exception); // optional
    return throwError(() => exception.getError());
  }
}
```

## [Step 4: Add Readable Stack Traces With Source Maps (Optional)](https://docs.sentry.io/platforms/javascript/guides/nestjs.md#step-4-add-readable-stack-traces-with-source-maps-optional)

The stack traces in your Sentry errors probably won't look like your actual code. To fix this, upload your source maps to Sentry. The easiest way to do this is by using the Sentry Wizard:

```bash
npx @sentry/wizard@latest -i sourcemaps
```

## [Step 5: Verify Your Setup](https://docs.sentry.io/platforms/javascript/guides/nestjs.md#step-5-verify-your-setup)

Let's test your setup and confirm that Sentry is working correctly and sending data to your Sentry project.

### [Issues](https://docs.sentry.io/platforms/javascript/guides/nestjs.md#issues)

First, let's verify that Sentry captures errors and creates issues in your Sentry project. Add the following route to your application, which will trigger an error that Sentry will capture:

```javascript
@Get("/debug-sentry")
  getError() {
    throw new Error("My first Sentry error!");
  }
```

### [Tracing](https://docs.sentry.io/platforms/javascript/guides/nestjs.md#tracing)

To test your tracing configuration, update the previous code snippet by starting a performance trace to measure the time it takes for the execution of your code:

```javascript
@Get("/debug-sentry")
  getError() {
    Sentry.startSpan(
	  {
	    op: "test",
	    name: "My First Test Transaction",
	  },
	  () => {
	    setTimeout(() => {
	      throw new Error("My first Sentry error!");
	    }, 99);
	  },
	);
}
```

### [View Captured Data in Sentry](https://docs.sentry.io/platforms/javascript/guides/nestjs.md#view-captured-data-in-sentry)

Now, head over to your project on [Sentry.io](https://sentry.io/) to view the collected data (it takes a couple of moments for the data to appear).

Need help locating the captured errors in your Sentry project?

1. Open the [**Issues**](https://sentry.io/orgredirect/organizations/:orgslug/issues) page and select an error from the issues list to view the full details and context of this error. For an interactive UI walkthrough, click [here](https://docs.sentry.io/product/sentry-basics/integrate-frontend/generate-first-error.md#ui-walkthrough).
2. Open the [**Traces**](https://sentry.io/orgredirect/organizations/:orgslug/traces) page and select a trace to reveal more information about each span, its duration, and any errors. For an interactive UI walkthrough, click [here](https://docs.sentry.io/product/sentry-basics/distributed-tracing/generate-first-error.md#ui-walkthrough).
3. Open the [**Profiles**](https://sentry.io/orgredirect/organizations/:orgslug/profiling) page, select a transaction, and then a profile ID to view its flame graph. For more information, click [here](https://docs.sentry.io/product/explore/profiling/profile-details.md).
4. Open the [**Logs**](https://sentry.io/explore/logs) page and filter by service, environment, or search keywords to view log entries from your application. For an interactive UI walkthrough, click [here](https://docs.sentry.io/product/explore/logs.md#overview).

## [Next Steps](https://docs.sentry.io/platforms/javascript/guides/nestjs.md#next-steps)

At this point, you should have integrated Sentry into your Nest.js application and should already be sending data to your Sentry project.

Now's a good time to customize your setup and look into more advanced topics. Our next recommended steps for you are:

* Extend Sentry to your frontend using one of our [frontend SDKs](https://docs.sentry.io/.md)
* Learn how to [manually capture errors](https://docs.sentry.io/platforms/javascript/guides/nestjs/usage.md)
* Continue to [customize your configuration](https://docs.sentry.io/platforms/javascript/guides/nestjs/configuration.md)
* Get familiar with [Sentry's product features](https://docs.sentry.io/product.md) like tracing, insights, and alerts

Are you having problems setting up the SDK?

* Check out alternative [installation methods](https://docs.sentry.io/platforms/javascript/guides/nestjs/install.md)
* Find various topics in [Troubleshooting](https://docs.sentry.io/platforms/javascript/guides/nestjs/troubleshooting.md)
* [Get support](https://sentry.zendesk.com/hc/en-us/)
