fix(sentry): filter TransformStream noise and close E2E detection gap for on_request_error events (#1145)

Add TransformStream 'transformAlgorithm is not a function' to
isNextjsInternalNoise — a known Node.js web streams race condition
during SSR with no app code in the stack trace.

Add isolation scope fallback to isE2ETestRequest. Next.js's
captureRequestError sets request headers in sdkProcessingMetadata
but not in event.request, and event.contexts.browser is enriched
by Sentry's ingestion pipeline after beforeSend runs. The new
fallback reads the scope's normalizedRequest headers directly.

Closes #1144

Co-authored-by: Ona <no-reply@ona.com>

Author: sw-factory-automations

.agents/conventions.md

@@ -480,15 +480,21 @@ filter these out:
   initialization (the SDK is loaded via dynamic `import()` in
   `instrumentation-client.ts`).
 - **Server-side** — `sentry.server.config.ts` and `sentry.edge.config.ts` use
-  `isE2ETestRequest(event)` which checks two sources:
+  `isE2ETestRequest(event)` which checks four sources:
   1. `event.request.headers` for `HeadlessChrome/` in the User-Agent — works for
      unhandled exceptions where Sentry auto-attaches request context.
   2. `event.contexts.browser.name` for `HeadlessChrome` — fallback for manually
      captured exceptions (via `captureException`/`lazyCaptureException`) where
      `event.request` is empty but the SDK enriches browser context.
-
-  Both checks are needed because manually captured exceptions skip request
-  header enrichment. Always check both paths when filtering E2E test noise.
+  3. `event.extra.userAgent` for `HeadlessChrome/` — fallback for errors captured
+     via `captureSupabaseError`/`captureApiError` which forward the request UA.
+  4. Isolation scope's `sdkProcessingMetadata.normalizedRequest.headers` — fallback
+     for `on_request_error` events (Next.js `captureRequestError`) where
+     `event.request` is null and `event.contexts.browser` is only populated by
+     Sentry's ingestion pipeline after `beforeSend` runs.
+
+  All four checks are needed because different capture mechanisms populate
+  different fields. Always check all paths when filtering E2E test noise.
 
 When adding new Sentry config files or `beforeSend` filters, use the
 consolidated filter functions: `shouldDropClientEvent` for client-side and

src/lib/sentry/e2e-detection.ts

@@ -1,4 +1,5 @@
 import type { ErrorEvent } from "@sentry/nextjs";
+import { getIsolationScope } from "@sentry/nextjs";
 
 /**
  * Returns true when the current browser session is an E2E test run.
@@ -62,5 +63,36 @@ export function isE2ETestRequest(event: ErrorEvent): boolean {
   const extraUa = event.extra?.userAgent;
   if (typeof extraUa === "string" && extraUa.includes("HeadlessChrome/")) return true;
 
+  // Fallback: check the isolation scope's normalizedRequest headers.
+  // Next.js's `captureRequestError` (on_request_error hook) sets request
+  // headers in sdkProcessingMetadata.normalizedRequest but does NOT populate
+  // event.request — the requestDataIntegration applies it after beforeSend.
+  // event.contexts.browser is also unavailable because Sentry's ingestion
+  // pipeline enriches it after the SDK sends the event.
+  if (isE2ETestFromScope()) return true;
+
   return false;
 }
+
+/**
+ * Checks the current isolation scope's normalizedRequest headers for
+ * HeadlessChrome. This catches on_request_error events where event.request
+ * is null and event.contexts.browser is not yet populated.
+ */
+function isE2ETestFromScope(): boolean {
+  try {
+    const scopeData = getIsolationScope().getScopeData();
+    const headers = scopeData.sdkProcessingMetadata?.normalizedRequest?.headers;
+    if (!headers) return false;
+
+    const scopeUa =
+      (headers as Record<string, string>)["user-agent"] ??
+      (headers as Record<string, string>)["User-Agent"] ??
+      "";
+    return scopeUa.includes("HeadlessChrome/");
+  } catch (_err: unknown) {
+    // getIsolationScope may not be available in all contexts (e.g. tests).
+    // Swallowing is intentional — this is a best-effort detection fallback.
+    return false;
+  }
+}

src/lib/sentry/event-filters.ts

@@ -1,12 +1,17 @@
 import type { ErrorEvent } from "@sentry/nextjs";
 
 /**
- * Error messages from Next.js internals that are caused by clients sending
- * malformed headers (e.g. RSC router state). These are not application bugs —
- * they originate from bots, crawlers, or browser quirks (Mobile Safari 17).
+ * Error messages from Next.js/Node.js internals that are not application bugs.
+ * Includes malformed client headers (bots, crawlers, Mobile Safari 17) and
+ * Node.js web streams race conditions during SSR.
  */
 const NEXTJS_INTERNAL_NOISE_PATTERNS = [
   "The router state header was sent but could not be parsed",
+  // Node.js internal web streams race condition during SSR. The TransformStream
+  // controller's state is torn down before the transform algorithm runs.
+  // Known issue: vercel/next.js#68319, vercel/next.js#75994.
+  // Stack trace contains only Node.js internals — no app code is involved.
+  "transformAlgorithm is not a function",
 ];
 
 /**

src/lib/sentry/sentry.unit.test.ts

@@ -4,8 +4,14 @@ import { PostgrestError } from "@supabase/supabase-js";
 
 const captureExceptionMock = vi.fn();
 
+// Mock isolation scope for isE2ETestFromScope tests
+let mockScopeData: Record<string, unknown> = {};
+
 vi.mock("@sentry/nextjs", () => ({
   captureException: (...args: unknown[]) => captureExceptionMock(...args),
+  getIsolationScope: () => ({
+    getScopeData: () => mockScopeData,
+  }),
 }));
 
 import {
@@ -1030,6 +1036,27 @@ describe("isNextjsInternalNoise", () => {
     const event = makeSentryEvent([{ type: "Error" }]);
     expect(isNextjsInternalNoise(event)).toBe(false);
   });
+
+  it("detects Node.js TransformStream race condition (MEMO-2G)", () => {
+    const event = makeSentryEvent([
+      {
+        type: "TypeError",
+        value: "controller[kState].transformAlgorithm is not a function",
+      },
+    ]);
+    expect(isNextjsInternalNoise(event)).toBe(true);
+  });
+
+  it("detects TransformStream error as substring in chained exceptions", () => {
+    const event = makeSentryEvent([
+      { type: "Error", value: "Some wrapper error" },
+      {
+        type: "TypeError",
+        value: "controller[kState].transformAlgorithm is not a function",
+      },
+    ]);
+    expect(isNextjsInternalNoise(event)).toBe(true);
+  });
 });
 
 /**
@@ -1667,6 +1694,65 @@ describe("isE2ETestRequest", () => {
     } as unknown as ErrorEvent;
     expect(isE2ETestRequest(event)).toBe(false);
   });
+
+  it("returns true when isolation scope has HeadlessChrome in normalizedRequest headers (MEMO-2G on_request_error)", () => {
+    mockScopeData = {
+      sdkProcessingMetadata: {
+        normalizedRequest: {
+          headers: {
+            "user-agent": "Mozilla/5.0 HeadlessChrome/147.0.0.0 Safari/537.36",
+          },
+        },
+      },
+    };
+    const event = { type: undefined } as ErrorEvent;
+    expect(isE2ETestRequest(event)).toBe(true);
+    mockScopeData = {};
+  });
+
+  it("returns true when isolation scope has HeadlessChrome in User-Agent (capitalized)", () => {
+    mockScopeData = {
+      sdkProcessingMetadata: {
+        normalizedRequest: {
+          headers: {
+            "User-Agent": "Mozilla/5.0 HeadlessChrome/147.0.0.0 Safari/537.36",
+          },
+        },
+      },
+    };
+    const event = { type: undefined } as ErrorEvent;
+    expect(isE2ETestRequest(event)).toBe(true);
+    mockScopeData = {};
+  });
+
+  it("returns false when isolation scope has normal Chrome in normalizedRequest headers", () => {
+    mockScopeData = {
+      sdkProcessingMetadata: {
+        normalizedRequest: {
+          headers: {
+            "user-agent": "Mozilla/5.0 Chrome/147.0.0.0 Safari/537.36",
+          },
+        },
+      },
+    };
+    const event = { type: undefined } as ErrorEvent;
+    expect(isE2ETestRequest(event)).toBe(false);
+    mockScopeData = {};
+  });
+
+  it("returns false when isolation scope has no normalizedRequest", () => {
+    mockScopeData = { sdkProcessingMetadata: {} };
+    const event = { type: undefined } as ErrorEvent;
+    expect(isE2ETestRequest(event)).toBe(false);
+    mockScopeData = {};
+  });
+
+  it("returns false when isolation scope has no sdkProcessingMetadata", () => {
+    mockScopeData = {};
+    const event = { type: undefined } as ErrorEvent;
+    expect(isE2ETestRequest(event)).toBe(false);
+    mockScopeData = {};
+  });
 });
 
 describe("shouldDropServerEvent", () => {
@@ -1734,4 +1820,39 @@ describe("shouldDropServerEvent", () => {
     } as unknown as ErrorEvent;
     expect(shouldDropServerEvent(event)).toBe(false);
   });
+
+  it("drops Node.js TransformStream race condition errors (MEMO-2G)", () => {
+    const event = {
+      type: undefined,
+      exception: {
+        values: [
+          {
+            type: "TypeError",
+            value: "controller[kState].transformAlgorithm is not a function",
+          },
+        ],
+      },
+    } as unknown as ErrorEvent;
+    expect(shouldDropServerEvent(event)).toBe(true);
+  });
+
+  it("drops on_request_error events from E2E tests via isolation scope (MEMO-2G)", () => {
+    mockScopeData = {
+      sdkProcessingMetadata: {
+        normalizedRequest: {
+          headers: {
+            "user-agent": "Mozilla/5.0 HeadlessChrome/147.0.0.0 Safari/537.36",
+          },
+        },
+      },
+    };
+    const event = {
+      type: undefined,
+      exception: {
+        values: [{ value: "Some server error" }],
+      },
+    } as unknown as ErrorEvent;
+    expect(shouldDropServerEvent(event)).toBe(true);
+    mockScopeData = {};
+  });
 });