merge event names

Author: chargome

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

@@ -18,7 +18,7 @@ export class TestEventListener {
   @OnEvent('multiple.first')
   @OnEvent('multiple.second')
   async handleMultipleEvents(payload: any): Promise<void> {
-    Sentry.setTag('payload', payload);
+    Sentry.setTag(payload.data, true);
     await new Promise(resolve => setTimeout(resolve, 100));
   }
 }

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

@@ -43,18 +43,24 @@ test('Event emitter', async () => {
 
 test('Multiple OnEvent decorators', async () => {
   const firstTxPromise = waitForTransaction('nestjs-distributed-tracing', transactionEvent => {
-    return transactionEvent.transaction === 'event multiple.first';
+    return transactionEvent.transaction === 'event multiple.first|multiple.second';
   });
   const secondTxPromise = waitForTransaction('nestjs-distributed-tracing', transactionEvent => {
-    return transactionEvent.transaction === 'event multiple.second';
+    return transactionEvent.transaction === 'event multiple.first|multiple.second';
+  });
+  const rootPromise = waitForTransaction('nestjs-distributed-tracing', transactionEvent => {
+    return transactionEvent.transaction === 'GET /events/emit-multiple';
   });
 
   const eventsUrl = `http://localhost:3050/events/emit-multiple`;
   await fetch(eventsUrl);
 
   const firstTx = await firstTxPromise;
   const secondTx = await secondTxPromise;
+  const rootTx = await rootPromise;
 
-  expect(firstTx.tags).toMatchObject({ payload: { data: 'test-first' } });
-  expect(secondTx.tags).toMatchObject({ payload: { data: 'test-second' } });
+  expect(firstTx).toBeDefined();
+  expect(secondTx).toBeDefined();
+  // assert that the correct payloads were added
+  expect(rootTx.tags).toMatchObject({ 'test-first': true, 'test-second': true });
 });

packages/nestjs/src/integrations/sentry-nest-event-instrumentation.ts

@@ -58,31 +58,46 @@ export class SentryNestEventInstrumentation extends InstrumentationBase {
   private _createWrapOnEvent() {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return function wrapOnEvent(original: any) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      return function wrappedOnEvent(event: any, options?: any) {
-        const eventName = Array.isArray(event)
-          ? event.join(',')
-          : typeof event === 'string' || typeof event === 'symbol'
-            ? event.toString()
-            : '<unknown_event>';
-
+      return function wrappedOnEvent(event: unknown, options?: unknown) {
         // Get the original decorator result
         const decoratorResult = original(event, options);
 
         // Return a new decorator function that wraps the handler
-        return function (target: OnEventTarget, propertyKey: string | symbol, descriptor: PropertyDescriptor) {
-          if (!descriptor.value || typeof descriptor.value !== 'function' || target.__SENTRY_INTERNAL__) {
+        return (target: OnEventTarget, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
+          if (
+            !descriptor.value ||
+            typeof descriptor.value !== 'function' ||
+            target.__SENTRY_INTERNAL__ ||
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            descriptor.value.__SENTRY_INSTRUMENTED__
+          ) {
             return decoratorResult(target, propertyKey, descriptor);
           }
 
-          // Get the original handler
           const originalHandler = descriptor.value;
           // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
           const handlerName = originalHandler.name || propertyKey;
+          let eventName = typeof event === 'string' ? event : String(event);
+
+          // Instrument the actual handler
+          descriptor.value = async function (...args: unknown[]) {
+            // When multiple @OnEvent decorators are used on a single method, we need to get all event names
+            // from the reflector metadata as there is no information during execution which event triggered it
+            if (Reflect.getMetadataKeys(descriptor.value).includes('EVENT_LISTENER_METADATA')) {
+              const eventData = Reflect.getMetadata('EVENT_LISTENER_METADATA', descriptor.value);
+              if (Array.isArray(eventData) && eventData.length > 0) {
+                eventName = eventData
+                  .map((data: unknown) => {
+                    if (data && typeof data === 'object' && 'event' in data && data.event) {
+                      return data.event;
+                    }
+                    return '';
+                  })
+                  .reverse() // decorators are evaluated bottom to top
+                  .join('|');
+              }
+            }
 
-          // Instrument the handler
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          descriptor.value = async function (...args: any[]) {
             return startSpan(getEventSpanOptions(eventName), async () => {
               try {
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
@@ -96,6 +111,9 @@ export class SentryNestEventInstrumentation extends InstrumentationBase {
             });
           };
 
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          descriptor.value.__SENTRY_INSTRUMENTED__ = true;
+
           // Preserve the original function name
           Object.defineProperty(descriptor.value, 'name', {
             value: handlerName,