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

Author: mydea

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

@@ -8,11 +8,10 @@ import { context, propagation } from '@opentelemetry/api';
 import { VERSION } from '@opentelemetry/core';
 import type { InstrumentationConfig } from '@opentelemetry/instrumentation';
 import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-import type { AggregationCounts, Client, SanitizedRequestData, Scope } from '@sentry/core';
-import {
-  addBreadcrumb,
+import type { AggregationCounts, Client, SanitizedRequestData, Scope} from '@sentry/core';
+import {   addBreadcrumb,
   addNonEnumerableProperty,
-  generateSpanId,
+flush,   generateSpanId,
   getBreadcrumbLogLevelFromHttpStatusCode,
   getClient,
   getCurrentScope,
@@ -22,6 +21,7 @@ import {
   logger,
   parseUrl,
   stripUrlQueryAndFragment,
+vercelWaitUntil ,
   withIsolationScope,
 } from '@sentry/core';
 import { DEBUG_BUILD } from '../../debug-build';
@@ -127,6 +127,11 @@ export class SentryHttpInstrumentation extends InstrumentationBase<SentryHttpIns
       this._onOutgoingRequestFinish(data.request, undefined);
     }) satisfies ChannelListener;
 
+    const onHttpServerResponseCreated = ((_data: unknown) => {
+      const data = _data as { response: http.OutgoingMessage };
+      patchResponseToFlushOnServerlessPlatformsOnce(data.response);
+    }) satisfies ChannelListener;
+
     /**
      * You may be wondering why we register these diagnostics-channel listeners
      * in such a convoluted way (as InstrumentationNodeModuleDefinition...)˝,
@@ -153,6 +158,11 @@ export class SentryHttpInstrumentation extends InstrumentationBase<SentryHttpIns
           // In this case, `http.client.response.finish` is not triggered
           subscribe('http.client.request.error', onHttpClientRequestError);
 
+          // On vercel, ensure that we flush events before the lambda freezes
+          if (process.env.VERCEL) {
+            subscribe('http.server.response.created', onHttpServerResponseCreated);
+          }
+
           return moduleExports;
         },
         () => {
@@ -178,6 +188,11 @@ export class SentryHttpInstrumentation extends InstrumentationBase<SentryHttpIns
           // In this case, `http.client.response.finish` is not triggered
           subscribe('http.client.request.error', onHttpClientRequestError);
 
+          // On vercel, ensure that we flush events before the lambda freezes
+          if (process.env.VERCEL) {
+            subscribe('http.server.response.created', onHttpServerResponseCreated);
+          }
+
           return moduleExports;
         },
         () => {
@@ -529,6 +544,66 @@ export function recordRequestSession({
   });
 }
 
+function patchResponseToFlushOnServerlessPlatformsOnce(res: http.OutgoingMessage): void {
+  // This means it was already patched, do nothing
+  if ((res as { __sentry_patched__?: boolean }).__sentry_patched__) {
+    return;
+  }
+
+  DEBUG_BUILD && logger.log(INSTRUMENTATION_NAME, 'Patching server.end()');
+  addNonEnumerableProperty(res, '__sentry_patched__', true);
+
+  // This is vercel specific handling to flush events before the lambda freezes
+
+  // 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') {
+    return;
+  }
+
+  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);
+    },
+  });
+}
+
 const clientToRequestSessionAggregatesMap = new Map<
   Client,
   { [timestampRoundedToSeconds: string]: { exited: number; crashed: number; errored: number } }

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,19 +146,6 @@ export const httpIntegration = defineIntegration((options: HttpOptions = {}) =>
   return {
     name: INTEGRATION_NAME,
     setupOnce() {
-      // TODO: get rid of this too
-      // 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 Sentry-specific instrumentation for request isolation and breadcrumbs