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

packages/deno/package.json

@@ -43,8 +43,8 @@
  "lint:es-compatibility": "es-check es2022 ./build/esm/*.js --module",
  "install:deno": "node ./scripts/install-deno.mjs",
  "test": "run-s install:deno deno-types test:unit",
- "test:unit": "deno test --allow-read --allow-run --allow-env --no-check",
- "test:unit:update": "deno test --allow-read --allow-write --allow-run -- --update",
+ "test:unit": "deno test --allow-net --allow-read --allow-run --allow-env --no-check",
+ "test:unit:update": "deno test --allow-net --allow-read --allow-run --allow-env --no-check --allow-write -- --update",
  "yalc:publish": "yalc publish --push --sig"
  },
  "volta": {

packages/deno/scripts/download-deno-types.mjs

@@ -2,6 +2,6 @@ import { existsSync, writeFileSync } from 'fs';
 import { download } from './download.mjs';
 
 if (!existsSync('lib.deno.d.ts')) {
- const code = await download('https://github.com/denoland/deno/releases/download/v2.1.5/lib.deno.d.ts');
+ const code = await download('https://github.com/denoland/deno/releases/download/v2.6.6/lib.deno.d.ts');
  writeFileSync('lib.deno.d.ts', code);
 }

packages/deno/src/async.ts

@@ -0,0 +1,80 @@
+// 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,
+ });
+}

packages/deno/src/index.ts

@@ -94,7 +94,7 @@ export {
 export { DenoClient } from './client';
 
 export { getDefaultIntegrations, init } from './sdk';
-
+export { denoServeIntegration } from './integrations/deno-serve';
 export { denoContextIntegration } from './integrations/context';
 export { globalHandlersIntegration } from './integrations/globalhandlers';
 export { normalizePathsIntegration } from './integrations/normalizepaths';

packages/deno/src/integrations/deno-serve.ts

@@ -0,0 +1,69 @@
+import type { IntegrationFn } from '@sentry/core';
+import { defineIntegration } from '@sentry/core';
+import { setAsyncLocalStorageAsyncContextStrategy } from '../async';
+import type { RequestHandlerWrapperOptions } from '../wrap-deno-request-handler';
+import { wrapDenoRequestHandler } from '../wrap-deno-request-handler';
+
+const INTEGRATION_NAME = 'DenoServe';
+
+export type ServeParams =
+ // [(Request) => Response]
+ | [Deno.ServeHandler<Deno.NetAddr>]
+ // [{ options }, (Request) => Response]
+ | [Deno.ServeUnixOptions, Deno.ServeHandler<Deno.UnixAddr>]
+ | [Deno.ServeVsockOptions, Deno.ServeHandler<Deno.VsockAddr>]
+ | [Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem), Deno.ServeHandler<Deno.NetAddr>]
+ // [{ handler: (Request) => Response }]
+ | [Deno.ServeUnixOptions & Deno.ServeInit<Deno.UnixAddr>]
+ | [Deno.ServeVsockOptions & Deno.ServeInit<Deno.VsockAddr>]
+ | [(Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem)) & Deno.ServeInit<Deno.NetAddr>];
+
+const isSimpleHandler = (p: ServeParams): p is [Deno.ServeHandler<Deno.Addr>] => typeof p[0] === 'function';
+
+const isServeOptWithFunction = (p: ServeParams): p is [Deno.ServeOptions<Deno.Addr>, Deno.ServeHandler<Deno.Addr>] =>
+ p.length >= 2 && typeof p[1] === 'function' && !!p[0] && typeof p[0] === 'object';
+
+const isServeInitOptions = (p: ServeParams): p is [Deno.ServeOptions<Deno.Addr> & Deno.ServeInit<Deno.Addr>] =>
+ typeof p[0] === 'object' &&
+ !!p[0] &&
+ !isServeOptWithFunction(p) &&
+ 'handler' in p[0] &&
+ typeof p[0].handler === 'function';
+
+const applyHandlerWrap = <A extends Deno.Addr>(
+ handler: (request: Request, info: Deno.ServeHandlerInfo<A>) => Response | Promise<Response>,
+ serveOptions?: Deno.ServeOptions,
+): Deno.ServeHandler =>
+ ((request, info) =>
+ wrapDenoRequestHandler<A>(
+ {
+ request,
+ info,
+ serveOptions,
+ } as RequestHandlerWrapperOptions<A>,
+ () => handler(request, info as Deno.ServeHandlerInfo<A>),
+ )) as Deno.ServeHandler;
+
+const _denoServeIntegration = (() => {
+ return {
+ name: INTEGRATION_NAME,
+ setupOnce() {
+ setAsyncLocalStorageAsyncContextStrategy();
+ Deno.serve = new Proxy(Deno.serve, {
+ apply(target, thisArg, args: ServeParams) {
+ if (isSimpleHandler(args)) {
+ args[0] = applyHandlerWrap(args[0]);
+ } else if (isServeOptWithFunction(args)) {
+ args[1] = applyHandlerWrap(args[1], args[0]);
+ } else if (isServeInitOptions(args)) {
+ args[0].handler = applyHandlerWrap(args[0].handler, args[0]);
+ }
+ // if none of those matched, it'll crash, most likely.
+ return target.apply(thisArg, args);
+ },
+ });
+ },
+ };
+}) satisfies IntegrationFn;
+
+export const denoServeIntegration = defineIntegration(_denoServeIntegration);

packages/deno/src/sdk.ts

@@ -8,12 +8,14 @@ import {
  initAndBind,
  linkedErrorsIntegration,
  nodeStackLineParser,
+ requestDataIntegration,
  stackParserFromStackParserOptions,
 } from '@sentry/core';
 import { DenoClient } from './client';
 import { breadcrumbsIntegration } from './integrations/breadcrumbs';
 import { denoContextIntegration } from './integrations/context';
 import { contextLinesIntegration } from './integrations/contextlines';
+import { denoServeIntegration } from './integrations/deno-serve';
 import { globalHandlersIntegration } from './integrations/globalhandlers';
 import { normalizePathsIntegration } from './integrations/normalizepaths';
 import { setupOpenTelemetryTracer } from './opentelemetry/tracer';
