ref(deno): Use a shared request handler wrapper for Deno.serve

Deno.serve, Bun.serve and Cloudflare each wrap a web `Request` handler
with their own copy of the same steps: request data and body, the
`http.server` span, streamed responses, errors and sessions. The copies
drift, so a fix in one runtime does not reach the others.

This adds `wrapServerRequestHandler` to `@sentry/server-utils` and
moves `Deno.serve` onto it. Bun.serve and Cloudflare follow in separate
PRs, so each runtime's changes can be reviewed alone. The wrapper has
only what Deno needs today, and the next PRs extend it. It is exported
from the shared entry, so the Node-free
`@sentry/server-utils/no-diagnostic-channels` entry can use it too.

The rules follow core's `node:http` server code. `OPTIONS` and `HEAD`
requests get no span and no body capture, but still get request data,
a session and error capture. The static asset filter applies only to
`GET`. For streamed responses, the wrapper uses the stream monitor from
the Bun SDK, which reads only when the client pulls and reports errors
from the stream source. It replaces Deno's own copy, which read ahead
of the client and ignored source errors.

The existing Deno tests pass with no change. Visible changes for Deno:

- An error from the source of a streamed response is now captured, and
  the span gets an error status.
- The SDK no longer reads a streamed response ahead of the client.
- Errors in `OPTIONS` and `HEAD` requests now carry the request data.
- `client.address` is no longer set to the path of a Unix socket.

Part of #25577
Part of JS-3975

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: isaacs

CHANGELOG.md

@@ -96,6 +96,14 @@ Work in this release was contributed by @adityareddy-dev, @jpdefo, @Jxxunnn, @ph
 
   When an instrumented package loaded after `init()` (for example through a dynamic `import()`), the SDK added its integration even if the user had removed it. This applied to an `integrations` function that filtered it out, `defaultIntegrations: false`, and a custom `defaultIntegrations` list. The SDK now applies the same rules to a late-loaded integration as to the defaults at `init()`. To do this, it calls an `integrations` function again, once for each package that loads after `init()`.
 
+- **ref(deno): Use the shared request handler wrapper for `Deno.serve`**
+
+  `Deno.serve` now uses a request handler wrapper that `Bun.serve` and Cloudflare will also use. Three small changes for Deno users:
+
+  - When the source of a streamed response fails, the SDK now captures the error and marks the span as failed.
+  - The SDK no longer reads a streamed response ahead of the client.
+  - Errors in `OPTIONS` and `HEAD` requests now carry the request data.
+
 ## 11.8.0
 
 ### Important Changes

packages/deno/src/utils/streaming.ts

@@ -1,87 +1,14 @@
-import {
-  CLIENT_ADDRESS,
-  CLIENT_PORT,
-  NETWORK_PROTOCOL_NAME,
-  SENTRY_OP,
-  SENTRY_SEGMENT_NAME_SOURCE,
-} from '@sentry/conventions/attributes';
-import { HTTP_SERVER } from '@sentry/conventions/op';
-import type { Client, Integration } from '@sentry/core';
-import {
-  captureBodyFromWinterCGRequest,
-  captureException,
-  continueTrace,
-  debug,
-  getClient,
-  getHttpSpanDetailsFromUrlObject,
-  hasSpansEnabled,
-  hasSpanStreamingEnabled,
-  httpHeadersToSpanAttributes,
-  HTTP_SPAN_NAME_FALLBACK,
-  parseStringToURLObject,
-  setHttpStatus,
-  startSpanManual,
-  winterCGHeadersToDict,
-  winterCGRequestToRequestData,
-  withIsolationScope,
-} from '@sentry/core';
-import { getClientIPAddress, isStaticAssetRequest, startRequestSession } from '@sentry/core/server';
+import type { Integration } from '@sentry/core';
+import { debug, getClient, withIsolationScope } from '@sentry/core';
+import { wrapServerRequestHandler } from '@sentry/server-utils';
 import type { DenoServeIntegrationOptions } from './integrations/deno-serve';
-import { streamResponse } from './utils/streaming';
 
 export type RequestHandlerWrapperOptions<Addr extends Deno.Addr> = {
   request: Request;
   info: Deno.ServeHandlerInfo<Addr>;
   serveOptions?: Deno.ServeOptions<Addr>;
 };
 
