feat(deno): instrument Deno.serve with async context support

isaacs · isaacs · commit 4ff9de7f2b8f · 2026-02-08T12:17:52.000-08:00
diff --git a/packages/deno/src/async.ts b/packages/deno/src/async.ts
@@ -0,0 +1,81 @@
+// Need to use node: prefix for deno compatibility
+import { AsyncLocalStorage } from 'node:async_hooks';
+import type { Scope } from '@sentry/core';
+import { getDefaultCurrentScope, getDefaultIsolationScope, setAsyncContextStrategy } from '@sentry/core';
+
+/**
+ * Sets the async context strategy to use AsyncLocalStorage.
+ *
+ * @internal Only exported to be used in higher-level Sentry packages
+ * @hidden Only exported to be used in higher-level Sentry packages
+ */
+export function setAsyncLocalStorageAsyncContextStrategy(): void {
+  const asyncStorage = new AsyncLocalStorage<{
+    scope: Scope;
+    isolationScope: Scope;
+  }>();
+
+  function getScopes(): { scope: Scope; isolationScope: Scope } {
+    const scopes = asyncStorage.getStore();
+
+    if (scopes) {
+      return scopes;
+    }
+
+    // fallback behavior:
+    // if, for whatever reason, we can't find scopes on the context here, we have to fix this somehow
+    return {
+      scope: getDefaultCurrentScope(),
+      isolationScope: getDefaultIsolationScope(),
+    };
+  }
+
+  function withScope<T>(callback: (scope: Scope) => T): T {
+    const scope = getScopes().scope.clone();
+    const isolationScope = getScopes().isolationScope;
+    return asyncStorage.run({ scope, isolationScope }, () => {
+      return callback(scope);
+    });
+  }
+
+  function withSetScope<T>(scope: Scope, callback: (scope: Scope) => T): T {
+    const isolationScope = getScopes().isolationScope.clone();
+    return asyncStorage.run({ scope, isolationScope }, () => {
+      return callback(scope);
+    });
+  }
+
+  function withIsolationScope<T>(callback: (isolationScope: Scope) => T): T {
+    const scope = getScopes().scope;
+    const isolationScope = getScopes().isolationScope.clone();
+    return asyncStorage.run({ scope, isolationScope }, () => {
+      return callback(isolationScope);
+    });
+  }
+
+  function withSetIsolationScope<T>(isolationScope: Scope, callback: (isolationScope: Scope) => T): T {
+    const scope = getScopes().scope;
+    return asyncStorage.run({ scope, isolationScope }, () => {
+      return callback(isolationScope);
+    });
+  }
+
+  // In contrast to the browser, we can rely on async context isolation here
+  function suppressTracing<T>(callback: () => T): T {
+    return withScope(scope => {
+      scope.setSDKProcessingMetadata({ __SENTRY_SUPPRESS_TRACING__: true });
+      return callback();
+    });
+  }
+
+  setAsyncContextStrategy({
+    suppressTracing,
+    withScope,
+    withSetScope,
+    withIsolationScope,
+    withSetIsolationScope,
+    getCurrentScope: () => getScopes().scope,
+    getIsolationScope: () => getScopes().isolationScope,
+  });
+}
+
diff --git a/packages/deno/src/integrations/deno-serve.ts b/packages/deno/src/integrations/deno-serve.ts
@@ -0,0 +1,107 @@
+import { defineIntegration, getClient } from '@sentry/core';
+import type { IntegrationFn } from '@sentry/core';
+import { setAsyncLocalStorageAsyncContextStrategy } from '../async';
+import { DenoOptions } from '../types';
+import { wrapDenoRequestHandler } from '../wrap-deno-request-handler';
+
+export type RequestHandlerWrapperOptions<Addr extends Deno.Addr> = {
+  request: Request;
+  options: DenoOptions;
+  info: Deno.ServeHandlerInfo<Addr>;
+  serveOptions?: Deno.ServeOptions<Addr>;
+};
+
+const INTEGRATION_NAME = 'DenoServe';
+
+export type ServeParams =
+  // [(Request) => Response]
+  | [Deno.ServeHandler<Deno.NetAddr>]
+  // [{ options }, (Request) => Response]
+  | [Deno.ServeUnixOptions, Deno.ServeHandler<Deno.UnixAddr>]
+  | [Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem), Deno.ServeHandler<Deno.NetAddr>]
+  // [{ handler: (Request) => Response }]
+  | [Deno.ServeUnixOptions & Deno.ServeInit<Deno.UnixAddr>]
+  | [(Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem)) & Deno.ServeInit<Deno.NetAddr>];
+
+const isServeOptWithFunction = (
+  p: ServeParams,
+): p is
+  | [Deno.ServeUnixOptions, Deno.ServeHandler<Deno.UnixAddr>]
+  | [Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem), Deno.ServeHandler<Deno.NetAddr>] =>
+  p.length >= 2 && typeof p[1] === 'function' && !!p[0] && typeof p[0] === 'object';
+
+const isServeInitOptions = (
+  p: ServeParams,
+): p is
+  | [Deno.ServeUnixOptions & Deno.ServeInit<Deno.UnixAddr>]
+  | [(Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem)) & Deno.ServeInit<Deno.NetAddr>] =>
+  typeof p[0] === 'object' &&
+  !!p[0] &&
+  !isServeOptWithFunction(p) &&
+  'handler' in p[0] &&
+  typeof p[0].handler === 'function';
+
+const isSimpleServeHandler = (p: ServeParams): p is [Deno.ServeHandler<Deno.NetAddr>] => typeof p[0] === 'function';
+
+const isServeUnixHandler = (p: ServeParams): p is [Deno.ServeUnixOptions, Deno.ServeHandler<Deno.UnixAddr>] =>
+  isServeOptWithFunction(p) && 'path' in p[0] && typeof p[0].path === 'string';
+
+const isServeTcpHandler = (
+  p: ServeParams,
+): p is [Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem), Deno.ServeHandler<Deno.NetAddr>] =>
+  isServeOptWithFunction(p) && (!('path' in p[0]) || typeof p[0].path !== 'string');
+
+const isServeUnixInit = (p: ServeParams): p is [Deno.ServeUnixOptions & Deno.ServeInit<Deno.UnixAddr>] =>
+  isServeInitOptions(p) && 'path' in p[0] && typeof p[0].path === 'string';
+
+const isServeTcpInit = (
+  p: ServeParams,
+): p is [(Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem)) & Deno.ServeInit<Deno.NetAddr>] =>
+  isServeInitOptions(p) && (!('path' in p[0]) || typeof p[0].path !== 'string');
+
+
+const applyHandlerWrap =
+  <A extends Deno.Addr>(
+    handler: Deno.ServeHandler<A>,
+    options: DenoOptions,
+    serveOptions?: Deno.ServeOptions<A>,
+  ): Deno.ServeHandler<A> =>
+  async (request, info) =>
+    await wrapDenoRequestHandler<A>(
+      {
+        options,
+        request,
+        info,
+        serveOptions,
+      },
+      () => handler(request, info),
+    );
+
+const _denoServeIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      setAsyncLocalStorageAsyncContextStrategy();
+      Deno.serve = new Proxy(Deno.serve, {
+        apply(target, thisArg, args: ServeParams) {
+          const options: DenoOptions = getClient()?.getOptions() ?? {};
+          if (isSimpleServeHandler(args)) {
+            args[0] = applyHandlerWrap(args[0], options);
+          } else if (isServeUnixHandler(args)) {
+            args[1] = applyHandlerWrap(args[1], options, args[0]);
+          } else if (isServeTcpHandler(args)) {
+            args[1] = applyHandlerWrap(args[1], options, args[0]);
+          } else if (isServeUnixInit(args)) {
+            args[0].handler = applyHandlerWrap(args[0].handler, options, args[0]);
+          } else if (isServeTcpInit(args)) {
+            args[0].handler = applyHandlerWrap(args[0].handler, options, args[0]);
+          }
+          // if none of those matched, it'll crash, most likely.
+          return target.apply(thisArg, args);
+        },
+      });
+    },
+  };
+}) satisfies IntegrationFn;
+
+export const denoServeIntegration = defineIntegration(_denoServeIntegration);
diff --git a/packages/deno/src/sdk.ts b/packages/deno/src/sdk.ts
@@ -13,6 +13,7 @@ import {
 import { DenoClient } from './client';
 import { breadcrumbsIntegration } from './integrations/breadcrumbs';
 import { denoContextIntegration } from './integrations/context';
+import { denoServeIntegration } from './integrations/deno-serve';
 import { contextLinesIntegration } from './integrations/contextlines';
 import { globalHandlersIntegration } from './integrations/globalhandlers';
 import { normalizePathsIntegration } from './integrations/normalizepaths';
@@ -34,6 +35,7 @@ export function getDefaultIntegrations(_options: Options): Integration[] {
     // Deno Specific
     breadcrumbsIntegration(),
     denoContextIntegration(),
+    denoServeIntegration(),
     contextLinesIntegration(),
     normalizePathsIntegration(),
     globalHandlersIntegration(),
diff --git a/packages/deno/src/transports/index.ts b/packages/deno/src/transports/index.ts
@@ -14,7 +14,7 @@ export function makeFetchTransport(options: BaseTransportOptions): Transport {
         consoleSandbox(() => {
           // eslint-disable-next-line no-console
           console.warn(`Sentry SDK requires 'net' permission to send events.
-    Run with '--allow-net=${url.host}' to grant the requires permissions.`);
+    Run with '--allow-net=${url.host}' to grant the required permissions.`);
         });
       }
     })
diff --git a/packages/deno/src/utils/streaming.ts b/packages/deno/src/utils/streaming.ts
@@ -0,0 +1,41 @@
+export type StreamingGuess = {
+  isStreaming: boolean;
+};
+
+/**
+ * Classifies a Response as streaming or non-streaming.
+ *
+ * Heuristics:
+ * - No body → not streaming
+ * - Known streaming Content-Types → streaming (SSE, NDJSON, JSON streaming)
+ * - text/plain without Content-Length → streaming (some AI APIs)
+ * - Otherwise → not streaming (conservative default, including HTML/SSR)
+ *
+ * We avoid probing the stream to prevent blocking on transform streams (like injectTraceMetaTags)
+ * or SSR streams that may not have data ready immediately.
+ */
+export function classifyResponseStreaming(res: Response): StreamingGuess {
+  if (!res.body) {
+    return { isStreaming: false };
+  }
+
+  const contentType = res.headers.get('content-type') ?? '';
+  const contentLength = res.headers.get('content-length');
+
+  // Streaming: Known streaming content types
+  // - text/event-stream: Server-Sent Events (Vercel AI SDK, real-time APIs)
+  // - application/x-ndjson, application/ndjson: Newline-delimited JSON
+  // - application/stream+json: JSON streaming
+  // - text/plain (without Content-Length): Some AI APIs use this for streaming text
+  if (
+    /^text\/event-stream\b/i.test(contentType) ||
+    /^application\/(x-)?ndjson\b/i.test(contentType) ||
+    /^application\/stream\+json\b/i.test(contentType) ||
+    (/^text\/plain\b/i.test(contentType) && !contentLength)
+  ) {
+    return { isStreaming: true };
+  }
+
+  // Default: treat as non-streaming
+  return { isStreaming: false };
+}
diff --git a/packages/deno/src/wrap-deno-request-handler.ts b/packages/deno/src/wrap-deno-request-handler.ts
@@ -0,0 +1,142 @@
+import {
+  continueTrace,
+  withIsolationScope,
+  startSpanManual,
+  parseStringToURLObject,
+  getHttpSpanDetailsFromUrlObject,
+  httpHeadersToSpanAttributes,
+  winterCGHeadersToDict,
+  SEMANTIC_ATTRIBUTE_SENTRY_OP,
+  winterCGRequestToRequestData,
+  captureException,
+  setHttpStatus,
+} from '@sentry/core';
+import { init } from './sdk';
+import { DenoOptions } from './types';
+import { classifyResponseStreaming } from './utils/streaming';
+
+export type RequestHandlerWrapperOptions<Addr extends Deno.Addr> = {
+  request: Request;
+  options: DenoOptions;
+  info: Deno.ServeHandlerInfo<Addr>;
+  serveOptions?: Deno.ServeOptions<Addr>;
+};
+
+const assignIfSet = <T extends Record<string, unknown>, K extends keyof T>(
+  obj: T,
+  key: K,
+  value: T[K] | undefined | null,
+) => {
+  if (value !== undefined && value !== null) obj[key] = value;
+}
+
+export const wrapDenoRequestHandler = <Addr extends Deno.Addr = Deno.Addr>(
+  wrapperOptions: RequestHandlerWrapperOptions<Addr>,
+  handler: () => Promise<Response> | Response,
+): Response | Promise<Response> => {
+  return withIsolationScope(async isolationScope => {
+    const { request, options, info } = wrapperOptions;
+
+    const client = init(options);
+    isolationScope.setClient(client);
+
+    if (request.method === 'OPTIONS' || request.method === 'HEAD') {
+      try {
+        return await handler();
+      } catch (e) {
+        captureException(e, {
+          mechanism: { handled: false, type: 'auto.http.deno' },
+        });
+        throw e;
+      }
+    }
+
+    const urlObject = parseStringToURLObject(request.url);
+    const [name, attributes] = getHttpSpanDetailsFromUrlObject(urlObject, 'server', 'auto.http.deno', request);
+
+    assignIfSet(attributes, 'http.request.body.size', request.headers.get('content-length'));
+    assignIfSet(attributes, 'user_agent.original', request.headers.get('user-agent'));
+
+    const sendDefaultPii = client.getOptions().sendDefaultPii ?? false;
+    if (sendDefaultPii) {
+      assignIfSet(
+        attributes,
+        'client.address',
+        (info?.remoteAddr as Deno.NetAddr)?.hostname ?? (info?.remoteAddr as Deno.UnixAddr)?.path,
+      );
+      assignIfSet(attributes, 'client.port', (info?.remoteAddr as Deno.NetAddr)?.port);
+    }
+
+    Object.assign(
+      attributes,
+      httpHeadersToSpanAttributes(winterCGHeadersToDict(request.headers), client.getOptions().sendDefaultPii ?? false),
+    );
+    attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP] = 'http.server';
+    isolationScope.setSDKProcessingMetadata({
+      normalizedRequest: winterCGRequestToRequestData(request),
+    });
+
+    return continueTrace(
+      {
+        sentryTrace: request.headers.get('sentry-trace') || '',
+        baggage: request.headers.get('baggage'),
+      },
+      () => {
+        return startSpanManual({ name, attributes }, async span => {
+          let res: Response;
+
+          try {
+            res = await handler();
+            setHttpStatus(span, res.status);
+          } catch (e) {
+            span.end();
+            captureException(e, {
+              mechanism: { handled: false, type: 'auto.http.deno' },
+            });
+            throw e;
+          }
+          // Classify response to detect actual streaming
+          const classification = classifyResponseStreaming(res);
+          if (classification.isStreaming && res.body) {
+            // Streaming response detected - monitor consumption to keep span alive
+            try {
+              const [clientStream, monitorStream] = res.body.tee();
+
+              // Monitor stream consumption and end span when complete
+              await (async () => {
+                const reader = monitorStream.getReader();
+                try {
+                  let done = false;
+                  while (!done) {
+                    const result = await reader.read();
+                    done = result.done;
+                  }
+                } catch {
+                  // Stream error or cancellation - will end span in finally
+                } finally {
+                  reader.releaseLock();
+                  span.end();
+                }
+              })();
+
+              // Return response with client stream
+              return new Response(clientStream, {
+                status: res.status,
+                statusText: res.statusText,
+                headers: res.headers,
+              });
+            } catch (e) {
+              // tee() failed (e.g stream already locked) - fall back to non-streaming handling
+              span.end();
+              return res;
+            }
+          }
+
+          // Non-streaming response - end span immediately and return original
+          span.end();
+          return res;
+        });
+      },
+    );
+  });
+}

Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ export function makeFetchTransport(options: BaseTransportOptions): Transport {`
`14`	`14`	`consoleSandbox(() => {`
`15`	`15`	`// eslint-disable-next-line no-console`
`16`	`16`	console.warn(`Sentry SDK requires 'net' permission to send events.
`17`		- Run with '--allow-net=${url.host}' to grant the requires permissions.`);
	`17`	+ Run with '--allow-net=${url.host}' to grant the required permissions.`);
`18`	`18`	`});`
`19`	`19`	`}`
`20`	`20`	`})`