feat(nestjs): Instrument event handlers (#14307)

Author: chargome

dev-packages/e2e-tests/test-applications/nestjs-distributed-tracing/package.json

@@ -18,6 +18,7 @@
     "@nestjs/common": "^10.0.0",
     "@nestjs/core": "^10.0.0",
     "@nestjs/platform-express": "^10.0.0",
+    "@nestjs/event-emitter": "^2.0.0",
     "@sentry/nestjs": "latest || *",
     "@sentry/types": "latest || *",
     "reflect-metadata": "^0.2.0",

dev-packages/e2e-tests/test-applications/nestjs-distributed-tracing/src/events.controller.ts

@@ -0,0 +1,14 @@
+import { Controller, Get } from '@nestjs/common';
+import { EventsService } from './events.service';
+
+@Controller('events')
+export class EventsController {
+  constructor(private readonly eventsService: EventsService) {}
+
+  @Get('emit')
+  async emitEvents() {
+    await this.eventsService.emitEvents();
+
+    return { message: 'Events emitted' };
+  }
+}

dev-packages/e2e-tests/test-applications/nestjs-distributed-tracing/src/events.module.ts

@@ -0,0 +1,21 @@
+import { Module } from '@nestjs/common';
+import { APP_FILTER } from '@nestjs/core';
+import { EventEmitterModule } from '@nestjs/event-emitter';
+import { SentryGlobalFilter, SentryModule } from '@sentry/nestjs/setup';
+import { EventsController } from './events.controller';
+import { EventsService } from './events.service';
+import { TestEventListener } from './listeners/test-event.listener';
+
+@Module({
+  imports: [SentryModule.forRoot(), EventEmitterModule.forRoot()],
+  controllers: [EventsController],
+  providers: [
+    {
+      provide: APP_FILTER,
+      useClass: SentryGlobalFilter,
+    },
+    EventsService,
+    TestEventListener,
+  ],
+})
+export class EventsModule {}

dev-packages/e2e-tests/test-applications/nestjs-distributed-tracing/src/events.service.ts

@@ -0,0 +1,14 @@
+import { Injectable } from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+
+@Injectable()
+export class EventsService {
+  constructor(private readonly eventEmitter: EventEmitter2) {}
+
+  async emitEvents() {
+    await this.eventEmitter.emit('myEvent.pass', { data: 'test' });
+    await this.eventEmitter.emit('myEvent.throw');
+
+    return { message: 'Events emitted' };
+  }
+}

dev-packages/e2e-tests/test-applications/nestjs-distributed-tracing/src/listeners/test-event.listener.ts

@@ -0,0 +1,16 @@
+import { Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+
+@Injectable()
+export class TestEventListener {
+  @OnEvent('myEvent.pass')
+  async handlePassEvent(payload: any): Promise<void> {
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+
+  @OnEvent('myEvent.throw')
+  async handleThrowEvent(): Promise<void> {
+    await new Promise(resolve => setTimeout(resolve, 100));
+    throw new Error('Test error from event handler');
+  }
+}

dev-packages/e2e-tests/test-applications/nestjs-distributed-tracing/src/main.ts

@@ -3,18 +3,23 @@ import './instrument';
 
 // Import other modules
 import { NestFactory } from '@nestjs/core';
+import { EventsModule } from './events.module';
 import { TraceInitiatorModule } from './trace-initiator.module';
 import { TraceReceiverModule } from './trace-receiver.module';
 
 const TRACE_INITIATOR_PORT = 3030;
 const TRACE_RECEIVER_PORT = 3040;
+const EVENTS_PORT = 3050;
 
 async function bootstrap() {
   const trace_initiator_app = await NestFactory.create(TraceInitiatorModule);
   await trace_initiator_app.listen(TRACE_INITIATOR_PORT);
 
   const trace_receiver_app = await NestFactory.create(TraceReceiverModule);
   await trace_receiver_app.listen(TRACE_RECEIVER_PORT);
+
+  const events_app = await NestFactory.create(EventsModule);
+  await events_app.listen(EVENTS_PORT);
 }
 
 bootstrap();

dev-packages/e2e-tests/test-applications/nestjs-distributed-tracing/tests/events.test.ts

@@ -0,0 +1,43 @@
+import { expect, test } from '@playwright/test';
+import { waitForError, waitForTransaction } from '@sentry-internal/test-utils';
+
+test('Event emitter', async () => {
+  const eventErrorPromise = waitForError('nestjs-distributed-tracing', errorEvent => {
+    return errorEvent.exception.values[0].value === 'Test error from event handler';
+  });
+  const successEventTransactionPromise = waitForTransaction('nestjs-distributed-tracing', transactionEvent => {
+    return transactionEvent.transaction === 'event myEvent.pass';
+  });
+
+  const eventsUrl = `http://localhost:3050/events/emit`;
+  await fetch(eventsUrl);
+
+  const eventError = await eventErrorPromise;
+  const successEventTransaction = await successEventTransactionPromise;
+
+  expect(eventError.exception).toEqual({
+    values: [
+      {
+        type: 'Error',
+        value: 'Test error from event handler',
+        stacktrace: expect.any(Object),
+        mechanism: expect.any(Object),
+      },
+    ],
+  });
+
+  expect(successEventTransaction.contexts.trace).toEqual({
+    parent_span_id: expect.any(String),
+    span_id: expect.any(String),
+    trace_id: expect.any(String),
+    data: {
+      'sentry.source': 'custom',
+      'sentry.sample_rate': 1,
+      'sentry.op': 'event.nestjs',
+      'sentry.origin': 'auto.event.nestjs',
+    },
+    origin: 'auto.event.nestjs',
+    op: 'event.nestjs',
+    status: 'ok',
+  });
+});

packages/nestjs/package.json

@@ -50,8 +50,8 @@
     "@sentry/utils": "8.38.0"
   },
   "devDependencies": {
-    "@nestjs/common": "10.4.7",
-    "@nestjs/core": "10.4.7"
+    "@nestjs/common": "^8.0.0 || ^9.0.0 || ^10.0.0",
+    "@nestjs/core": "^8.0.0 || ^9.0.0 || ^10.0.0"
   },
   "peerDependencies": {
     "@nestjs/common": "^8.0.0 || ^9.0.0 || ^10.0.0",

packages/node/src/integrations/tracing/nest/helpers.ts

@@ -36,6 +36,24 @@ export function getMiddlewareSpanOptions(target: InjectableTarget | CatchTarget,
   };
 }
 
+/**
+ * Returns span options for nest event spans.
+ */
+export function getEventSpanOptions(event: string): {
+  name: string;
+  attributes: Record<string, string>;
+  forceTransaction: boolean;
+} {
+  return {
+    name: `event ${event}`,
+    attributes: {
+      [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'event.nestjs',
+      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.event.nestjs',
+    },
+    forceTransaction: true,
+  };
+}
+
 /**
  * Adds instrumentation to a js observable and attaches the span to an active parent span.
  */

packages/node/src/integrations/tracing/nest/nest.ts

@@ -12,6 +12,7 @@ import {
 import type { IntegrationFn, Span } from '@sentry/types';
 import { logger } from '@sentry/utils';
 import { generateInstrumentOnce } from '../../../otel/instrument';
+import { SentryNestEventInstrumentation } from './sentry-nest-event-instrumentation';
 import { SentryNestInstrumentation } from './sentry-nest-instrumentation';
 import type { MinimalNestJsApp, NestJsErrorFilter } from './types';
 
@@ -25,10 +26,15 @@ const instrumentNestCommon = generateInstrumentOnce('Nest-Common', () => {
   return new SentryNestInstrumentation();
 });
 
+const instrumentNestEvent = generateInstrumentOnce('Nest-Event', () => {
+  return new SentryNestEventInstrumentation();
+});
+
 export const instrumentNest = Object.assign(
   (): void => {
     instrumentNestCore();
     instrumentNestCommon();
+    instrumentNestEvent();
   },
   { id: INTEGRATION_NAME },
 );