refactor(back): rework sentry integration

apps/backend/src/app/app.module.ts

@@ -1,12 +1,10 @@
 import { Module } from '@nestjs/common';
-import { APP_FILTER } from '@nestjs/core';
+import { APP_FILTER, APP_INTERCEPTOR } from '@nestjs/core';
 import { LoggerModule } from 'nestjs-pino';
-import * as Sentry from '@sentry/node';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { FastifyMulterModule } from '@nest-lab/fastify-multer';
 import { ExceptionHandlerFilter } from './filters/exception-handler.filter';
 import { ConfigFactory, Environment, validate } from './config';
-import { SentryModule } from './modules/sentry/sentry.module';
 import { AuthModule } from './modules/auth/auth.module';
 import { ActivitiesModule } from './modules/activities/activities.module';
 import { AdminModule } from './modules/admin/admin.module';
@@ -22,6 +20,7 @@ import { MapReviewModule } from './modules/map-review/map-review.module';
 import { DbModule } from './modules/database/db.module';
 import { KillswitchModule } from './modules/killswitch/killswitch.module';
 import { HealthcheckModule } from './modules/healthcheck/healthcheck.module';
+import { setupNestInterceptor } from '../instrumentation';
 
 @Module({
   imports: [
@@ -31,34 +30,6 @@ import { HealthcheckModule } from './modules/healthcheck/healthcheck.module';
       isGlobal: true,
       validate
     }),
-    // We use Sentry in production for error logging and performance tracing.
-    // This is a small wrapper module around @sentry/node that only inits in
-    // production if a valid DSN is set.
-    SentryModule.forRootAsync({
-      useFactory: async (config: ConfigService) => {
-        // Whether to enable SentryInterceptor. If enabled, we run a transaction
-        // for the lifetime of tracesSampleRate * all HTTP requests. This
-        // provides more detailed error
-        const enableTracing = config.getOrThrow('sentry.enableTracing');
-        return {
-          environment: config.getOrThrow('env'),
-          enableTracing,
-          sentryOpts: {
-            // If this isn't set in prod we won't init Sentry.
-            dsn: config.getOrThrow('sentry.dsn'),
-            enableTracing,
-            environment: config.getOrThrow('sentry.env'),
-            tracesSampleRate: config.getOrThrow('sentry.tracesSampleRate'),
-            integrations: config.getOrThrow('sentry.tracePrisma')
-              ? [Sentry.prismaIntegration()]
-              : undefined,
-            debug: false
-          }
-        };
-      },
-      imports: [DbModule.forRoot()],
-      inject: [ConfigService]
-    }),
     // Pino is a highly performant logger that outputs logs as JSON, which we
     // then export to Grafana Loki. This module sets up `pino-http` which logs
     // all HTTP requests (so no need for a Nest interceptor).
@@ -100,6 +71,10 @@ import { HealthcheckModule } from './modules/healthcheck/healthcheck.module';
     {
       provide: APP_FILTER,
       useClass: ExceptionHandlerFilter
+    },
+    {
+      provide: APP_INTERCEPTOR,
+      useFactory: setupNestInterceptor
     }
   ]
 })

apps/backend/src/app/config/config.interface.ts