@@ -28,12 +30,14 @@ export function getDefaultIntegrations(_options: Options): Integration[] {
  // TODO(v11): Replace with `eventFiltersIntegration` once we remove the deprecated `inboundFiltersIntegration`
  // eslint-disable-next-line deprecation/deprecation
  inboundFiltersIntegration(),
+ requestDataIntegration(),
  functionToStringIntegration(),
  linkedErrorsIntegration(),
  dedupeIntegration(),
  // Deno Specific
  breadcrumbsIntegration(),
  denoContextIntegration(),
+ denoServeIntegration(),
  contextLinesIntegration(),
  normalizePathsIntegration(),
  globalHandlersIntegration(),

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.`);
  });
  }
  })

packages/deno/src/utils/streaming.ts

@@ -0,0 +1,104 @@
+import type { Span } from '@sentry/core';
+
+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 };
+}
+
+/**
+ * Tee a stream, and end the provided span when the stream ends.
+ * Returns the other side of the tee, which can be used to send the
+ * response to a client.
+ */
+export async function streamResponse(span: Span, res: Response): Promise<Response> {
+ const classification = classifyResponseStreaming(res);
+
+ // not streaming, just end the span and return the response
+ if (!classification.isStreaming || !res.body) {
+ span.end();
+ return res;
+ }
+
+ // Streaming response detected - monitor consumption to keep span alive
+ try {
+ return new Response(
+ monitorStream(res.body, () => span.end()),
+ {
+ status: res.status,
+ statusText: res.statusText,
+ headers: res.headers,
+ },
+ );
+ } catch (e) {
+ // tee() failed - handle without streaming
+ span.end();
+ return res;
+ }
+}
+
+/**
+ * zero-copy monitoring of stream progress.
+ */
+function monitorStream(
+ stream: ReadableStream<Uint8Array<ArrayBufferLike>>,
+ onDone: () => void,
+): ReadableStream<Uint8Array<ArrayBufferLike>> {
+ const reader = stream.getReader();
+ reader.closed.finally(() => onDone());
+ return new ReadableStream({
+ async start(controller) {
+ let result: ReadableStreamReadResult<Uint8Array<ArrayBufferLike>>;
+ do {
+ result = await reader.read();
+ if (result.value) {
+ try {
+ controller.enqueue(result.value);
+ } catch (er) {
+ controller.error(er);
+ reader.releaseLock();
+ return;
+ }
+ }
+ } while (!result.done);
+ controller.close();
+ reader.releaseLock();
+ },
+ });
+}

packages/deno/package.json

@@ -43,8 +43,8 @@
  "lint:es-compatibility": "es-check es2022 ./build/esm/*.js --module",
  "install:deno": "node ./scripts/install-deno.mjs",
  "test": "run-s install:deno deno-types test:unit",
- "test:unit": "deno test --allow-read --allow-run --allow-env --no-check",
- "test:unit:update": "deno test --allow-read --allow-write --allow-run -- --update",
+ "test:unit": "deno test --allow-net --allow-read --allow-run --allow-env --no-check",
+ "test:unit:update": "deno test --allow-net --allow-read --allow-run --allow-env --no-check --allow-write -- --update",
  "yalc:publish": "yalc publish --push --sig"
  },
  "volta": {

packages/deno/scripts/download-deno-types.mjs

@@ -2,6 +2,6 @@ import { existsSync, writeFileSync } from 'fs';
 import { download } from './download.mjs';
 
 if (!existsSync('lib.deno.d.ts')) {
- const code = await download('https://github.com/denoland/deno/releases/download/v2.1.5/lib.deno.d.ts');
+ const code = await download('https://github.com/denoland/deno/releases/download/v2.6.6/lib.deno.d.ts');
  writeFileSync('lib.deno.d.ts', code);
 }

packages/deno/src/async.ts

@@ -0,0 +1,80 @@
+// 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,
+ });
+}

packages/deno/src/index.ts

@@ -94,7 +94,7 @@ export {
 export { DenoClient } from './client';
 
 export { getDefaultIntegrations, init } from './sdk';
-
+export { denoServeIntegration } from './integrations/deno-serve';
 export { denoContextIntegration } from './integrations/context';
 export { globalHandlersIntegration } from './integrations/globalhandlers';
 export { normalizePathsIntegration } from './integrations/normalizepaths';

packages/deno/src/integrations/deno-serve.ts

@@ -0,0 +1,69 @@
+import type { IntegrationFn } from '@sentry/core';
+import { defineIntegration } from '@sentry/core';
+import { setAsyncLocalStorageAsyncContextStrategy } from '../async';
+import type { RequestHandlerWrapperOptions } from '../wrap-deno-request-handler';
+import { wrapDenoRequestHandler } from '../wrap-deno-request-handler';
+
+const INTEGRATION_NAME = 'DenoServe';
+
+export type ServeParams =
+ // [(Request) => Response]
+ | [Deno.ServeHandler<Deno.NetAddr>]
+ // [{ options }, (Request) => Response]
+ | [Deno.ServeUnixOptions, Deno.ServeHandler<Deno.UnixAddr>]
+ | [Deno.ServeVsockOptions, Deno.ServeHandler<Deno.VsockAddr>]
+ | [Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem), Deno.ServeHandler<Deno.NetAddr>]
+ // [{ handler: (Request) => Response }]
+ | [Deno.ServeUnixOptions & Deno.ServeInit<Deno.UnixAddr>]
+ | [Deno.ServeVsockOptions & Deno.ServeInit<Deno.VsockAddr>]
+ | [(Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem)) & Deno.ServeInit<Deno.NetAddr>];
+
+const isSimpleHandler = (p: ServeParams): p is [Deno.ServeHandler<Deno.Addr>] => typeof p[0] === 'function';
+
+const isServeOptWithFunction = (p: ServeParams): p is [Deno.ServeOptions<Deno.Addr>, Deno.ServeHandler<Deno.Addr>] =>
+ p.length >= 2 && typeof p[1] === 'function' && !!p[0] && typeof p[0] === 'object';
+
+const isServeInitOptions = (p: ServeParams): p is [Deno.ServeOptions<Deno.Addr> & Deno.ServeInit<Deno.Addr>] =>
+ typeof p[0] === 'object' &&
+ !!p[0] &&
+ !isServeOptWithFunction(p) &&
+ 'handler' in p[0] &&
+ typeof p[0].handler === 'function';
+
+const applyHandlerWrap = <A extends Deno.Addr>(
+ handler: (request: Request, info: Deno.ServeHandlerInfo<A>) => Response | Promise<Response>,
+ serveOptions?: Deno.ServeOptions,
+): Deno.ServeHandler =>
+ ((request, info) =>
+ wrapDenoRequestHandler<A>(
+ {
+ request,
+ info,
+ serveOptions,
+ } as RequestHandlerWrapperOptions<A>,
+ () => handler(request, info as Deno.ServeHandlerInfo<A>),
+ )) as Deno.ServeHandler;
+
+const _denoServeIntegration = (() => {
+ return {
+ name: INTEGRATION_NAME,
+ setupOnce() {
+ setAsyncLocalStorageAsyncContextStrategy();
+ Deno.serve = new Proxy(Deno.serve, {
+ apply(target, thisArg, args: ServeParams) {
+ if (isSimpleHandler(args)) {
+ args[0] = applyHandlerWrap(args[0]);
+ } else if (isServeOptWithFunction(args)) {
+ args[1] = applyHandlerWrap(args[1], args[0]);
+ } else if (isServeInitOptions(args)) {
+ args[0].handler = applyHandlerWrap(args[0].handler, args[0]);
+ }
+ // if none of those matched, it'll crash, most likely.
+ return target.apply(thisArg, args);
+ },
+ });
+ },
+ };
+}) satisfies IntegrationFn;
+
+export const denoServeIntegration = defineIntegration(_denoServeIntegration);

packages/deno/src/sdk.ts

@@ -8,12 +8,14 @@ import {
  initAndBind,
  linkedErrorsIntegration,
  nodeStackLineParser,
+ requestDataIntegration,
  stackParserFromStackParserOptions,
 } from '@sentry/core';
 import { DenoClient } from './client';
 import { breadcrumbsIntegration } from './integrations/breadcrumbs';
 import { denoContextIntegration } from './integrations/context';
 import { contextLinesIntegration } from './integrations/contextlines';
+import { denoServeIntegration } from './integrations/deno-serve';
 import { globalHandlersIntegration } from './integrations/globalhandlers';
 import { normalizePathsIntegration } from './integrations/normalizepaths';
 import { setupOpenTelemetryTracer } from './opentelemetry/tracer';
@@ -28,12 +30,14 @@ export function getDefaultIntegrations(_options: Options): Integration[] {
  // TODO(v11): Replace with `eventFiltersIntegration` once we remove the deprecated `inboundFiltersIntegration`
  // eslint-disable-next-line deprecation/deprecation
  inboundFiltersIntegration(),
+ requestDataIntegration(),
  functionToStringIntegration(),
  linkedErrorsIntegration(),
  dedupeIntegration(),
  // Deno Specific
  breadcrumbsIntegration(),
  denoContextIntegration(),
+ denoServeIntegration(),
  contextLinesIntegration(),
  normalizePathsIntegration(),
  globalHandlersIntegration(),

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.`);
  });
  }
  })

packages/deno/src/utils/streaming.ts

@@ -0,0 +1,104 @@
+import type { Span } from '@sentry/core';
+
+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 };
+}
+
+/**
+ * Tee a stream, and end the provided span when the stream ends.
+ * Returns the other side of the tee, which can be used to send the
+ * response to a client.
+ */
+export async function streamResponse(span: Span, res: Response): Promise<Response> {
+ const classification = classifyResponseStreaming(res);
+
+ // not streaming, just end the span and return the response
+ if (!classification.isStreaming || !res.body) {
+ span.end();
+ return res;
+ }
+
+ // Streaming response detected - monitor consumption to keep span alive
+ try {
+ return new Response(
+ monitorStream(res.body, () => span.end()),
+ {
+ status: res.status,
+ statusText: res.statusText,
+ headers: res.headers,
+ },
+ );
+ } catch (e) {
+ // tee() failed - handle without streaming
+ span.end();
+ return res;
+ }
+}
+
+/**
+ * zero-copy monitoring of stream progress.
+ */
+function monitorStream(
+ stream: ReadableStream<Uint8Array<ArrayBufferLike>>,
+ onDone: () => void,
+): ReadableStream<Uint8Array<ArrayBufferLike>> {
+ const reader = stream.getReader();
+ reader.closed.finally(() => onDone());
+ return new ReadableStream({
+ async start(controller) {
+ let result: ReadableStreamReadResult<Uint8Array<ArrayBufferLike>>;
+ do {
+ result = await reader.read();
+ if (result.value) {
+ try {
+ controller.enqueue(result.value);
+ } catch (er) {
+ controller.error(er);
+ reader.releaseLock();
+ return;
+ }
+ }
+ } while (!result.done);
+ controller.close();
+ reader.releaseLock();
+ },
+ });
+}

packages/deno/package.json

