ref(node): Avoid double wrapping http module for vercel-edge

Author: mydea

packages/node/src/integrations/http/SentryHttpInstrumentation.ts

@@ -1,3 +1,4 @@
+/* eslint-disable max-lines */
 import { subscribe } from 'node:diagnostics_channel';
 import type * as http from 'node:http';
 import type { EventEmitter } from 'node:stream';
@@ -9,6 +10,7 @@ import type { AggregationCounts, Client, SanitizedRequestData, Scope } from '@se
 import {
   addBreadcrumb,
   addNonEnumerableProperty,
+  flush,
   generateSpanId,
   getBreadcrumbLogLevelFromHttpStatusCode,
   getClient,
@@ -19,6 +21,7 @@ import {
   logger,
   parseUrl,
   stripUrlQueryAndFragment,
+  vercelWaitUntil,
   withIsolationScope,
 } from '@sentry/core';
 import { DEBUG_BUILD } from '../../debug-build';
@@ -114,6 +117,14 @@ export class SentryHttpInstrumentation extends InstrumentationBase<SentryHttpIns
       this._onOutgoingRequestFinish(request, response);
     });
 
+    // On vercel, ensure that we flush events before the lambda freezes
+    if (process.env.VERCEL) {
+      subscribe('http.server.response.created', data => {
+        const response = (data as { response: http.ServerResponse }).response;
+        patchResponseToFlushOnServerlessPlatforms(response);
+      });
+    }
+
     return [];
   }
 
@@ -458,3 +469,54 @@ const clientToRequestSessionAggregatesMap = new Map<
   Client,
   { [timestampRoundedToSeconds: string]: { exited: number; crashed: number; errored: number } }
 >();
+
+function patchResponseToFlushOnServerlessPlatforms(res: http.OutgoingMessage): void {
+  // Freely extend this function with other platforms if necessary
+  if (process.env.VERCEL) {
+    // In some cases res.end does not seem to be defined leading to errors if passed to Proxy
+    // https://github.com/getsentry/sentry-javascript/issues/15759
+    if (typeof res.end === 'function') {
+      let markOnEndDone = (): void => undefined;
+      const onEndDonePromise = new Promise<void>(res => {
+        markOnEndDone = res;
+      });
+
+      res.on('close', () => {
+        markOnEndDone();
+      });
+
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      res.end = new Proxy(res.end, {
+        apply(target, thisArg, argArray) {
+          vercelWaitUntil(
+            new Promise<void>(finishWaitUntil => {
+              // Define a timeout that unblocks the lambda just to be safe so we're not indefinitely keeping it alive, exploding server bills
+              const timeout = setTimeout(() => {
+                finishWaitUntil();
+              }, 2000);
+
+              onEndDonePromise
+                .then(() => {
+                  DEBUG_BUILD && logger.log('Flushing events before Vercel Lambda freeze');
+                  return flush(2000);
+                })
+                .then(
+                  () => {
+                    clearTimeout(timeout);
+                    finishWaitUntil();
+                  },
+                  e => {
+                    clearTimeout(timeout);
+                    DEBUG_BUILD && logger.log('Error while flushing events for Vercel:\n', e);
+                    finishWaitUntil();
+                  },
+                );
+            }),
+          );
+
+          return target.apply(thisArg, argArray);
+        },
+      });
+    }
+  }
+}

packages/node/src/integrations/http/SentryHttpInstrumentationBeforeOtel.ts

@@ -12,7 +12,6 @@ import { addOriginToSpan } from '../../utils/addOriginToSpan';
 import { getRequestUrl } from '../../utils/getRequestUrl';
 import type { SentryHttpInstrumentationOptions } from './SentryHttpInstrumentation';
 import { SentryHttpInstrumentation } from './SentryHttpInstrumentation';
-import { SentryHttpInstrumentationBeforeOtel } from './SentryHttpInstrumentationBeforeOtel';
 
 const INTEGRATION_NAME = 'Http';
 
@@ -108,10 +107,6 @@ interface HttpOptions {
   };
 }
 
-const instrumentSentryHttpBeforeOtel = generateInstrumentOnce(`${INTEGRATION_NAME}.sentry-before-otel`, () => {
-  return new SentryHttpInstrumentationBeforeOtel();
-});
-
 const instrumentSentryHttp = generateInstrumentOnce<SentryHttpInstrumentationOptions>(
   `${INTEGRATION_NAME}.sentry`,
   options => {
@@ -151,18 +146,6 @@ export const httpIntegration = defineIntegration((options: HttpOptions = {}) =>
   return {
     name: INTEGRATION_NAME,
     setupOnce() {
-      // Below, we instrument the Node.js HTTP API three times. 2 times Sentry-specific, 1 time OTEL specific.
-      // Due to timing reasons, we sometimes need to apply Sentry instrumentation _before_ we apply the OTEL
-      // instrumentation (e.g. to flush on serverless platforms), and sometimes we need to apply Sentry instrumentation
-      // _after_ we apply OTEL instrumentation (e.g. for isolation scope handling and breadcrumbs).
-
-      // This is Sentry-specific instrumentation that is applied _before_ any OTEL instrumentation.
-      if (process.env.VERCEL) {
-        // Currently this instrumentation only does something when deployed on Vercel, so to save some overhead, we short circuit adding it here only for Vercel.
-        // If it's functionality is extended in the future, feel free to remove the if statement and this comment.
-        instrumentSentryHttpBeforeOtel();
-      }
-
       const instrumentSpans = _shouldInstrumentSpans(options, getClient<NodeClient>()?.getOptions());
 
       // This is the "regular" OTEL instrumentation that emits spans
@@ -171,7 +154,8 @@ export const httpIntegration = defineIntegration((options: HttpOptions = {}) =>
         instrumentOtelHttp(instrumentationConfig);
       }
 
-      // This is Sentry-specific instrumentation that is applied _after_ any OTEL instrumentation.
+      // This is Sentry-specific instrumentation
+      // It uses diagnostics channel, so it does not rely on import-in-the-middle or similar shenanigans
       instrumentSentryHttp({
         ...options,
         // If spans are not instrumented, it means the HttpInstrumentation has not been added