fix(nestjs): Check arguments before instrumenting with @Injectable

dev-packages/e2e-tests/test-applications/nestjs-basic/src/app.controller.ts

@@ -96,4 +96,24 @@ export class AppController {
   async exampleExceptionLocalFilter() {
     throw new ExampleExceptionLocalFilter();
   }
+
+  @Get('test-service-use')
+  testServiceWithUseMethod() {
+    return this.appService.use();
+  }
+
+  @Get('test-service-transform')
+  testServiceWithTransform() {
+    return this.appService.transform();
+  }
+
+  @Get('test-service-intercept')
+  testServiceWithIntercept() {
+    return this.appService.intercept();
+  }
+
+  @Get('test-service-canActivate')
+  testServiceWithCanActivate() {
+    return this.appService.canActivate();
+  }
 }

dev-packages/e2e-tests/test-applications/nestjs-basic/src/app.service.ts

@@ -78,4 +78,20 @@ export class AppService {
   async killTestCron() {
     this.schedulerRegistry.deleteCronJob('test-cron-job');
   }
+
+  use() {
+    console.log('Test use!');
+  }
+
+  transform() {
+    console.log('Test transform!');
+  }
+
+  intercept() {
+    console.log('Test intercept!');
+  }
+
+  canActivate() {
+    console.log('Test canActivate!');
+  }
 }

dev-packages/e2e-tests/test-applications/nestjs-basic/tests/transactions.test.ts

@@ -707,3 +707,23 @@ test('API route transaction includes exactly one nest async interceptor span aft
   // 'Interceptor - After Route' is NOT the parent of 'test-controller-span'
   expect(testControllerSpan.parent_span_id).not.toBe(exampleInterceptorSpanAfterRouteId);
 });
+
+test('Calling use method on service with Injectable decorator returns 200', async ({ baseURL }) => {
+  const response = await fetch(`${baseURL}/test-service-use`);
+  expect(response.status).toBe(200);
+});
+
+test('Calling transform method on service with Injectable decorator returns 200', async ({ baseURL }) => {
+  const response = await fetch(`${baseURL}/test-service-transform`);
+  expect(response.status).toBe(200);
+});
+
+test('Calling intercept method on service with Injectable decorator returns 200', async ({ baseURL }) => {
+  const response = await fetch(`${baseURL}/test-service-intercept`);
+  expect(response.status).toBe(200);
+});
+
+test('Calling canActivate method on service with Injectable decorator returns 200', async ({ baseURL }) => {
+  const response = await fetch(`${baseURL}/test-service-canActivate`);
+  expect(response.status).toBe(200);
+});

dev-packages/e2e-tests/test-applications/node-nestjs-basic/src/app.controller.ts

@@ -82,4 +82,24 @@ export class AppController {
   async flush() {
     await flush();
   }
+
+  @Get('test-service-use')
+  testServiceWithUseMethod() {
+    return this.appService.use();
+  }
+
+  @Get('test-service-transform')
+  testServiceWithTransform() {
+    return this.appService.transform();
+  }
+
+  @Get('test-service-intercept')
+  testServiceWithIntercept() {
+    return this.appService.intercept();
+  }
+
+  @Get('test-service-canActivate')
+  testServiceWithCanActivate() {
+    return this.appService.canActivate();
+  }
 }

dev-packages/e2e-tests/test-applications/node-nestjs-basic/src/app.service.ts

@@ -78,4 +78,20 @@ export class AppService {
   async killTestCron() {
     this.schedulerRegistry.deleteCronJob('test-cron-job');
   }
+
+  use() {
+    console.log('Test use!');
+  }
+
+  transform() {
+    console.log('Test transform!');
+  }
+
+  intercept() {
+    console.log('Test intercept!');
+  }
+
+  canActivate() {
+    console.log('Test canActivate!');
+  }
 }

dev-packages/e2e-tests/test-applications/node-nestjs-basic/tests/transactions.test.ts

@@ -705,3 +705,23 @@ test('API route transaction includes exactly one nest async interceptor span aft
   // 'Interceptor - After Route' is NOT the parent of 'test-controller-span'
   expect(testControllerSpan.parent_span_id).not.toBe(exampleInterceptorSpanAfterRouteId);
 });