@@ -43,8 +43,8 @@
  "lint:es-compatibility": "es-check es2022 ./build/esm/*.js --module",
  "install:deno": "node ./scripts/install-deno.mjs",
  "test": "run-s install:deno deno-types test:unit",
- "test:unit": "deno test --allow-read --allow-run --allow-env --no-check",
- "test:unit:update": "deno test --allow-read --allow-write --allow-run -- --update",
+ "test:unit": "deno test --allow-net --allow-read --allow-run --allow-env --no-check",
+ "test:unit:update": "deno test --allow-net --allow-read --allow-run --allow-env --no-check --allow-write -- --update",
  "yalc:publish": "yalc publish --push --sig"
  },
  "volta": {

packages/deno/scripts/download-deno-types.mjs

@@ -2,6 +2,6 @@ import { existsSync, writeFileSync } from 'fs';
 import { download } from './download.mjs';
 
 if (!existsSync('lib.deno.d.ts')) {
- const code = await download('https://github.com/denoland/deno/releases/download/v2.1.5/lib.deno.d.ts');
+ const code = await download('https://github.com/denoland/deno/releases/download/v2.6.6/lib.deno.d.ts');
  writeFileSync('lib.deno.d.ts', code);
 }

packages/deno/src/async.ts

@@ -0,0 +1,80 @@
+// 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,
+ });
+}

packages/deno/src/index.ts

@@ -94,7 +94,7 @@ export {
 export { DenoClient } from './client';
 
 export { getDefaultIntegrations, init } from './sdk';
-
+export { denoServeIntegration } from './integrations/deno-serve';
 export { denoContextIntegration } from './integrations/context';
 export { globalHandlersIntegration } from './integrations/globalhandlers';
 export { normalizePathsIntegration } from './integrations/normalizepaths';

packages/deno/src/integrations/deno-serve.ts

@@ -0,0 +1,69 @@
+import type { IntegrationFn } from '@sentry/core';
+import { defineIntegration } from '@sentry/core';
+import { setAsyncLocalStorageAsyncContextStrategy } from '../async';
+import type { RequestHandlerWrapperOptions } from '../wrap-deno-request-handler';
+import { wrapDenoRequestHandler } from '../wrap-deno-request-handler';
+
+const INTEGRATION_NAME = 'DenoServe';
+
+export type ServeParams =
+ // [(Request) => Response]
+ | [Deno.ServeHandler<Deno.NetAddr>]
+ // [{ options }, (Request) => Response]
+ | [Deno.ServeUnixOptions, Deno.ServeHandler<Deno.UnixAddr>]
+ | [Deno.ServeVsockOptions, Deno.ServeHandler<Deno.VsockAddr>]
+ | [Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem), Deno.ServeHandler<Deno.NetAddr>]
+ // [{ handler: (Request) => Response }]
+ | [Deno.ServeUnixOptions & Deno.ServeInit<Deno.UnixAddr>]
+ | [Deno.ServeVsockOptions & Deno.ServeInit<Deno.VsockAddr>]
+ | [(Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem)) & Deno.ServeInit<Deno.NetAddr>];
+
+const isSimpleHandler = (p: ServeParams): p is [Deno.ServeHandler<Deno.Addr>] => typeof p[0] === 'function';
+
+const isServeOptWithFunction = (p: ServeParams): p is [Deno.ServeOptions<Deno.Addr>, Deno.ServeHandler<Deno.Addr>] =>
+ p.length >= 2 && typeof p[1] === 'function' && !!p[0] && typeof p[0] === 'object';
+
+const isServeInitOptions = (p: ServeParams): p is [Deno.ServeOptions<Deno.Addr> & Deno.ServeInit<Deno.Addr>] =>
+ typeof p[0] === 'object' &&
+ !!p[0] &&
+ !isServeOptWithFunction(p) &&
+ 'handler' in p[0] &&
+ typeof p[0].handler === 'function';
+
+const applyHandlerWrap = <A extends Deno.Addr>(
+ handler: (request: Request, info: Deno.ServeHandlerInfo<A>) => Response | Promise<Response>,
+ serveOptions?: Deno.ServeOptions,
+): Deno.ServeHandler =>
+ ((request, info) =>
+ wrapDenoRequestHandler<A>(
+ {
+ request,
+ info,
+ serveOptions,
+ } as RequestHandlerWrapperOptions<A>,
+ () => handler(request, info as Deno.ServeHandlerInfo<A>),
+ )) as Deno.ServeHandler;
+
+const _denoServeIntegration = (() => {
+ return {
+ name: INTEGRATION_NAME,
+ setupOnce() {
+ setAsyncLocalStorageAsyncContextStrategy();
+ Deno.serve = new Proxy(Deno.serve, {
+ apply(target, thisArg, args: ServeParams) {
+ if (isSimpleHandler(args)) {
+ args[0] = applyHandlerWrap(args[0]);
+ } else if (isServeOptWithFunction(args)) {
+ args[1] = applyHandlerWrap(args[1], args[0]);
+ } else if (isServeInitOptions(args)) {
+ args[0].handler = applyHandlerWrap(args[0].handler, args[0]);
+ }
+ // if none of those matched, it'll crash, most likely.
+ return target.apply(thisArg, args);
+ },
+ });
+ },
+ };
+}) satisfies IntegrationFn;
+
+export const denoServeIntegration = defineIntegration(_denoServeIntegration);

packages/deno/src/sdk.ts

@@ -8,12 +8,14 @@ import {
  initAndBind,
  linkedErrorsIntegration,
  nodeStackLineParser,
+ requestDataIntegration,
  stackParserFromStackParserOptions,
 } from '@sentry/core';
 import { DenoClient } from './client';
 import { breadcrumbsIntegration } from './integrations/breadcrumbs';
 import { denoContextIntegration } from './integrations/context';
 import { contextLinesIntegration } from './integrations/contextlines';
+import { denoServeIntegration } from './integrations/deno-serve';
 import { globalHandlersIntegration } from './integrations/globalhandlers';
 import { normalizePathsIntegration } from './integrations/normalizepaths';
 import { setupOpenTelemetryTracer } from './opentelemetry/tracer';