@@ -39,6 +39,7 @@ export interface ConfigInterface {
   sentry: {
     dsn: string;
     enableTracing: boolean;
+    enableNodeProfiling: boolean;
     tracesSampleRate: number;
     tracePrisma: boolean;
     env: 'production' | 'staging';

apps/backend/src/app/config/config.ts

@@ -45,7 +45,11 @@ export const ConfigFactory = (): ConfigInterface => {
       enableTracing: process.env['SENTRY_ENABLE_TRACING'] === 'true' || false,
       tracesSampleRate: +process.env['SENTRY_TRACE_SAMPLE_RATE'] || 0,
       tracePrisma: process.env['SENTRY_TRACE_PRISMA'] === 'true' || false,
-      env: (process.env['SENTRY_ENV'] || '') as 'production' | 'staging'
+      env:
+        ((process.env['SENTRY_ENV'] || '') as 'production' | 'staging') ||
+        'staging',
+      enableNodeProfiling:
+        process.env['SENTRY_ENABLE_NODE_PROFILING'] === 'true' || false
     },
     sessionSecret: process.env['SESSION_SECRET'] || '',
     steam: {

apps/backend/src/app/config/config.validation.ts

@@ -82,6 +82,10 @@ export class ConfigValidation {
   @IsBoolean()
   readonly SENTRY_TRACE_PRISMA?: boolean;
 
+  @IsOptional()
+  @IsBoolean()
+  readonly SENTRY_ENABLE_NODE_PROFILING?: boolean;
+
   @IsOptional()
   @IsIn(['production', 'staging'])
   readonly SENTRY_ENV?: 'production' | 'staging';

apps/backend/src/app/filters/exception-handler.filter.ts

@@ -4,24 +4,21 @@ import {
   ExceptionFilter,
   HttpException,
   HttpStatus,
-  Inject,
-  Logger
+  Logger,
+  ServiceUnavailableException
 } from '@nestjs/common';
 import { HttpAdapterHost } from '@nestjs/core';
 import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library';
 import { ConfigService } from '@nestjs/config';
 import '@sentry/tracing'; // Required according to https://github.com/getsentry/sentry-javascript/issues/4731#issuecomment-1075410543
 import * as Sentry from '@sentry/node';
-import { SENTRY_INIT_STATE } from '../modules/sentry/sentry.const';
-import { SentryInitState } from '../modules/sentry/sentry.interface';
 import { Environment } from '../config';
 
 @Catch()
 export class ExceptionHandlerFilter implements ExceptionFilter {
   constructor(
     private readonly httpAdapterHost: HttpAdapterHost,
-    private readonly configService: ConfigService,
-    @Inject(SENTRY_INIT_STATE) private readonly sentryEnabled: SentryInitState
+    private readonly configService: ConfigService
   ) {}
 
   private readonly logger = new Logger('Exception Filter');
@@ -69,9 +66,9 @@ export class ExceptionHandlerFilter implements ExceptionFilter {
             message: exception.message
           };
 
-          // In production, send to Sentry so long as it's enabled (if the DSN is
-          // invalid/empty it'll be disabled).
-          if (this.sentryEnabled) {
+          // In production, send to Sentry so long as it's enabled
+          // TODO: maybe still want to inject sentry init state token
+          if (Sentry.isInitialized()) {
             eventID = Sentry.captureException(exception);
             msg.eventID = eventID;
           }

apps/backend/src/app/interceptors/sentry.interceptor.ts

@@ -1,39 +1,25 @@
-import * as Sentry from '@sentry/node';
 import {
   CallHandler,
   ExecutionContext,
   Injectable,
   NestInterceptor
 } from '@nestjs/common';
-import { Observable, tap } from 'rxjs';
+import { Observable } from 'rxjs';
+import { getIsolationScope } from '@sentry/node';
 
 @Injectable()
 export class SentryInterceptor implements NestInterceptor {
   intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
-    const request = context.switchToHttp().getRequest();
-    const { method, url } = request;
+    if (context.getType() !== 'http') {
+      return next.handle();
+    }
 
-    // Based on https://github.com/ericjeker/nestjs-sentry-example/blob/main/src/sentry/sentry.interceptor.ts,
-    // but updated for Sentry 7, which majorly changed how transactions/spans are handled.
-    return Sentry.startSpan(
-      {
-        op: 'http.server',
-        name: `${method} ${url}`
-      },
-      (rootSpan: Sentry.Span) =>
-        Sentry.startSpan(
-          {
-            op: 'http.handler',
-            name: `${context.getClass().name}.${context.getHandler().name}`
-          },
-          (span: Sentry.Span) =>
-            next.handle().pipe(
-              tap(() => {
-                span.end();
-                rootSpan.end();
-              })
-            )
-        )
-    );
+    const req = context.switchToHttp().getRequest();
+
+    if (req.route) {
+      getIsolationScope().setTransactionName(
+        `${req.method?.toUpperCase() ?? 'UNKNOWN'} ${req.route.path}`
+      );
+    }
   }
 }

apps/backend/src/instrumentation.ts

@@ -0,0 +1,89 @@
+/* eslint @typescript-eslint/naming-convention: 0 */
+import * as Sentry from '@sentry/node';
+import {
+  NodeOptions,
+  nestIntegration,
+  prismaIntegration,
+  spanToJSON,
+  SEMANTIC_ATTRIBUTE_SENTRY_OP,
+  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN
+} from '@sentry/node';
+import { Integration } from '@sentry/types';
+import { nodeProfilingIntegration } from '@sentry/profiling-node';
+import { pino } from 'pino';
+import { ConfigFactory, Environment } from './app/config';
+import { SentryInterceptor } from './app/interceptors/sentry.interceptor';
+
+// Sentry now has a dedicated Nest in integration but doesn't let us integrate
+// nicely with our exception handling, also is in an alpha state. Largely
+// their approach from https://github.com/getsentry/sentry-javascript/blob/develop/packages/node/src/integrations/tracing/nest.ts
+
+// Not gonna run validator here, Nest will do on startup and throw if fails,
+// not a big deal if something is invalid here, we'll see immediately.
+const config = ConfigFactory();
+
+const logger = pino();
+
+// Private DSN to Sentry, if missing (or we're not in prod env), Sentry isn't
+// initialized.
+const dsn = config.sentry.dsn;
+
+// Whether to enable SentryInterceptor. If enabled, we run a transaction
+// for the lifetime of tracesSampleRate * all HTTP requests. This
+// provides more detailed error
+const enableTracing = config.sentry.enableTracing;
+
+// Rate at which to sample traces. 0.0 - 1
+const sampleRate = config.sentry.tracesSampleRate;
+
+const integrations: Integration[] = [nestIntegration()];
+
+if (config.sentry.tracePrisma) {
+  integrations.push(prismaIntegration());
+}
+
+//https://docs.sentry.io/platforms/javascript/guides/node/profiling/#runtime-flags
+if (config.sentry.enableNodeProfiling) {
+  integrations.push(nodeProfilingIntegration());
+}
+
+const opts: NodeOptions = {
+  dsn,
+  environment: config.sentry.env,
+  enableTracing,
+  tracesSampleRate: sampleRate,
+  profilesSampleRate: sampleRate,
+  debug: false,
+  integrations
+};
+
+if (config.env === Environment.PRODUCTION && dsn) {
+  logger.info('Initializing Sentry');
+  Sentry.init(opts);
+}
+
+export function setupNestInterceptor() {
+  if (!Sentry.isInitialized() || !config.sentry.dsn) return;
+
+  const client = Sentry.getClient();
+  if (!client) return;
+
+  client.on('spanStart', (span) => {
+    const attributes = spanToJSON(span).data || {};
+
+    // this is one of: app_creation, request_context, handler
+    const type = attributes['nestjs.type'];
+
+    // If this is already set, or we have no nest.js span, no need to process again...
+    if (attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP] || !type) {
+      return;
+    }
+
+    span.setAttributes({
+      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.otel.nestjs',
+      [SEMANTIC_ATTRIBUTE_SENTRY_OP]: `${type}.nestjs`
+    });
+  });
+
+  return new SentryInterceptor();
+}

apps/backend/src/main.ts

@@ -1,3 +1,4 @@
+import './instrumentation'; // This must be first import!!
 import { NestFactory, Reflector } from '@nestjs/core';
 import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
 import {