+
+test('Calling use method on service with Injectable decorator returns 200', async ({ baseURL }) => {
+  const response = await fetch(`${baseURL}/test-service-use`);
+  expect(response.status).toBe(200);
+});
+
+test('Calling transform method on service with Injectable decorator returns 200', async ({ baseURL }) => {
+  const response = await fetch(`${baseURL}/test-service-transform`);
+  expect(response.status).toBe(200);
+});
+
+test('Calling intercept method on service with Injectable decorator returns 200', async ({ baseURL }) => {
+  const response = await fetch(`${baseURL}/test-service-intercept`);
+  expect(response.status).toBe(200);
+});
+
+test('Calling canActivate method on service with Injectable decorator returns 200', async ({ baseURL }) => {
+  const response = await fetch(`${baseURL}/test-service-canActivate`);
+  expect(response.status).toBe(200);
+});

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

@@ -1,7 +1,7 @@
 import { SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, withActiveSpan } from '@sentry/core';
 import type { Span } from '@sentry/types';
 import { addNonEnumerableProperty } from '@sentry/utils';
-import type { CatchTarget, InjectableTarget, Observable, Subscription } from './types';
+import type { CatchTarget, InjectableTarget, NextFunction, Observable, Subscription } from './types';
 
 const sentryPatched = 'sentryPatched';
 
@@ -53,3 +53,22 @@ export function instrumentObservable(observable: Observable<unknown>, activeSpan
     });
   }
 }
+
+/**
+ * Proxies the next() call in a nestjs middleware to end the span when it is called.
+ */
+export function getNextProxy(next: NextFunction, span: Span, prevSpan: undefined | Span): NextFunction {
+  return new Proxy(next, {
+    apply: (originalNext, thisArgNext, argsNext) => {
+      span.end();
+
+      if (prevSpan) {
+        return withActiveSpan(prevSpan, () => {
+          return Reflect.apply(originalNext, thisArgNext, argsNext);
+        });
+      } else {
+        return Reflect.apply(originalNext, thisArgNext, argsNext);
+      }
+    },
+  });
+}

packages/node/src/integrations/tracing/nest/sentry-nest-instrumentation.ts