@@ -28,12 +30,14 @@ export function getDefaultIntegrations(_options: Options): Integration[] {
  // TODO(v11): Replace with `eventFiltersIntegration` once we remove the deprecated `inboundFiltersIntegration`
  // eslint-disable-next-line deprecation/deprecation
  inboundFiltersIntegration(),
+ requestDataIntegration(),
  functionToStringIntegration(),
  linkedErrorsIntegration(),
  dedupeIntegration(),
  // Deno Specific
  breadcrumbsIntegration(),
  denoContextIntegration(),
+ denoServeIntegration(),
  contextLinesIntegration(),
  normalizePathsIntegration(),
  globalHandlersIntegration(),

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.`);
  });
  }
  })

packages/deno/src/utils/streaming.ts

@@ -0,0 +1,104 @@
+import type { Span } from '@sentry/core';
+
+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 };
+}
+
+/**
+ * Tee a stream, and end the provided span when the stream ends.
+ * Returns the other side of the tee, which can be used to send the
+ * response to a client.
+ */
+export async function streamResponse(span: Span, res: Response): Promise<Response> {
+ const classification = classifyResponseStreaming(res);
+
+ // not streaming, just end the span and return the response
+ if (!classification.isStreaming || !res.body) {
+ span.end();
+ return res;
+ }
+
+ // Streaming response detected - monitor consumption to keep span alive
+ try {
+ return new Response(
+ monitorStream(res.body, () => span.end()),
+ {
+ status: res.status,
+ statusText: res.statusText,
+ headers: res.headers,
+ },
+ );
+ } catch (e) {
+ // tee() failed - handle without streaming
+ span.end();
+ return res;
+ }
+}
+
+/**
+ * zero-copy monitoring of stream progress.
+ */
+function monitorStream(
+ stream: ReadableStream<Uint8Array<ArrayBufferLike>>,
+ onDone: () => void,
+): ReadableStream<Uint8Array<ArrayBufferLike>> {
+ const reader = stream.getReader();
+ reader.closed.finally(() => onDone());
+ return new ReadableStream({
+ async start(controller) {
+ let result: ReadableStreamReadResult<Uint8Array<ArrayBufferLike>>;
+ do {
+ result = await reader.read();
+ if (result.value) {
+ try {
+ controller.enqueue(result.value);
+ } catch (er) {
+ controller.error(er);
+ reader.releaseLock();
+ return;
+ }
+ }
+ } while (!result.done);
+ controller.close();
+ reader.releaseLock();
+ },
+ });
+}

packages/deno/package.json

@@ -43,8 +43,8 @@
  "lint:es-compatibility": "es-check es2022 ./build/esm/*.js --module",
  "install:deno": "node ./scripts/install-deno.mjs",
  "test": "run-s install:deno deno-types test:unit",
- "test:unit": "deno test --allow-read --allow-run --allow-env --no-check",
- "test:unit:update": "deno test --allow-read --allow-write --allow-run -- --update",
+ "test:unit": "deno test --allow-net --allow-read --allow-run --allow-env --no-check",
+ "test:unit:update": "deno test --allow-net --allow-read --allow-run --allow-env --no-check --allow-write -- --update",
  "yalc:publish": "yalc publish --push --sig"
  },
  "volta": {

packages/deno/scripts/download-deno-types.mjs

@@ -2,6 +2,6 @@ import { existsSync, writeFileSync } from 'fs';
 import { download } from './download.mjs';
 
 if (!existsSync('lib.deno.d.ts')) {
- const code = await download('https://github.com/denoland/deno/releases/download/v2.1.5/lib.deno.d.ts');
+ const code = await download('https://github.com/denoland/deno/releases/download/v2.6.6/lib.deno.d.ts');
  writeFileSync('lib.deno.d.ts', code);
 }

packages/deno/src/async.ts

@@ -0,0 +1,80 @@
+// 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,
+ });
+}

packages/deno/src/index.ts

@@ -94,7 +94,7 @@ export {
 export { DenoClient } from './client';
 
 export { getDefaultIntegrations, init } from './sdk';
-
+export { denoServeIntegration } from './integrations/deno-serve';
 export { denoContextIntegration } from './integrations/context';
 export { globalHandlersIntegration } from './integrations/globalhandlers';
 export { normalizePathsIntegration } from './integrations/normalizepaths';

packages/deno/src/integrations/deno-serve.ts

@@ -0,0 +1,69 @@
+import type { IntegrationFn } from '@sentry/core';
+import { defineIntegration } from '@sentry/core';
+import { setAsyncLocalStorageAsyncContextStrategy } from '../async';
+import type { RequestHandlerWrapperOptions } from '../wrap-deno-request-handler';
+import { wrapDenoRequestHandler } from '../wrap-deno-request-handler';
+
+const INTEGRATION_NAME = 'DenoServe';
+
+export type ServeParams =
+ // [(Request) => Response]
+ | [Deno.ServeHandler<Deno.NetAddr>]
+ // [{ options }, (Request) => Response]
+ | [Deno.ServeUnixOptions, Deno.ServeHandler<Deno.UnixAddr>]
+ | [Deno.ServeVsockOptions, Deno.ServeHandler<Deno.VsockAddr>]
+ | [Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem), Deno.ServeHandler<Deno.NetAddr>]
+ // [{ handler: (Request) => Response }]
+ | [Deno.ServeUnixOptions & Deno.ServeInit<Deno.UnixAddr>]
+ | [Deno.ServeVsockOptions & Deno.ServeInit<Deno.VsockAddr>]
+ | [(Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem)) & Deno.ServeInit<Deno.NetAddr>];
+
+const isSimpleHandler = (p: ServeParams): p is [Deno.ServeHandler<Deno.Addr>] => typeof p[0] === 'function';
+
+const isServeOptWithFunction = (p: ServeParams): p is [Deno.ServeOptions<Deno.Addr>, Deno.ServeHandler<Deno.Addr>] =>
+ p.length >= 2 && typeof p[1] === 'function' && !!p[0] && typeof p[0] === 'object';
+
+const isServeInitOptions = (p: ServeParams): p is [Deno.ServeOptions<Deno.Addr> & Deno.ServeInit<Deno.Addr>] =>
+ typeof p[0] === 'object' &&
+ !!p[0] &&
+ !isServeOptWithFunction(p) &&
+ 'handler' in p[0] &&
+ typeof p[0].handler === 'function';
+
+const applyHandlerWrap = <A extends Deno.Addr>(
+ handler: (request: Request, info: Deno.ServeHandlerInfo<A>) => Response | Promise<Response>,
+ serveOptions?: Deno.ServeOptions,
+): Deno.ServeHandler =>
+ ((request, info) =>
+ wrapDenoRequestHandler<A>(
+ {
+ request,
+ info,
+ serveOptions,
+ } as RequestHandlerWrapperOptions<A>,
+ () => handler(request, info as Deno.ServeHandlerInfo<A>),
+ )) as Deno.ServeHandler;
+
+const _denoServeIntegration = (() => {
+ return {
+ name: INTEGRATION_NAME,
+ setupOnce() {
+ setAsyncLocalStorageAsyncContextStrategy();
+ Deno.serve = new Proxy(Deno.serve, {
+ apply(target, thisArg, args: ServeParams) {
+ if (isSimpleHandler(args)) {
+ args[0] = applyHandlerWrap(args[0]);
+ } else if (isServeOptWithFunction(args)) {
+ args[1] = applyHandlerWrap(args[1], args[0]);
+ } else if (isServeInitOptions(args)) {
+ args[0].handler = applyHandlerWrap(args[0].handler, args[0]);
+ }
+ // if none of those matched, it'll crash, most likely.
+ return target.apply(thisArg, args);
+ },
+ });
+ },
+ };
+}) satisfies IntegrationFn;
+
+export const denoServeIntegration = defineIntegration(_denoServeIntegration);

packages/deno/src/sdk.ts

@@ -8,12 +8,14 @@ import {
  initAndBind,
  linkedErrorsIntegration,
  nodeStackLineParser,
+ requestDataIntegration,
  stackParserFromStackParserOptions,
 } from '@sentry/core';
 import { DenoClient } from './client';
 import { breadcrumbsIntegration } from './integrations/breadcrumbs';
 import { denoContextIntegration } from './integrations/context';
 import { contextLinesIntegration } from './integrations/contextlines';
+import { denoServeIntegration } from './integrations/deno-serve';
 import { globalHandlersIntegration } from './integrations/globalhandlers';
 import { normalizePathsIntegration } from './integrations/normalizepaths';
 import { setupOpenTelemetryTracer } from './opentelemetry/tracer';
@@ -28,12 +30,14 @@ export function getDefaultIntegrations(_options: Options): Integration[] {
  // TODO(v11): Replace with `eventFiltersIntegration` once we remove the deprecated `inboundFiltersIntegration`
  // eslint-disable-next-line deprecation/deprecation
  inboundFiltersIntegration(),
+ requestDataIntegration(),
  functionToStringIntegration(),
  linkedErrorsIntegration(),
  dedupeIntegration(),
  // Deno Specific
  breadcrumbsIntegration(),
  denoContextIntegration(),
+ denoServeIntegration(),
  contextLinesIntegration(),
  normalizePathsIntegration(),
  globalHandlersIntegration(),

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.`);
  });
  }
  })

packages/deno/src/utils/streaming.ts

@@ -0,0 +1,104 @@
+import type { Span } from '@sentry/core';
+
+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 };
+}
+
+/**
+ * Tee a stream, and end the provided span when the stream ends.
+ * Returns the other side of the tee, which can be used to send the
+ * response to a client.
+ */
+export async function streamResponse(span: Span, res: Response): Promise<Response> {
+ const classification = classifyResponseStreaming(res);
+
+ // not streaming, just end the span and return the response
+ if (!classification.isStreaming || !res.body) {
+ span.end();
+ return res;
+ }
+
+ // Streaming response detected - monitor consumption to keep span alive
+ try {
+ return new Response(
+ monitorStream(res.body, () => span.end()),
+ {
+ status: res.status,
+ statusText: res.statusText,
+ headers: res.headers,
+ },
+ );
+ } catch (e) {
+ // tee() failed - handle without streaming
+ span.end();
+ return res;
+ }
+}
+
+/**
+ * zero-copy monitoring of stream progress.
+ */
+function monitorStream(
+ stream: ReadableStream<Uint8Array<ArrayBufferLike>>,
+ onDone: () => void,
+): ReadableStream<Uint8Array<ArrayBufferLike>> {
+ const reader = stream.getReader();
+ reader.closed.finally(() => onDone());
+ return new ReadableStream({
+ async start(controller) {
+ let result: ReadableStreamReadResult<Uint8Array<ArrayBufferLike>>;
+ do {
+ result = await reader.read();
+ if (result.value) {
+ try {
+ controller.enqueue(result.value);
+ } catch (er) {
+ controller.error(er);
+ reader.releaseLock();
+ return;
+ }
+ }
+ } while (!result.done);
+ controller.close();
+ reader.releaseLock();
+ },
+ });
+}

packages/deno/package.json

