feat(deno): include all orchestrion integrations

Automatically pull in all orchestrion integrations defined in
server-utils into the Deno SDK.

Move the `setAsyncLocalStorageAsyncContextStrategy()` into the Deno SDK
init method, since it's eventually called by any client that uses even
the default set of integrations anyway.

Consume the list of integrations from @sentry/server-utils, so that any
new integrations that are added will automatically get picked up by the
Deno SDK, without having another piece to keep in sync and remember to
add.

The existing wrapped-and-renamed integrations are deprecated, but still
on by default, warning that their names will change in v11. As this will
be a breaking change, it's not added here, but a `todo` note is added to
remind us to make it a plain alias in the next major.

Closes #21225
Closes JS-2634

Author: isaacs

dev-packages/deno-integration-tests/suites/orchestrion-mysql/test.ts

@@ -95,8 +95,8 @@ Deno.test('@sentry/deno/import: transforms mysql so it publishes the orchestrion
   assert(line.includes('"runtime":["mysql"]'), `expected runtime marker, got: ${line}`);
 });
 
-// Exercises the SDK path end-to-end: `init()` wires `denoMysqlIntegration`
-// (which installs the AsyncLocalStorage context strategy and subscribes to the
+// Exercises the SDK path end-to-end: `init()` installs the AsyncLocalStorage
+// context strategy and wires `denoMysqlIntegration` (which subscribes to the
 // channel), and we drive the `orchestrion:mysql:query` channel manually — the
 // same events the orchestrion transform publishes around `connection.query()` —
 // so no live database is needed. Asserting a nested `db` span proves the

dev-packages/deno-integration-tests/suites/orchestrion-postgres/test.ts

@@ -95,8 +95,8 @@ Deno.test('@sentry/deno/import: transforms pg so it publishes the orchestrion ch
   assert(line.includes('"runtime":["pg","pg-pool"]'), `expected runtime marker, got: ${line}`);
 });
 
-// Exercises the SDK path end-to-end: `init()` wires `denoPostgresIntegration`
-// (which installs the AsyncLocalStorage context strategy and subscribes to the
+// Exercises the SDK path end-to-end: `init()` installs the AsyncLocalStorage
+// context strategy and wires `denoPostgresIntegration` (which subscribes to the
 // channel), and we drive the `orchestrion:pg:query` channel manually — the
 // same events the orchestrion transform publishes around `client.query()` —
 // so no live database is needed. Asserting a nested `db` span proves the

packages/deno/src/index.ts

@@ -111,14 +111,24 @@ export { denoHttpIntegration } from './integrations/http';
 export type { DenoHttpIntegrationOptions } from './integrations/http';
 export { denoRedisIntegration } from './integrations/redis';
 export type { DenoRedisIntegrationOptions } from './integrations/redis';
+// Deprecated: these default integrations are renamed (`Deno*` → the shared name) in the next major;
+// re-exported until then. See each integration's `@deprecated` note.
+/* eslint-disable typescript/no-deprecated */
 export { denoMysqlIntegration } from './integrations/mysql';
 export { denoPostgresIntegration } from './integrations/postgres';
 export { denoAmqplibIntegration } from './integrations/amqplib';
-export { denoDataloaderIntegration } from './integrations/dataloader';
-export { denoKnexIntegration } from './integrations/knex';
 export { denoKoaIntegration } from './integrations/koa';
 export { denoMongoIntegration } from './integrations/mongo';
 export { denoMongooseIntegration } from './integrations/mongoose';
+/* eslint-enable typescript/no-deprecated */
+export { dataloaderChannelIntegration, knexChannelIntegration } from '@sentry/server-utils/orchestrion';
+// The deprecated `denoDataloaderIntegration`/`denoKnexIntegration` wrappers are
+// superseded by the universal integrations re-exported above, but kept for
+// back-compat.
+/* eslint-disable typescript/no-deprecated */
+export { denoDataloaderIntegration } from './integrations/dataloader';
+export { denoKnexIntegration } from './integrations/knex';
+/* eslint-enable typescript/no-deprecated */
 export { denoContextIntegration } from './integrations/context';
 export { globalHandlersIntegration } from './integrations/globalhandlers';
 export { normalizePathsIntegration } from './integrations/normalizepaths';

