feat(node): Drop http.server spans with 404 status by default

mydea · mydea · commit c9c00349bb35 · 2025-05-07T09:28:31.000+02:00
This can be configured via `dropSpansForIncomingRequestStatusCodes` option in `httpIntegration()`.
diff --git a/dev-packages/node-integration-tests/suites/express-v5/tracing/instrument-filterStatusCode.mjs b/dev-packages/node-integration-tests/suites/express-v5/tracing/instrument-filterStatusCode.mjs
@@ -0,0 +1,14 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  transport: loggingTransport,
+  integrations: [
+    Sentry.httpIntegration({
+      dropSpansForIncomingRequestStatusCodes: [499, /3\d{2}/],
+    }),
+  ],
+});
diff --git a/dev-packages/node-integration-tests/suites/express-v5/tracing/scenario-filterStatusCode.mjs b/dev-packages/node-integration-tests/suites/express-v5/tracing/scenario-filterStatusCode.mjs
@@ -0,0 +1,25 @@
+import * as Sentry from '@sentry/node';
+import { startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+import express from 'express';
+
+const app = express();
+
+app.get('/', (_req, res) => {
+  res.send({ response: 'response 0' });
+});
+
+app.get('/499', (_req, res) => {
+  res.status(499).send({ response: 'response 499' });
+});
+
+app.get('/300', (_req, res) => {
+  res.status(300).send({ response: 'response 300' });
+});
+
+app.get('/399', (_req, res) => {
+  res.status(399).send({ response: 'response 399' });
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);
diff --git a/dev-packages/node-integration-tests/suites/express-v5/tracing/test.ts b/dev-packages/node-integration-tests/suites/express-v5/tracing/test.ts
@@ -77,7 +77,7 @@ describe('express v5 tracing', () => {
       await runner.completed();
     });
 
-    test('handles root page correctly', async () => {
+    test('handles root route correctly', async () => {
       const runner = createRunner()
         .expect({
           transaction: {
@@ -89,30 +89,17 @@ describe('express v5 tracing', () => {
       await runner.completed();
     });
 
-    test('handles 404 page correctly', async () => {
+    test('ignores 404 routes by default', async () => {
       const runner = createRunner()
         .expect({
+          // No transaction is sent for the 404 route
           transaction: {
-            transaction: 'GET /does-not-exist',
-            contexts: {
-              trace: {
-                span_id: expect.stringMatching(/[a-f0-9]{16}/),
-                trace_id: expect.stringMatching(/[a-f0-9]{32}/),
-                data: {
-                  'http.response.status_code': 404,
-                  url: expect.stringMatching(/\/does-not-exist$/),
-                  'http.method': 'GET',
-                  'http.url': expect.stringMatching(/\/does-not-exist$/),
-                  'http.target': '/does-not-exist',
-                },
-                op: 'http.server',
-                status: 'not_found',
-              },
-            },
+            transaction: 'GET /',
           },
         })
         .start();
       runner.makeRequest('get', '/does-not-exist', { expectError: true });
+      runner.makeRequest('get', '/');
       await runner.completed();
     });
 
@@ -290,4 +277,56 @@ describe('express v5 tracing', () => {
       });
     });
   });
+
+  describe('filter status codes', () => {
+    createEsmAndCjsTests(
+      __dirname,
+      'scenario-filterStatusCode.mjs',
+      'instrument-filterStatusCode.mjs',
+      (createRunner, test) => {
+         // We opt-out of the default 404 filtering in order to test how 404 spans are handled
+        test('handles 404 route correctly', async () => {
+          const runner = createRunner()
+            .expect({
+              transaction: {
+                transaction: 'GET /does-not-exist',
+                contexts: {
+                  trace: {
+                    span_id: expect.stringMatching(/[a-f0-9]{16}/),
+                    trace_id: expect.stringMatching(/[a-f0-9]{32}/),
+                    data: {
+                      'http.response.status_code': 404,
+                      url: expect.stringMatching(/\/does-not-exist$/),
+                      'http.method': 'GET',
+                      'http.url': expect.stringMatching(/\/does-not-exist$/),
+                      'http.target': '/does-not-exist',
+                    },
+                    op: 'http.server',
+                    status: 'not_found',
+                  },
+                },
+              },
+            })
+            .start();
+          runner.makeRequest('get', '/does-not-exist', { expectError: true });
+          await runner.completed();
+        });
+
+        test('filters defined status codes', async () => {
+          const runner = createRunner()
+            .expect({
+              transaction: {
+                transaction: 'GET /',
+              },
+            })
+            .start();
+          await runner.makeRequest('get', '/499', { expectError: true });
+          await runner.makeRequest('get', '/300', { expectError: true });
+          await runner.makeRequest('get', '/399', { expectError: true });
+          await runner.makeRequest('get', '/');
+          await runner.completed();
+        });
+      },
+    );
+  });
 });
diff --git a/dev-packages/node-integration-tests/suites/express/tracing/instrument-filterStatusCode.mjs b/dev-packages/node-integration-tests/suites/express/tracing/instrument-filterStatusCode.mjs
@@ -0,0 +1,14 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  transport: loggingTransport,
+  integrations: [
+    Sentry.httpIntegration({
+      dropSpansForIncomingRequestStatusCodes: [499, /3\d{2}/],
+    }),
+  ],
+});
diff --git a/dev-packages/node-integration-tests/suites/express/tracing/scenario-filterStatusCode.mjs b/dev-packages/node-integration-tests/suites/express/tracing/scenario-filterStatusCode.mjs
@@ -0,0 +1,25 @@
+import * as Sentry from '@sentry/node';
+import { startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+import express from 'express';
+
+const app = express();
+
+app.get('/', (_req, res) => {
+  res.send({ response: 'response 0' });
+});
+
+app.get('/499', (_req, res) => {
+  res.status(499).send({ response: 'response 499' });
+});
+
+app.get('/300', (_req, res) => {
+  res.status(300).send({ response: 'response 300' });
+});
+
+app.get('/399', (_req, res) => {
+  res.status(399).send({ response: 'response 399' });
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);
diff --git a/dev-packages/node-integration-tests/suites/express/tracing/test.ts b/dev-packages/node-integration-tests/suites/express/tracing/test.ts
@@ -90,33 +90,17 @@ describe('express tracing', () => {
       await runner.completed();
     });
 
-    test('handles 404 page correctly', async () => {
+    test('ignores 404 routes by default', async () => {
       const runner = createRunner()
         .expect({
+          // No transaction is sent for the 404 route
           transaction: {
-            // FIXME: This is wrong :(
             transaction: 'GET /',
-            contexts: {
-              trace: {
-                span_id: expect.stringMatching(/[a-f0-9]{16}/),
-                trace_id: expect.stringMatching(/[a-f0-9]{32}/),
-                data: {
-                  'http.response.status_code': 404,
-                  url: expect.stringMatching(/\/does-not-exist$/),
-                  'http.method': 'GET',
-                  // FIXME: This is wrong :(
-                  'http.route': '/',
-                  'http.url': expect.stringMatching(/\/does-not-exist$/),
-                  'http.target': '/does-not-exist',
-                },
-                op: 'http.server',
-                status: 'not_found',
-              },
-            },
           },
         })
         .start();
       runner.makeRequest('get', '/does-not-exist', { expectError: true });
+      runner.makeRequest('get', '/');
       await runner.completed();
     });
 
@@ -324,4 +308,57 @@ describe('express tracing', () => {
       });
     });
   });
+
+  describe('filter status codes', () => {
+    createEsmAndCjsTests(
+      __dirname,
+      'scenario-filterStatusCode.mjs',
+      'instrument-filterStatusCode.mjs',
+      (createRunner, test) => {
+        // We opt-out of the default 404 filtering in order to test how 404 spans are handled
+        test('handles 404 route correctly', async () => {
+          const runner = createRunner()
+            .expect({
+              transaction: {
+                // FIXME: This is incorrect, sadly :(
+                transaction: 'GET /',
+                contexts: {
+                  trace: {
+                    span_id: expect.stringMatching(/[a-f0-9]{16}/),
+                    trace_id: expect.stringMatching(/[a-f0-9]{32}/),
+                    data: {
+                      'http.response.status_code': 404,
+                      url: expect.stringMatching(/\/does-not-exist$/),
+                      'http.method': 'GET',
+                      'http.url': expect.stringMatching(/\/does-not-exist$/),
+                      'http.target': '/does-not-exist',
+                    },
+                    op: 'http.server',
+                    status: 'not_found',
+                  },
+                },
+              },
+            })
+            .start();
+          runner.makeRequest('get', '/does-not-exist', { expectError: true });
+          await runner.completed();
+        });
+
+        test('filters defined status codes', async () => {
+          const runner = createRunner()
+            .expect({
+              transaction: {
+                transaction: 'GET /',
+              },
+            })
+            .start();
+          await runner.makeRequest('get', '/499', { expectError: true });
+          await runner.makeRequest('get', '/300', { expectError: true });
+          await runner.makeRequest('get', '/399', { expectError: true });
+          await runner.makeRequest('get', '/');
+          await runner.completed();
+        });
+      },
+    );
+  });
 });
diff --git a/packages/node/src/integrations/http/index.ts b/packages/node/src/integrations/http/index.ts
@@ -73,6 +73,14 @@ interface HttpOptions {
    */
   ignoreIncomingRequests?: (urlPath: string, request: IncomingMessage) => boolean;
 
+  /**
+   * Do not capture spans for incoming HTTP requests with the given status codes.
+   * By default, spans with 404 status code are ignored.
+   *
+   * @default `[404]`
+   */
+  dropSpansForIncomingRequestStatusCodes?: (number | RegExp)[];
+
   /**
    * Do not capture the request body for incoming HTTP requests to URLs where the given callback returns `true`.
    * This can be useful for long running requests where the body is not needed and we want to avoid capturing it.
@@ -148,6 +156,8 @@ export function _shouldInstrumentSpans(options: HttpOptions, clientOptions: Part
  * It creates breadcrumbs and spans for outgoing HTTP requests which will be attached to the currently active span.
  */
 export const httpIntegration = defineIntegration((options: HttpOptions = {}) => {
+  const dropSpansForIncomingRequestStatusCodes = options.dropSpansForIncomingRequestStatusCodes ?? [404];
+
   return {
     name: INTEGRATION_NAME,
     setupOnce() {
@@ -180,6 +190,22 @@ export const httpIntegration = defineIntegration((options: HttpOptions = {}) =>
         instrumentOtelHttp(instrumentationConfig);
       }
     },
+    processEvent(event) {
+      // Drop transaction if it has a status code that should be ignored
+      if (event.type === 'transaction') {
+        const statusCode = event.contexts?.trace?.data?.['http.response.status_code'];
+        if (
+          typeof statusCode === 'number' &&
+          dropSpansForIncomingRequestStatusCodes.some(code =>
+            typeof code === 'number' ? code === statusCode : code.test(statusCode.toString()),
+          )
+        ) {
+          return null;
+        }
+      }
+
+      return event;
+    },
   };
 });
 