@@ -43,8 +43,8 @@
  "lint:es-compatibility": "es-check es2022 ./build/esm/*.js --module",
  "install:deno": "node ./scripts/install-deno.mjs",
  "test": "run-s install:deno deno-types test:unit",
- "test:unit": "deno test --allow-read --allow-run --allow-env --no-check",
- "test:unit:update": "deno test --allow-read --allow-write --allow-run -- --update",
+ "test:unit": "deno test --allow-net --allow-read --allow-run --allow-env --no-check",
+ "test:unit:update": "deno test --allow-net --allow-read --allow-run --allow-env --no-check --allow-write -- --update",
  "yalc:publish": "yalc publish --push --sig"
  },
  "volta": {

packages/deno/scripts/download-deno-types.mjs

@@ -2,6 +2,6 @@ import { existsSync, writeFileSync } from 'fs';
 import { download } from './download.mjs';
 
 if (!existsSync('lib.deno.d.ts')) {
- const code = await download('https://github.com/denoland/deno/releases/download/v2.1.5/lib.deno.d.ts');
+ const code = await download('https://github.com/denoland/deno/releases/download/v2.6.6/lib.deno.d.ts');
  writeFileSync('lib.deno.d.ts', code);
 }

packages/deno/src/async.ts

@@ -0,0 +1,80 @@
+// 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,
+ });
+}

packages/deno/src/index.ts

@@ -94,7 +94,7 @@ export {
 export { DenoClient } from './client';
 
 export { getDefaultIntegrations, init } from './sdk';
-
+export { denoServeIntegration } from './integrations/deno-serve';
 export { denoContextIntegration } from './integrations/context';
 export { globalHandlersIntegration } from './integrations/globalhandlers';
 export { normalizePathsIntegration } from './integrations/normalizepaths';

packages/deno/src/integrations/deno-serve.ts

@@ -0,0 +1,69 @@
+import type { IntegrationFn } from '@sentry/core';
+import { defineIntegration } from '@sentry/core';
+import { setAsyncLocalStorageAsyncContextStrategy } from '../async';
+import type { RequestHandlerWrapperOptions } from '../wrap-deno-request-handler';
+import { wrapDenoRequestHandler } from '../wrap-deno-request-handler';
+
+const INTEGRATION_NAME = 'DenoServe';
+
+export type ServeParams =
+ // [(Request) => Response]
+ | [Deno.ServeHandler<Deno.NetAddr>]
+ // [{ options }, (Request) => Response]
+ | [Deno.ServeUnixOptions, Deno.ServeHandler<Deno.UnixAddr>]
+ | [Deno.ServeVsockOptions, Deno.ServeHandler<Deno.VsockAddr>]
+ | [Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem), Deno.ServeHandler<Deno.NetAddr>]
+ // [{ handler: (Request) => Response }]
+ | [Deno.ServeUnixOptions & Deno.ServeInit<Deno.UnixAddr>]
+ | [Deno.ServeVsockOptions & Deno.ServeInit<Deno.VsockAddr>]
+ | [(Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem)) & Deno.ServeInit<Deno.NetAddr>];
+
+const isSimpleHandler = (p: ServeParams): p is [Deno.ServeHandler<Deno.Addr>] => typeof p[0] === 'function';
+
+const isServeOptWithFunction = (p: ServeParams): p is [Deno.ServeOptions<Deno.Addr>, Deno.ServeHandler<Deno.Addr>] =>
+ p.length >= 2 && typeof p[1] === 'function' && !!p[0] && typeof p[0] === 'object';
+
+const isServeInitOptions = (p: ServeParams): p is [Deno.ServeOptions<Deno.Addr> & Deno.ServeInit<Deno.Addr>] =>
+ typeof p[0] === 'object' &&
+ !!p[0] &&
+ !isServeOptWithFunction(p) &&
+ 'handler' in p[0] &&
+ typeof p[0].handler === 'function';
+
+const applyHandlerWrap = <A extends Deno.Addr>(
+ handler: (request: Request, info: Deno.ServeHandlerInfo<A>) => Response | Promise<Response>,
+ serveOptions?: Deno.ServeOptions,
+): Deno.ServeHandler =>
+ ((request, info) =>
+ wrapDenoRequestHandler<A>(
+ {
+ request,
+ info,
+ serveOptions,
+ } as RequestHandlerWrapperOptions<A>,
+ () => handler(request, info as Deno.ServeHandlerInfo<A>),
+ )) as Deno.ServeHandler;
+
+const _denoServeIntegration = (() => {
+ return {
+ name: INTEGRATION_NAME,
+ setupOnce() {
+ setAsyncLocalStorageAsyncContextStrategy();
+ Deno.serve = new Proxy(Deno.serve, {
+ apply(target, thisArg, args: ServeParams) {
+ if (isSimpleHandler(args)) {
+ args[0] = applyHandlerWrap(args[0]);
+ } else if (isServeOptWithFunction(args)) {
+ args[1] = applyHandlerWrap(args[1], args[0]);
+ } else if (isServeInitOptions(args)) {
+ args[0].handler = applyHandlerWrap(args[0].handler, args[0]);
+ }
+ // if none of those matched, it'll crash, most likely.
+ return target.apply(thisArg, args);
+ },
+ });
+ },
+ };
+}) satisfies IntegrationFn;
+
+export const denoServeIntegration = defineIntegration(_denoServeIntegration);

packages/deno/src/sdk.ts

@@ -8,12 +8,14 @@ import {
  initAndBind,
  linkedErrorsIntegration,
  nodeStackLineParser,
+ requestDataIntegration,
  stackParserFromStackParserOptions,
 } from '@sentry/core';
 import { DenoClient } from './client';
 import { breadcrumbsIntegration } from './integrations/breadcrumbs';
 import { denoContextIntegration } from './integrations/context';
 import { contextLinesIntegration } from './integrations/contextlines';
+import { denoServeIntegration } from './integrations/deno-serve';
 import { globalHandlersIntegration } from './integrations/globalhandlers';
 import { normalizePathsIntegration } from './integrations/normalizepaths';
 import { setupOpenTelemetryTracer } from './opentelemetry/tracer';