@@ -8,7 +8,7 @@ import {
 import { getActiveSpan, startInactiveSpan, startSpan, startSpanManual, withActiveSpan } from '@sentry/core';
 import type { Span } from '@sentry/types';
 import { SDK_VERSION, addNonEnumerableProperty, isThenable } from '@sentry/utils';
-import { getMiddlewareSpanOptions, instrumentObservable, isPatched } from './helpers';
+import { getMiddlewareSpanOptions, getNextProxy, instrumentObservable, isPatched } from './helpers';
 import type { CallHandler, CatchTarget, InjectableTarget, MinimalNestJsExecutionContext, Observable } from './types';
 
 const supportedVersions = ['>=8.0.0 <11'];
@@ -100,24 +100,24 @@ export class SentryNestInstrumentation extends InstrumentationBase {
 
             target.prototype.use = new Proxy(target.prototype.use, {
               apply: (originalUse, thisArgUse, argsUse) => {
+                // Middlewares have a request, response and next argument.
+                if (argsUse.length < 3) {
+                  return originalUse.apply(thisArgUse, argsUse);
+                }
+
                 const [req, res, next, ...args] = argsUse;
                 const prevSpan = getActiveSpan();
 
-                return startSpanManual(getMiddlewareSpanOptions(target), (span: Span) => {
-                  const nextProxy = new Proxy(next, {
-                    apply: (originalNext, thisArgNext, argsNext) => {
-                      span.end();
-
-                      if (prevSpan) {
-                        return withActiveSpan(prevSpan, () => {
-                          return Reflect.apply(originalNext, thisArgNext, argsNext);
-                        });
-                      } else {
-                        return Reflect.apply(originalNext, thisArgNext, argsNext);
-                      }
-                    },
-                  });
+                // Check that we can reasonably assume that the target is a middleware.
+                // Without these guards, instrumentation will fail if a function named 'use' on a service, which is
+                // decorated with @Injectable, is called.
+                if (!req || !res || !next || !(typeof next === 'function')) {
+                  return originalUse.apply(thisArgUse, argsUse);
+                }
 
+                return startSpanManual(getMiddlewareSpanOptions(target), (span: Span) => {
+                  // proxy next to end span on call
+                  const nextProxy = getNextProxy(next, span, prevSpan);
                   return originalUse.apply(thisArgUse, [req, res, nextProxy, args]);
                 });
               },
@@ -133,6 +133,17 @@ export class SentryNestInstrumentation extends InstrumentationBase {
 
             target.prototype.canActivate = new Proxy(target.prototype.canActivate, {
               apply: (originalCanActivate, thisArgCanActivate, argsCanActivate) => {
+                // Guards have a context argument.
+                if (argsCanActivate.length == 0) {
+                  return originalCanActivate.apply(thisArgCanActivate, argsCanActivate);
+                }
+
+                const context: MinimalNestJsExecutionContext = argsCanActivate[0];
+
+                if (!context) {
+                  return originalCanActivate.apply(thisArgCanActivate, argsCanActivate);
+                }
+
                 return startSpan(getMiddlewareSpanOptions(target), () => {
                   return originalCanActivate.apply(thisArgCanActivate, argsCanActivate);
                 });
@@ -148,6 +159,18 @@ export class SentryNestInstrumentation extends InstrumentationBase {
 
             target.prototype.transform = new Proxy(target.prototype.transform, {
               apply: (originalTransform, thisArgTransform, argsTransform) => {
+                // Pipes have a value and metadata argument.
+                if (argsTransform.length < 2) {
+                  return originalTransform.apply(thisArgTransform, argsTransform);
+                }
+
+                const value = argsTransform[0];
+                const metadata = argsTransform[1];
+
+                if (!value || !metadata) {
+                  return originalTransform.apply(thisArgTransform, argsTransform);
+                }
+
                 return startSpan(getMiddlewareSpanOptions(target), () => {
                   return originalTransform.apply(thisArgTransform, argsTransform);
                 });
@@ -163,12 +186,22 @@ export class SentryNestInstrumentation extends InstrumentationBase {
 
             target.prototype.intercept = new Proxy(target.prototype.intercept, {
               apply: (originalIntercept, thisArgIntercept, argsIntercept) => {
+                // Interceptors have a context and next argument.
+                if (argsIntercept.length < 2) {
+                  return originalIntercept.apply(thisArgIntercept, argsIntercept);
+                }
+
                 const context: MinimalNestJsExecutionContext = argsIntercept[0];
                 const next: CallHandler = argsIntercept[1];
 
                 const parentSpan = getActiveSpan();
                 let afterSpan: Span;
 
+                // Check that we can reasonably assume that the target is an interceptor.
+                if (!context || !next || !(typeof next.handle === 'function')) {
+                  return originalIntercept.apply(thisArgIntercept, argsIntercept);
+                }
+
                 return startSpanManual(getMiddlewareSpanOptions(target), (beforeSpan: Span) => {
                   // eslint-disable-next-line @typescript-eslint/unbound-method
                   next.handle = new Proxy(next.handle, {
@@ -263,6 +296,17 @@ export class SentryNestInstrumentation extends InstrumentationBase {
 
             target.prototype.catch = new Proxy(target.prototype.catch, {
               apply: (originalCatch, thisArgCatch, argsCatch) => {
+                if (argsCatch.length < 2) {
+                  return originalCatch.apply(thisArgCatch, argsCatch);
+                }
+
+                const exception = argsCatch[0];
+                const host = argsCatch[1];
+
+                if (!exception || !host) {
+                  return originalCatch.apply(thisArgCatch, argsCatch);
+                }
+
                 return startSpan(getMiddlewareSpanOptions(target), () => {
                   return originalCatch.apply(thisArgCatch, argsCatch);
                 });

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

@@ -73,3 +73,8 @@ export interface CatchTarget {
     catch?: (...args: any[]) => any;
   };
 }
+
+/**
+ * Represents an express NextFunction.
+ */
+export type NextFunction = (err?: any) => void;