-function captureServeError(e: unknown): void {
-  captureException(e, {
-    mechanism: {
-      handled: false,
-      type: 'auto.http.deno',
-      data: { function: 'serve' },
-    },
-  });
-}
-
-// A user callback that throws must not fail the request or leave the span open.
-function callUserCallback<T>(name: string, callback: () => T, fallback: T): T {
-  try {
-    return callback();
-  } catch (e) {
-    debug.error(`Error in the Deno.serve ${name} callback.`, e);
-    return fallback;
-  }
-}
-
-function shouldCreateSpan(
-  client: Client,
-  integration: DenoServeIntegrationOptions | undefined,
-  request: Request,
-  urlPath: string,
-): boolean {
-  if (!(integration?.spans ?? hasSpansEnabled(client.getOptions()))) {
-    return false;
-  }
-  if (integration?.ignoreStaticAssets && request.method === 'GET' && isStaticAssetRequest(urlPath)) {
-    return false;
-  }
-  const ignoreIncomingRequests = integration?.ignoreIncomingRequests;
-  return !(
-    ignoreIncomingRequests &&
-    callUserCallback('ignoreIncomingRequests', () => ignoreIncomingRequests(urlPath, request), false)
-  );
-}
-
-const assignIfSet = <T extends Record<string, unknown>, K extends keyof T>(
-  obj: T,
-  key: K,
-  value: T[K] | undefined | null,
-): void => {
-  if (value !== undefined && value !== null) obj[key] = value;
-};
-
 export const wrapDenoRequestHandler = <Addr extends Deno.Addr = Deno.Addr>(
   wrapperOptions: RequestHandlerWrapperOptions<Addr>,
   handler: () => Promise<Response> | Response,
@@ -100,140 +27,20 @@ export const wrapDenoRequestHandler = <Addr extends Deno.Addr = Deno.Addr>(
     }
     isolationScope.setClient(client);
 
-    const integration = client.getIntegrationByName<Integration & DenoServeIntegrationOptions>('DenoServe');
-    const endSession = integration?.sessions
-      ? startRequestSession(client, {
-          requestIsolationScope: isolationScope,
-          sessionFlushingDelayMS: integration.sessionFlushingDelayMS,
-        })
-      : undefined;
-
-    if (request.method === 'OPTIONS' || request.method === 'HEAD') {
-      try {
-        return await handler();
-      } catch (e) {
-        captureServeError(e);
-        throw e;
-      } finally {
-        endSession?.();
-      }
-    }
-
-    const urlObject = parseStringToURLObject(request.url);
-    const [rawName, attributes] = getHttpSpanDetailsFromUrlObject(
-      urlObject,
-      'server',
-      'auto.http.deno',
-      request,
-      undefined,
-      client,
-    );
-    // With span streaming, span names have to be low cardinality, so we can't fall back to the URL.
-    // A `route` source means the name already is (e.g. the `/` path), so it is kept as-is.
-    const name =
-      attributes[SENTRY_SEGMENT_NAME_SOURCE] === 'route' || !hasSpanStreamingEnabled(client)
-        ? rawName
-        : request.method?.toUpperCase() || HTTP_SPAN_NAME_FALLBACK;
-
-    const contentLength = request.headers.get('content-length');
-    assignIfSet(attributes, 'http.request.body.size', contentLength && parseInt(contentLength, 10));
-    assignIfSet(attributes, 'user_agent.original', request.headers.get('user-agent'));
-
-    const headers = winterCGHeadersToDict(request.headers);
-    const socketIp = (info?.remoteAddr as Deno.NetAddr)?.hostname;
-    const dataCollection = client.getDataCollectionOptions();
-    if (dataCollection.userInfo) {
-      // `client.address` is the originating client, so a forwarding header wins over the socket, which
-      // behind a proxy holds the proxy's address. The socket port is the proxy's too, so `client.port`
-      // stays unset then.
-      const forwardedAddress = getClientIPAddress(headers);
-      assignIfSet(
-        attributes,
-        CLIENT_ADDRESS,
-        forwardedAddress || socketIp || (info?.remoteAddr as Deno.UnixAddr)?.path,
-      );
-      if (!forwardedAddress) {
-        assignIfSet(attributes, CLIENT_PORT, (info?.remoteAddr as Deno.NetAddr)?.port);
-      }
-    }
-
-    // describes the OSI application-layer protocol (http), not the scheme (might be https)
-    attributes[NETWORK_PROTOCOL_NAME] = 'http';
-
-    Object.assign(attributes, httpHeadersToSpanAttributes(headers, dataCollection));
-    attributes[SENTRY_OP] = HTTP_SERVER;
-    isolationScope.setSDKProcessingMetadata({
-      normalizedRequest: winterCGRequestToRequestData(request),
-      ipAddress: socketIp,
-    });
-
-    const effectiveBodySize =
-      integration?.maxRequestBodySize ?? (dataCollection.httpBodies.includes('incomingRequest') ? 'medium' : 'none');
-    const ignoreRequestBody = integration?.ignoreRequestBody;
-    if (
-      request.method !== 'GET' &&
-      effectiveBodySize !== 'none' &&
-      // If the filter throws, skip the body so it cannot leak data the filter was meant to hide.
-      !(ignoreRequestBody && callUserCallback('ignoreRequestBody', () => ignoreRequestBody(request.url, request), true))
-    ) {
-      await captureBodyFromWinterCGRequest(request, isolationScope, effectiveBodySize);
-    }
-
-    const urlPath = urlObject ? `${urlObject.pathname}${urlObject.search}` : '/';
-    const createSpan = shouldCreateSpan(client, integration, request, urlPath);
-
-    return continueTrace(
+    return wrapServerRequestHandler(
       {
-        sentryTrace: request.headers.get('sentry-trace') || '',
-        baggage: request.headers.get('baggage'),
-      },
-      async () => {
-        if (!createSpan) {
-          let res: Response;
-          try {
-            res = await handler();
-            isolationScope.setContext('response', {
-              status_code: res.status,
-            });
-          } catch (e) {
-            captureServeError(e);
-            endSession?.();
-            throw e;
-          }
-          return endSession ? streamResponse(undefined, res, endSession) : res;
-        }
-
-        return startSpanManual({ name, attributes }, async span => {
-          const { onSpanCreated, onSpanEnd } = integration ?? {};
-          if (onSpanCreated) {
-            callUserCallback('onSpanCreated', () => onSpanCreated(span, request), undefined);
-          }
-          let res: Response;
-
-          try {
-            res = await handler();
-            setHttpStatus(span, res.status);
-            isolationScope.setContext('response', {
-              status_code: res.status,
-            });
-            span.setAttributes(
-              httpHeadersToSpanAttributes(Object.fromEntries(res.headers), dataCollection, 'response'),
-            );
-          } catch (e) {
-            span.end();
-            captureServeError(e);
-            endSession?.();
-            throw e;
-          }
-
-          return streamResponse(span, res, () => {
-            if (onSpanEnd) {
-              callUserCallback('onSpanEnd', () => onSpanEnd(span, request, res), undefined);
-            }
-            endSession?.();
-          });
-        });
+        request,
+        client,
+        isolationScope,
+        options: client.getIntegrationByName<Integration & DenoServeIntegrationOptions>('DenoServe'),
+        origin: 'auto.http.deno',
+        mechanism: { handled: false, type: 'auto.http.deno', data: { function: 'serve' } },
+        getSocketAddress: () => {
+          const remoteAddr = info?.remoteAddr as Deno.NetAddr | undefined;
+          return remoteAddr?.hostname ? { address: remoteAddr.hostname, port: remoteAddr.port } : undefined;
+        },
       },
+      handler,
     );
   });
 };