@@ -28,12 +30,14 @@ export function getDefaultIntegrations(_options: Options): Integration[] {
  // TODO(v11): Replace with `eventFiltersIntegration` once we remove the deprecated `inboundFiltersIntegration`
  // eslint-disable-next-line deprecation/deprecation
  inboundFiltersIntegration(),
+ requestDataIntegration(),
  functionToStringIntegration(),
  linkedErrorsIntegration(),
  dedupeIntegration(),
  // Deno Specific
  breadcrumbsIntegration(),
  denoContextIntegration(),
+ denoServeIntegration(),
  contextLinesIntegration(),
  normalizePathsIntegration(),
  globalHandlersIntegration(),

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.`);
  });
  }
  })

packages/deno/src/utils/streaming.ts

@@ -0,0 +1,104 @@
+import type { Span } from '@sentry/core';
+
+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 };
+}
+
+/**
+ * Tee a stream, and end the provided span when the stream ends.
+ * Returns the other side of the tee, which can be used to send the
+ * response to a client.
+ */
+export async function streamResponse(span: Span, res: Response): Promise<Response> {
+ const classification = classifyResponseStreaming(res);
+
+ // not streaming, just end the span and return the response
+ if (!classification.isStreaming || !res.body) {
+ span.end();
+ return res;
+ }
+
+ // Streaming response detected - monitor consumption to keep span alive
+ try {
+ return new Response(
+ monitorStream(res.body, () => span.end()),
+ {
+ status: res.status,
+ statusText: res.statusText,
+ headers: res.headers,
+ },
+ );
+ } catch (e) {
+ // tee() failed - handle without streaming
+ span.end();
+ return res;
+ }
+}
+
+/**
+ * zero-copy monitoring of stream progress.
+ */
+function monitorStream(
+ stream: ReadableStream<Uint8Array<ArrayBufferLike>>,
+ onDone: () => void,
+): ReadableStream<Uint8Array<ArrayBufferLike>> {
+ const reader = stream.getReader();
+ reader.closed.finally(() => onDone());
+ return new ReadableStream({
+ async start(controller) {
+ let result: ReadableStreamReadResult<Uint8Array<ArrayBufferLike>>;
+ do {
+ result = await reader.read();
+ if (result.value) {
+ try {
+ controller.enqueue(result.value);
+ } catch (er) {
+ controller.error(er);
+ reader.releaseLock();
+ return;
+ }
+ }
+ } while (!result.done);
+ controller.close();
+ reader.releaseLock();
+ },
+ });
+}

packages/deno/package.json

@@ -43,8 +43,8 @@
  "lint:es-compatibility": "es-check es2022 ./build/esm/*.js --module",
  "install:deno": "node ./scripts/install-deno.mjs",
  "test": "run-s install:deno deno-types test:unit",
- "test:unit": "deno test --allow-read --allow-run --allow-env --no-check",
- "test:unit:update": "deno test --allow-read --allow-write --allow-run -- --update",
+ "test:unit": "deno test --allow-net --allow-read --allow-run --allow-env --no-check",
+ "test:unit:update": "deno test --allow-net --allow-read --allow-run --allow-env --no-check --allow-write -- --update",
  "yalc:publish": "yalc publish --push --sig"
  },
  "volta": {

packages/deno/scripts/download-deno-types.mjs

@@ -2,6 +2,6 @@ import { existsSync, writeFileSync } from 'fs';
 import { download } from './download.mjs';
 
 if (!existsSync('lib.deno.d.ts')) {
- const code = await download('https://github.com/denoland/deno/releases/download/v2.1.5/lib.deno.d.ts');
+ const code = await download('https://github.com/denoland/deno/releases/download/v2.6.6/lib.deno.d.ts');
  writeFileSync('lib.deno.d.ts', code);
 }

packages/deno/src/async.ts

@@ -0,0 +1,80 @@
+// 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,
+ });
+}

packages/deno/src/index.ts

@@ -94,7 +94,7 @@ export {
 export { DenoClient } from './client';
 
 export { getDefaultIntegrations, init } from './sdk';
-
+export { denoServeIntegration } from './integrations/deno-serve';
 export { denoContextIntegration } from './integrations/context';
 export { globalHandlersIntegration } from './integrations/globalhandlers';
 export { normalizePathsIntegration } from './integrations/normalizepaths';

packages/deno/src/integrations/deno-serve.ts

@@ -0,0 +1,69 @@
+import type { IntegrationFn } from '@sentry/core';
+import { defineIntegration } from '@sentry/core';
+import { setAsyncLocalStorageAsyncContextStrategy } from '../async';
+import type { RequestHandlerWrapperOptions } from '../wrap-deno-request-handler';
+import { wrapDenoRequestHandler } from '../wrap-deno-request-handler';
+
+const INTEGRATION_NAME = 'DenoServe';
+
+export type ServeParams =
+ // [(Request) => Response]
+ | [Deno.ServeHandler<Deno.NetAddr>]
+ // [{ options }, (Request) => Response]
+ | [Deno.ServeUnixOptions, Deno.ServeHandler<Deno.UnixAddr>]
+ | [Deno.ServeVsockOptions, Deno.ServeHandler<Deno.VsockAddr>]
+ | [Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem), Deno.ServeHandler<Deno.NetAddr>]
+ // [{ handler: (Request) => Response }]
+ | [Deno.ServeUnixOptions & Deno.ServeInit<Deno.UnixAddr>]
+ | [Deno.ServeVsockOptions & Deno.ServeInit<Deno.VsockAddr>]
+ | [(Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem)) & Deno.ServeInit<Deno.NetAddr>];
+
+const isSimpleHandler = (p: ServeParams): p is [Deno.ServeHandler<Deno.Addr>] => typeof p[0] === 'function';
+
+const isServeOptWithFunction = (p: ServeParams): p is [Deno.ServeOptions<Deno.Addr>, Deno.ServeHandler<Deno.Addr>] =>
+ p.length >= 2 && typeof p[1] === 'function' && !!p[0] && typeof p[0] === 'object';
+
+const isServeInitOptions = (p: ServeParams): p is [Deno.ServeOptions<Deno.Addr> & Deno.ServeInit<Deno.Addr>] =>
+ typeof p[0] === 'object' &&
+ !!p[0] &&
+ !isServeOptWithFunction(p) &&
+ 'handler' in p[0] &&
+ typeof p[0].handler === 'function';
+
+const applyHandlerWrap = <A extends Deno.Addr>(
+ handler: (request: Request, info: Deno.ServeHandlerInfo<A>) => Response | Promise<Response>,
+ serveOptions?: Deno.ServeOptions,
+): Deno.ServeHandler =>
+ ((request, info) =>
+ wrapDenoRequestHandler<A>(
+ {
+ request,
+ info,
+ serveOptions,
+ } as RequestHandlerWrapperOptions<A>,
+ () => handler(request, info as Deno.ServeHandlerInfo<A>),
+ )) as Deno.ServeHandler;
+
+const _denoServeIntegration = (() => {
+ return {
+ name: INTEGRATION_NAME,
+ setupOnce() {
+ setAsyncLocalStorageAsyncContextStrategy();
+ Deno.serve = new Proxy(Deno.serve, {
+ apply(target, thisArg, args: ServeParams) {
+ if (isSimpleHandler(args)) {
+ args[0] = applyHandlerWrap(args[0]);
+ } else if (isServeOptWithFunction(args)) {
+ args[1] = applyHandlerWrap(args[1], args[0]);
+ } else if (isServeInitOptions(args)) {
+ args[0].handler = applyHandlerWrap(args[0].handler, args[0]);
+ }
+ // if none of those matched, it'll crash, most likely.
+ return target.apply(thisArg, args);
+ },
+ });
+ },
+ };
+}) satisfies IntegrationFn;
+
+export const denoServeIntegration = defineIntegration(_denoServeIntegration);

packages/deno/src/sdk.ts

@@ -8,12 +8,14 @@ import {
  initAndBind,
  linkedErrorsIntegration,
  nodeStackLineParser,
+ requestDataIntegration,
  stackParserFromStackParserOptions,
 } from '@sentry/core';
 import { DenoClient } from './client';
 import { breadcrumbsIntegration } from './integrations/breadcrumbs';
 import { denoContextIntegration } from './integrations/context';
 import { contextLinesIntegration } from './integrations/contextlines';
+import { denoServeIntegration } from './integrations/deno-serve';
 import { globalHandlersIntegration } from './integrations/globalhandlers';
 import { normalizePathsIntegration } from './integrations/normalizepaths';
 import { setupOpenTelemetryTracer } from './opentelemetry/tracer';
@@ -28,12 +30,14 @@ export function getDefaultIntegrations(_options: Options): Integration[] {
  // TODO(v11): Replace with `eventFiltersIntegration` once we remove the deprecated `inboundFiltersIntegration`
  // eslint-disable-next-line deprecation/deprecation
  inboundFiltersIntegration(),
+ requestDataIntegration(),
  functionToStringIntegration(),
  linkedErrorsIntegration(),
  dedupeIntegration(),
  // Deno Specific
  breadcrumbsIntegration(),
  denoContextIntegration(),
+ denoServeIntegration(),
  contextLinesIntegration(),
  normalizePathsIntegration(),
  globalHandlersIntegration(),

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.`);
  });
  }
  })

packages/deno/src/utils/streaming.ts

@@ -0,0 +1,104 @@
+import type { Span } from '@sentry/core';
+
+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 };
+}
+
+/**
+ * Tee a stream, and end the provided span when the stream ends.
+ * Returns the other side of the tee, which can be used to send the
+ * response to a client.
+ */
+export async function streamResponse(span: Span, res: Response): Promise<Response> {
+ const classification = classifyResponseStreaming(res);
+
+ // not streaming, just end the span and return the response
+ if (!classification.isStreaming || !res.body) {
+ span.end();
+ return res;
+ }
+
+ // Streaming response detected - monitor consumption to keep span alive
+ try {
+ return new Response(
+ monitorStream(res.body, () => span.end()),
+ {
+ status: res.status,
+ statusText: res.statusText,
+ headers: res.headers,
+ },
+ );
+ } catch (e) {
+ // tee() failed - handle without streaming
+ span.end();
+ return res;
+ }
+}
+
+/**
+ * zero-copy monitoring of stream progress.
+ */
+function monitorStream(
+ stream: ReadableStream<Uint8Array<ArrayBufferLike>>,
+ onDone: () => void,
+): ReadableStream<Uint8Array<ArrayBufferLike>> {
+ const reader = stream.getReader();
+ reader.closed.finally(() => onDone());
+ return new ReadableStream({
+ async start(controller) {
+ let result: ReadableStreamReadResult<Uint8Array<ArrayBufferLike>>;
+ do {
+ result = await reader.read();
+ if (result.value) {
+ try {
+ controller.enqueue(result.value);
+ } catch (er) {
+ controller.error(er);
+ reader.releaseLock();
+ return;
+ }
+ }
+ } while (!result.done);
+ controller.close();
+ reader.releaseLock();
+ },
+ });
+}

packages/deno/package.json