packages/deno/src/integrations/amqplib.ts

@@ -1,33 +1,26 @@
 import { amqplibChannelIntegration } from '@sentry/server-utils/orchestrion';
 import type { Integration, IntegrationFn } from '@sentry/core';
 import { defineIntegration, extendIntegration } from '@sentry/core';
-import { setAsyncLocalStorageAsyncContextStrategy } from '../async';
 
 const INTEGRATION_NAME = 'DenoAmqplib' as const;
 
-/**
- * Create spans for `amqplib` publish/consume operations under Deno.
- *
- * `amqplib` channels are injected by the orchestrion runtime hook at load time.
- * The `@sentry/deno/import` loader must be active for this integration to
- * record anything.
- *
- * The channel-subscription logic is shared with the other server runtimes in
- * `@sentry/server-utils`. This just installs Deno's `AsyncLocalStorage` context
- * strategy (so spans nest under the active span and survive amqplib's internal
- * callback dispatch) before delegating.
- */
 const _denoAmqplibIntegration = (() => {
-  const inner = amqplibChannelIntegration();
-
-  return extendIntegration(inner, {
+  return extendIntegration(amqplibChannelIntegration(), {
     name: INTEGRATION_NAME,
-    setupOnce() {
-      setAsyncLocalStorageAsyncContextStrategy();
-    },
   });
 }) satisfies IntegrationFn;
 
+// TODO(v11): turn wrapping into plain alias
+/**
+ * Create spans for `amqplib` publish/consume operations under Deno.
+ * Included in the default integrations.
+ *
+ * @deprecated In the next major this wrapper is removed and `amqplib` is
+ * instrumented by the shared `amqplibChannelIntegration` directly, so the
+ * default integration's name changes from `DenoAmqplib` to `Amqplib`.
+ * If you reference it by name (e.g. to disable it), update `'DenoAmqplib'` to
+ * `'Amqplib'`.
+ */
 export const denoAmqplibIntegration = defineIntegration(_denoAmqplibIntegration) as () => Integration & {
   name: 'DenoAmqplib';
   setupOnce: () => void;

packages/deno/src/integrations/dataloader.ts

@@ -1,33 +1,22 @@
 import { dataloaderChannelIntegration } from '@sentry/server-utils/orchestrion';
 import type { Integration, IntegrationFn } from '@sentry/core';
 import { defineIntegration, extendIntegration } from '@sentry/core';
-import { setAsyncLocalStorageAsyncContextStrategy } from '../async';
 
 const INTEGRATION_NAME = 'DenoDataloader' as const;
 
-/**
- * Create spans for `dataloader` load/batch operations under Deno.
- *
- * `dataloader` channels are injected by the orchestrion runtime hook at load time.
- * The `@sentry/deno/import` loader must be active for this integration to
- * record anything.
- *
- * The channel-subscription logic is shared with the other server runtimes in
- * `@sentry/server-utils`. This just installs Deno's `AsyncLocalStorage` context
- * strategy (so spans nest under the active span and survive dataloader's deferred
- * batch dispatch) before delegating.
- */
 const _denoDataloaderIntegration = (() => {
-  const inner = dataloaderChannelIntegration();
-
-  return extendIntegration(inner, {
+  return extendIntegration(dataloaderChannelIntegration(), {
     name: INTEGRATION_NAME,
-    setupOnce() {
-      setAsyncLocalStorageAsyncContextStrategy();
-    },
   });
 }) satisfies IntegrationFn;
 
+/**
+ * Create spans for `dataloader` load/batch operations under Deno.
+ *
+ * @deprecated `dataloaderChannelIntegration` is now available directly, so this
+ * wrapper is redundant and will be removed in a future major. Use it (or the
+ * shared `dataloaderChannelIntegration`) instead.
+ */
 export const denoDataloaderIntegration = defineIntegration(_denoDataloaderIntegration) as () => Integration & {
   name: 'DenoDataloader';
   setupOnce: () => void;

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

@@ -1,6 +1,5 @@
 import type { IntegrationFn } from '@sentry/core';
 import { debug, defineIntegration } from '@sentry/core';
-import { setAsyncLocalStorageAsyncContextStrategy } from '../async';
 import type { RequestHandlerWrapperOptions } from '../wrap-deno-request-handler';
 import { wrapDenoRequestHandler } from '../wrap-deno-request-handler';
 
@@ -63,8 +62,6 @@ const _denoServeIntegration = (() => {
   return {
     name: INTEGRATION_NAME,
     setupOnce() {
-      setAsyncLocalStorageAsyncContextStrategy();
-
       const originalServe = Deno.serve;
       const wrappedServe = instrumentedDenoServe(originalServe);
 

packages/deno/src/integrations/http.ts

@@ -11,7 +11,6 @@ import {
   HTTP_ON_CLIENT_REQUEST,
   HTTP_ON_SERVER_REQUEST,
 } from '@sentry/core';
-import { setAsyncLocalStorageAsyncContextStrategy } from '../async';
 import {
   DENO_VERSION,
   HTTP_CLIENT_DIAGNOSTICS_CHANNEL_SUPPORTED,
@@ -111,11 +110,6 @@ const _denoHttpIntegration = ((options: DenoHttpIntegrationOptions = {}) => {
         return;
       }
 
-      // Wire up Deno's AsyncLocalStorage-backed ACS so the server subscription's
-      // `withIsolationScope(clone, ...)` actually activates the cloned scope.
-      // Without this, request isolation and span creation degrade silently.
-      setAsyncLocalStorageAsyncContextStrategy();
-
       if (HTTP_SERVER_DIAGNOSTICS_CHANNEL_SUPPORTED) {
         const { [HTTP_ON_SERVER_REQUEST]: onHttpServerRequest } = getHttpServerSubscriptions({
           // `spans` falls through to the client's tracing config when unset.

packages/deno/src/integrations/knex.ts

@@ -1,33 +1,22 @@
 import { knexChannelIntegration } from '@sentry/server-utils/orchestrion';
 import type { Integration, IntegrationFn } from '@sentry/core';
 import { defineIntegration, extendIntegration } from '@sentry/core';
-import { setAsyncLocalStorageAsyncContextStrategy } from '../async';
 
 const INTEGRATION_NAME = 'DenoKnex' as const;
 
-/**
- * Create spans for `knex` queries under Deno.
- *
- * `knex` channels are injected by the orchestrion runtime hook at load time.
- * The `@sentry/deno/import` loader must be active for this integration to
- * record anything.
- *
- * The channel-subscription logic is shared with the other server runtimes in
- * `@sentry/server-utils`. This just installs Deno's
- * `AsyncLocalStorage` context strategy (so spans nest under the active
- * span and survive knex's internal callback dispatch) before delegating.
- */
 const _denoKnexIntegration = (() => {
-  const inner = knexChannelIntegration();
-
-  return extendIntegration(inner, {
+  return extendIntegration(knexChannelIntegration(), {
     name: INTEGRATION_NAME,
-    setupOnce() {
-      setAsyncLocalStorageAsyncContextStrategy();
-    },
   });
 }) satisfies IntegrationFn;
 
+/**
+ * Create spans for `knex` queries under Deno.
+ *
+ * @deprecated `knexChannelIntegration` is now available directly, so this
+ * wrapper is redundant and will be removed in a future major. Use
+ * `knexChannelIntegration` instead.
+ */
 export const denoKnexIntegration = defineIntegration(_denoKnexIntegration) as () => Integration & {
   name: 'DenoKnex';
   setupOnce: () => void;

packages/deno/src/integrations/koa.ts

@@ -2,27 +2,26 @@ import { koaChannelIntegration } from '@sentry/server-utils/orchestrion';
 import type { KoaChannelIntegrationOptions } from '@sentry/server-utils/orchestrion';
 import type { Integration, IntegrationFn } from '@sentry/core';
 import { defineIntegration, extendIntegration } from '@sentry/core';
-import { setAsyncLocalStorageAsyncContextStrategy } from '../async';
 
 const INTEGRATION_NAME = 'DenoKoa' as const;
 
-/**
- * Create spans for `koa` middleware/router layers under Deno. Requires the
- * `@sentry/deno/import` loader. Delegates to the shared subscriber in
- * `@sentry/server-utils`, adding Deno's `AsyncLocalStorage` context strategy so
- * spans nest under the active HTTP server span.
- */
 const _denoKoaIntegration = ((options: KoaChannelIntegrationOptions = {}) => {
-  const inner = koaChannelIntegration(options);
-
-  return extendIntegration(inner, {
+  return extendIntegration(koaChannelIntegration(options), {
     name: INTEGRATION_NAME,
-    setupOnce() {
-      setAsyncLocalStorageAsyncContextStrategy();
-    },
   });
 }) satisfies IntegrationFn;
 
+// TODO(v11): turn wrapping into plain alias
+/**
+ * Create spans for `koa` middleware/router layers under Deno.
+ * Included in the default integrations.
+ *
+ * @deprecated In the next major this wrapper is removed and `koa` is
+ * instrumented by the shared `koaChannelIntegration` directly, so the
+ * default integration's name changes from `DenoKoa` to `Koa`.
+ * If you reference it by name (e.g. to disable it), update `'DenoKoa'` to
+ * `'Koa'`.
+ */
 export const denoKoaIntegration = defineIntegration(_denoKoaIntegration) as (
   options?: KoaChannelIntegrationOptions,
 ) => Integration & {

packages/deno/src/integrations/mongo.ts

@@ -1,33 +1,26 @@
 import { mongodbChannelIntegration } from '@sentry/server-utils/orchestrion';
 import type { Integration, IntegrationFn } from '@sentry/core';
 import { defineIntegration, extendIntegration } from '@sentry/core';
-import { setAsyncLocalStorageAsyncContextStrategy } from '../async';
 
 const INTEGRATION_NAME = 'DenoMongo' as const;
 
-/**
- * Create spans for `mongodb` queries under Deno.
- *
- * `mongodb` channels are injected by the orchestrion runtime hook at load time.
- * The `@sentry/deno/import` loader must be active for this integration to
- * record anything.
- *
- * The channel-subscription logic is shared with the other server runtimes in
- * `@sentry/server-utils`. This just installs Deno's
- * `AsyncLocalStorage` context strategy (so spans nest under the active
- * span and survive mongodb's internal callback dispatch) before delegating.
- */
 const _denoMongoIntegration = (() => {
-  const inner = mongodbChannelIntegration();
-
-  return extendIntegration(inner, {
+  return extendIntegration(mongodbChannelIntegration(), {
     name: INTEGRATION_NAME,
-    setupOnce() {
-      setAsyncLocalStorageAsyncContextStrategy();
-    },
   });
 }) satisfies IntegrationFn;
 
+// TODO(v11): turn wrapping into plain alias
+/**
+ * Create spans for `mongodb` queries under Deno.
+ * Included in the default integrations.
+ *
+ * @deprecated In the next major this wrapper is removed and `mongodb` is
+ * instrumented by the shared `mongodbChannelIntegration` directly, so the
+ * default integration's name changes from `DenoMongo` to `Mongo`.
+ * If you reference it by name (e.g. to disable it), update `'DenoMongo'` to
+ * `'Mongo'`.
+ */
 export const denoMongoIntegration = defineIntegration(_denoMongoIntegration) as () => Integration & {
   name: 'DenoMongo';
   setupOnce: () => void;