packages/deno/src/wrap-deno-request-handler.ts

@@ -866,6 +866,46 @@ Deno.test('Deno.serve should handle streaming responses', async () => {
   assertEquals(transactionEvents[0]?.contexts?.trace?.op, 'http.server');
 });
 
+Deno.test('Deno.serve should capture an error from a streamed response source', async () => {
+  resetGlobals();
+  const errorEvents: ErrorEvent[] = [];
+  const transactionEvents: TransactionEvent[] = [];
+
+  const client = init({
+    dsn: 'https://username@domain/123',
+    tracesSampleRate: 1,
+    traceLifecycle: 'static',
+    beforeSend: (event: ErrorEvent) => {
+      errorEvents.push(event);
+      return null;
+    },
+    beforeSendTransaction: (event: TransactionEvent) => {
+      transactionEvents.push(event);
+      return null;
+    },
+  }) as DenoClient;
+
+  const server = await serveForTest(() => {
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(new TextEncoder().encode('chunk1\n'));
+        setTimeout(() => controller.error(new Error('stream interrupted')), 10);
+      },
+    });
+    return new Response(stream, { headers: { 'content-type': 'text/event-stream' } });
+  });
+
+  const response = await fetch(`${server.url}/stream`);
+  await response.text().catch(() => undefined);
+  await server.close();
+  await client.flush();
+
+  assertEquals(errorEvents.length, 1);
+  assertEquals(errorEvents[0]?.exception?.values?.[0]?.value, 'stream interrupted');
+  assertEquals(errorEvents[0]?.exception?.values?.[0]?.mechanism?.type, 'auto.http.deno');
+  assertEquals(transactionEvents[0]?.contexts?.trace?.status, 'internal_error');
+});
+
 Deno.test('Deno.serve should work when manually capturing exceptions within handler', async () => {
   resetGlobals();
   const errorEvents: ErrorEvent[] = [];