@@ -43,8 +43,8 @@
  "lint:es-compatibility": "es-check es2022 ./build/esm/*.js --module",
  "install:deno": "node ./scripts/install-deno.mjs",
  "test": "run-s install:deno deno-types test:unit",
- "test:unit": "deno test --allow-read --allow-run --allow-env --no-check",
- "test:unit:update": "deno test --allow-read --allow-write --allow-run -- --update",
+ "test:unit": "deno test --allow-net --allow-read --allow-run --allow-env --no-check",
+ "test:unit:update": "deno test --allow-net --allow-read --allow-run --allow-env --no-check --allow-write -- --update",
  "yalc:publish": "yalc publish --push --sig"
  },
  "volta": {

packages/deno/scripts/download-deno-types.mjs

@@ -2,6 +2,6 @@ import { existsSync, writeFileSync } from 'fs';
 import { download } from './download.mjs';
 
 if (!existsSync('lib.deno.d.ts')) {
- const code = await download('https://github.com/denoland/deno/releases/download/v2.1.5/lib.deno.d.ts');
+ const code = await download('https://github.com/denoland/deno/releases/download/v2.6.6/lib.deno.d.ts');
  writeFileSync('lib.deno.d.ts', code);
 }

packages/deno/src/async.ts

@@ -0,0 +1,80 @@
+// 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,
+ });
+}

packages/deno/src/index.ts

@@ -94,7 +94,7 @@ export {
 export { DenoClient } from './client';
 
 export { getDefaultIntegrations, init } from './sdk';
-
+export { denoServeIntegration } from './integrations/deno-serve';
 export { denoContextIntegration } from './integrations/context';
 export { globalHandlersIntegration } from './integrations/globalhandlers';
 export { normalizePathsIntegration } from './integrations/normalizepaths';

packages/deno/src/integrations/deno-serve.ts

@@ -0,0 +1,69 @@
+import type { IntegrationFn } from '@sentry/core';
+import { defineIntegration } from '@sentry/core';
+import { setAsyncLocalStorageAsyncContextStrategy } from '../async';
+import type { RequestHandlerWrapperOptions } from '../wrap-deno-request-handler';
+import { wrapDenoRequestHandler } from '../wrap-deno-request-handler';
+
+const INTEGRATION_NAME = 'DenoServe';
+
+export type ServeParams =
+ // [(Request) => Response]
+ | [Deno.ServeHandler<Deno.NetAddr>]
+ // [{ options }, (Request) => Response]
+ | [Deno.ServeUnixOptions, Deno.ServeHandler<Deno.UnixAddr>]
+ | [Deno.ServeVsockOptions, Deno.ServeHandler<Deno.VsockAddr>]
+ | [Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem), Deno.ServeHandler<Deno.NetAddr>]
+ // [{ handler: (Request) => Response }]
+ | [Deno.ServeUnixOptions & Deno.ServeInit<Deno.UnixAddr>]
+ | [Deno.ServeVsockOptions & Deno.ServeInit<Deno.VsockAddr>]
+ | [(Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem)) & Deno.ServeInit<Deno.NetAddr>];
+
+const isSimpleHandler = (p: ServeParams): p is [Deno.ServeHandler<Deno.Addr>] => typeof p[0] === 'function';
+
+const isServeOptWithFunction = (p: ServeParams): p is [Deno.ServeOptions<Deno.Addr>, Deno.ServeHandler<Deno.Addr>] =>
+ p.length >= 2 && typeof p[1] === 'function' && !!p[0] && typeof p[0] === 'object';
+
+const isServeInitOptions = (p: ServeParams): p is [Deno.ServeOptions<Deno.Addr> & Deno.ServeInit<Deno.Addr>] =>
+ typeof p[0] === 'object' &&
+ !!p[0] &&
+ !isServeOptWithFunction(p) &&
+ 'handler' in p[0] &&
+ typeof p[0].handler === 'function';
+
+const applyHandlerWrap = <A extends Deno.Addr>(
+ handler: (request: Request, info: Deno.ServeHandlerInfo<A>) => Response | Promise<Response>,
+ serveOptions?: Deno.ServeOptions,
+): Deno.ServeHandler =>
+ ((request, info) =>
+ wrapDenoRequestHandler<A>(
+ {
+ request,
+ info,
+ serveOptions,
+ } as RequestHandlerWrapperOptions<A>,
+ () => handler(request, info as Deno.ServeHandlerInfo<A>),
+ )) as Deno.ServeHandler;
+
+const _denoServeIntegration = (() => {
+ return {
+ name: INTEGRATION_NAME,
+ setupOnce() {
+ setAsyncLocalStorageAsyncContextStrategy();
+ Deno.serve = new Proxy(Deno.serve, {
+ apply(target, thisArg, args: ServeParams) {
+ if (isSimpleHandler(args)) {
+ args[0] = applyHandlerWrap(args[0]);
+ } else if (isServeOptWithFunction(args)) {
+ args[1] = applyHandlerWrap(args[1], args[0]);
+ } else if (isServeInitOptions(args)) {
+ args[0].handler = applyHandlerWrap(args[0].handler, args[0]);
+ }
+ // if none of those matched, it'll crash, most likely.
+ return target.apply(thisArg, args);
+ },
+ });
+ },
+ };
+}) satisfies IntegrationFn;
+
+export const denoServeIntegration = defineIntegration(_denoServeIntegration);

packages/deno/src/sdk.ts

@@ -8,12 +8,14 @@ import {
  initAndBind,
  linkedErrorsIntegration,
  nodeStackLineParser,
+ requestDataIntegration,
  stackParserFromStackParserOptions,
 } from '@sentry/core';
 import { DenoClient } from './client';
 import { breadcrumbsIntegration } from './integrations/breadcrumbs';
 import { denoContextIntegration } from './integrations/context';
 import { contextLinesIntegration } from './integrations/contextlines';
+import { denoServeIntegration } from './integrations/deno-serve';
 import { globalHandlersIntegration } from './integrations/globalhandlers';
 import { normalizePathsIntegration } from './integrations/normalizepaths';
 import { setupOpenTelemetryTracer } from './opentelemetry/tracer';
@@ -28,12 +30,14 @@ export function getDefaultIntegrations(_options: Options): Integration[] {
  // TODO(v11): Replace with `eventFiltersIntegration` once we remove the deprecated `inboundFiltersIntegration`
  // eslint-disable-next-line deprecation/deprecation
  inboundFiltersIntegration(),
+ requestDataIntegration(),
  functionToStringIntegration(),
  linkedErrorsIntegration(),
  dedupeIntegration(),
  // Deno Specific
  breadcrumbsIntegration(),
  denoContextIntegration(),
+ denoServeIntegration(),
  contextLinesIntegration(),
  normalizePathsIntegration(),
  globalHandlersIntegration(),

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.`);
  });
  }
  })

packages/deno/src/utils/streaming.ts

@@ -0,0 +1,104 @@
+import type { Span } from '@sentry/core';
+
+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 };
+}
+
+/**
+ * Tee a stream, and end the provided span when the stream ends.
+ * Returns the other side of the tee, which can be used to send the
+ * response to a client.
+ */
+export async function streamResponse(span: Span, res: Response): Promise<Response> {
+ const classification = classifyResponseStreaming(res);
+
+ // not streaming, just end the span and return the response
+ if (!classification.isStreaming || !res.body) {
+ span.end();
+ return res;
+ }
+
+ // Streaming response detected - monitor consumption to keep span alive
+ try {
+ return new Response(
+ monitorStream(res.body, () => span.end()),
+ {
+ status: res.status,
+ statusText: res.statusText,
+ headers: res.headers,
+ },
+ );
+ } catch (e) {
+ // tee() failed - handle without streaming
+ span.end();
+ return res;
+ }
+}
+
+/**
+ * zero-copy monitoring of stream progress.
+ */
+function monitorStream(
+ stream: ReadableStream<Uint8Array<ArrayBufferLike>>,
+ onDone: () => void,
+): ReadableStream<Uint8Array<ArrayBufferLike>> {
+ const reader = stream.getReader();
+ reader.closed.finally(() => onDone());
+ return new ReadableStream({
+ async start(controller) {
+ let result: ReadableStreamReadResult<Uint8Array<ArrayBufferLike>>;
+ do {
+ result = await reader.read();
+ if (result.value) {
+ try {
+ controller.enqueue(result.value);
+ } catch (er) {
+ controller.error(er);
+ reader.releaseLock();
+ return;
+ }
+ }
+ } while (!result.done);
+ controller.close();
+ reader.releaseLock();
+ },
+ });
+}

packages/deno/package.json

@@ -43,8 +43,8 @@
  "lint:es-compatibility": "es-check es2022 ./build/esm/*.js --module",
  "install:deno": "node ./scripts/install-deno.mjs",
  "test": "run-s install:deno deno-types test:unit",
- "test:unit": "deno test --allow-read --allow-run --allow-env --no-check",
- "test:unit:update": "deno test --allow-read --allow-write --allow-run -- --update",
+ "test:unit": "deno test --allow-net --allow-read --allow-run --allow-env --no-check",
+ "test:unit:update": "deno test --allow-net --allow-read --allow-run --allow-env --no-check --allow-write -- --update",
  "yalc:publish": "yalc publish --push --sig"
  },
  "volta": {

packages/deno/scripts/download-deno-types.mjs

@@ -2,6 +2,6 @@ import { existsSync, writeFileSync } from 'fs';
 import { download } from './download.mjs';
 
 if (!existsSync('lib.deno.d.ts')) {
- const code = await download('https://github.com/denoland/deno/releases/download/v2.1.5/lib.deno.d.ts');
+ const code = await download('https://github.com/denoland/deno/releases/download/v2.6.6/lib.deno.d.ts');
  writeFileSync('lib.deno.d.ts', code);
 }

packages/deno/src/async.ts

@@ -0,0 +1,80 @@
+// 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,
+ });
+}

packages/deno/src/index.ts

@@ -94,7 +94,7 @@ export {
 export { DenoClient } from './client';
 
 export { getDefaultIntegrations, init } from './sdk';
-
+export { denoServeIntegration } from './integrations/deno-serve';
 export { denoContextIntegration } from './integrations/context';
 export { globalHandlersIntegration } from './integrations/globalhandlers';
 export { normalizePathsIntegration } from './integrations/normalizepaths';

packages/deno/src/integrations/deno-serve.ts

@@ -0,0 +1,69 @@
+import type { IntegrationFn } from '@sentry/core';
+import { defineIntegration } from '@sentry/core';
+import { setAsyncLocalStorageAsyncContextStrategy } from '../async';
+import type { RequestHandlerWrapperOptions } from '../wrap-deno-request-handler';
+import { wrapDenoRequestHandler } from '../wrap-deno-request-handler';
+
+const INTEGRATION_NAME = 'DenoServe';
+
+export type ServeParams =
+ // [(Request) => Response]
+ | [Deno.ServeHandler<Deno.NetAddr>]
+ // [{ options }, (Request) => Response]
+ | [Deno.ServeUnixOptions, Deno.ServeHandler<Deno.UnixAddr>]
+ | [Deno.ServeVsockOptions, Deno.ServeHandler<Deno.VsockAddr>]
+ | [Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem), Deno.ServeHandler<Deno.NetAddr>]
+ // [{ handler: (Request) => Response }]
+ | [Deno.ServeUnixOptions & Deno.ServeInit<Deno.UnixAddr>]
+ | [Deno.ServeVsockOptions & Deno.ServeInit<Deno.VsockAddr>]
+ | [(Deno.ServeTcpOptions | (Deno.ServeTcpOptions & Deno.TlsCertifiedKeyPem)) & Deno.ServeInit<Deno.NetAddr>];
+
+const isSimpleHandler = (p: ServeParams): p is [Deno.ServeHandler<Deno.Addr>] => typeof p[0] === 'function';
+
+const isServeOptWithFunction = (p: ServeParams): p is [Deno.ServeOptions<Deno.Addr>, Deno.ServeHandler<Deno.Addr>] =>
+ p.length >= 2 && typeof p[1] === 'function' && !!p[0] && typeof p[0] === 'object';
+
+const isServeInitOptions = (p: ServeParams): p is [Deno.ServeOptions<Deno.Addr> & Deno.ServeInit<Deno.Addr>] =>
+ typeof p[0] === 'object' &&
+ !!p[0] &&
+ !isServeOptWithFunction(p) &&
+ 'handler' in p[0] &&
+ typeof p[0].handler === 'function';
+
+const applyHandlerWrap = <A extends Deno.Addr>(
+ handler: (request: Request, info: Deno.ServeHandlerInfo<A>) => Response | Promise<Response>,
+ serveOptions?: Deno.ServeOptions,
+): Deno.ServeHandler =>
+ ((request, info) =>
+ wrapDenoRequestHandler<A>(
+ {
+ request,
+ info,
+ serveOptions,
+ } as RequestHandlerWrapperOptions<A>,
+ () => handler(request, info as Deno.ServeHandlerInfo<A>),
+ )) as Deno.ServeHandler;
+
+const _denoServeIntegration = (() => {
+ return {
+ name: INTEGRATION_NAME,
+ setupOnce() {
+ setAsyncLocalStorageAsyncContextStrategy();
+ Deno.serve = new Proxy(Deno.serve, {
+ apply(target, thisArg, args: ServeParams) {
+ if (isSimpleHandler(args)) {
+ args[0] = applyHandlerWrap(args[0]);
+ } else if (isServeOptWithFunction(args)) {
+ args[1] = applyHandlerWrap(args[1], args[0]);
+ } else if (isServeInitOptions(args)) {
+ args[0].handler = applyHandlerWrap(args[0].handler, args[0]);
+ }
+ // if none of those matched, it'll crash, most likely.
+ return target.apply(thisArg, args);
+ },
+ });
+ },
+ };
+}) satisfies IntegrationFn;
+
+export const denoServeIntegration = defineIntegration(_denoServeIntegration);

packages/deno/src/sdk.ts

@@ -8,12 +8,14 @@ import {
  initAndBind,
  linkedErrorsIntegration,
  nodeStackLineParser,
+ requestDataIntegration,
  stackParserFromStackParserOptions,
 } from '@sentry/core';
 import { DenoClient } from './client';
 import { breadcrumbsIntegration } from './integrations/breadcrumbs';
 import { denoContextIntegration } from './integrations/context';
 import { contextLinesIntegration } from './integrations/contextlines';
+import { denoServeIntegration } from './integrations/deno-serve';
 import { globalHandlersIntegration } from './integrations/globalhandlers';
 import { normalizePathsIntegration } from './integrations/normalizepaths';
 import { setupOpenTelemetryTracer } from './opentelemetry/tracer';
@@ -28,12 +30,14 @@ export function getDefaultIntegrations(_options: Options): Integration[] {
  // TODO(v11): Replace with `eventFiltersIntegration` once we remove the deprecated `inboundFiltersIntegration`
  // eslint-disable-next-line deprecation/deprecation
  inboundFiltersIntegration(),
+ requestDataIntegration(),
  functionToStringIntegration(),
  linkedErrorsIntegration(),
  dedupeIntegration(),
  // Deno Specific
  breadcrumbsIntegration(),
  denoContextIntegration(),
+ denoServeIntegration(),
  contextLinesIntegration(),
  normalizePathsIntegration(),
  globalHandlersIntegration(),

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.`);
  });
  }
  })

packages/deno/src/utils/streaming.ts

@@ -0,0 +1,104 @@
+import type { Span } from '@sentry/core';
+
+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 };
+}
+
+/**
+ * Tee a stream, and end the provided span when the stream ends.
+ * Returns the other side of the tee, which can be used to send the
+ * response to a client.
+ */
+export async function streamResponse(span: Span, res: Response): Promise<Response> {
+ const classification = classifyResponseStreaming(res);
+
+ // not streaming, just end the span and return the response
+ if (!classification.isStreaming || !res.body) {
+ span.end();
+ return res;
+ }
+
+ // Streaming response detected - monitor consumption to keep span alive
+ try {
+ return new Response(
+ monitorStream(res.body, () => span.end()),
+ {
+ status: res.status,
+ statusText: res.statusText,
+ headers: res.headers,
+ },
+ );
+ } catch (e) {
+ // tee() failed - handle without streaming
+ span.end();
+ return res;
+ }
+}
+
+/**
+ * zero-copy monitoring of stream progress.
+ */
+function monitorStream(
+ stream: ReadableStream<Uint8Array<ArrayBufferLike>>,
+ onDone: () => void,
+): ReadableStream<Uint8Array<ArrayBufferLike>> {
+ const reader = stream.getReader();
+ reader.closed.finally(() => onDone());
+ return new ReadableStream({
+ async start(controller) {
+ let result: ReadableStreamReadResult<Uint8Array<ArrayBufferLike>>;
+ do {
+ result = await reader.read();
+ if (result.value) {
+ try {
+ controller.enqueue(result.value);
+ } catch (er) {
+ controller.error(er);
+ reader.releaseLock();
+ return;
+ }
+ }
+ } while (!result.done);
+ controller.close();
+ reader.releaseLock();
+ },
+ });
+}