feat(node): Always set up express, fastify, koa, hapi integrations (#23473)

These integrations may also do non-tracing related things (e.g. error
capturing etc), so they should be added by default.
This also means that we always want to add the orchestrion runtime, even
in non-tracing mode.

Instead, I added a flag `enableRuntimeChannelInjection` to opt-out of
this behavior if needed.

Also added these three as defaults to deno and bun, to mirror this.

Additionally, this unifies the integrations we add into
`getErrorIntegrations()` and `getTracingIntegrations()`, so we can
re-use this in node, deno and bun. It also adds awsIntegration to the
tracing set so this is also added in all scenarios now.

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: mydea

.size-limit.js

@@ -430,7 +430,7 @@ module.exports = [
     path: 'packages/node/build/esm/index.js',
     import: createImport('initWithoutDefaultIntegrations', 'getDefaultIntegrationsWithoutPerformance'),
     gzip: true,
-    limit: '87 KB',
+    limit: '92 KB',
     disablePlugins: ['@size-limit/esbuild'],
     ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
     modifyWebpackConfig: function (config) {
@@ -454,7 +454,7 @@ module.exports = [
     import: createImport('init'),
     ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
     gzip: true,
-    limit: '97 KB',
+    limit: '99 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   // Cloudflare SDK (ESM) - compressed, minified to match `wrangler deploy --dry-run --minify` output

dev-packages/deno-integration-tests/src/index.ts

@@ -1,4 +1,4 @@
-import type { TransactionEvent } from '@sentry/core';
+import type { Event, TransactionEvent } from '@sentry/core';
 import { getAsyncContextStrategy, getMainCarrier, setAsyncContextStrategy } from '@sentry/core';
 
 /**
@@ -16,41 +16,64 @@ export function resetGlobals(): void {
   setAsyncContextStrategy(acs);
 }
 
-export interface TransactionSink {
-  beforeSendTransaction: (event: TransactionEvent) => null;
-  waitFor: (predicate: (event: TransactionEvent) => boolean) => Promise<TransactionEvent>;
+interface EventSink<T> {
+  beforeSend: (event: T) => null;
+  waitFor: (predicate: (event: T) => boolean) => Promise<T>;
 }
 
-/**
- * A `beforeSendTransaction` hook that records every transaction and lets a test
- * `await` the first one matching a predicate. `waitFor` resolves immediately if
- * a match already arrived, so there is no ordering race with the hook.
- */
-export function transactionSink(): TransactionSink {
-  const transactions: TransactionEvent[] = [];
-  const waiters: { predicate: (e: TransactionEvent) => boolean; resolve: (e: TransactionEvent) => void }[] = [];
+function eventSink<T>(): EventSink<T> {
+  const events: T[] = [];
+  const waiters: { predicate: (e: T) => boolean; resolve: (e: T) => void }[] = [];
   return {
-    beforeSendTransaction(event) {
-      transactions.push(event);
+    beforeSend(event) {
+      events.push(event);
+
       for (let i = waiters.length - 1; i >= 0; i--) {
         const w = waiters[i]!;
         if (w.predicate(event)) {
           waiters.splice(i, 1);
           w.resolve(event);
         }
       }
+
       return null;
     },
     waitFor(predicate) {
-      const already = transactions.find(predicate);
+      const already = events.find(predicate);
       if (already) return Promise.resolve(already);
-      return new Promise<TransactionEvent>(resolve => {
+      return new Promise<T>(resolve => {
         waiters.push({ predicate, resolve });
       });
     },
   };
 }
 
+/**
+ * A `beforeSend` hook that records every transaction event and lets a test
+ * `await` the first one matching a predicate. `waitFor` resolves immediately if
+ * a match already arrived, so there is no ordering race with the hook.
+ */
+export function transactionSink(): {
+  waitFor: (predicate: (event: TransactionEvent) => boolean) => Promise<TransactionEvent>;
+  beforeSendTransaction: (event: TransactionEvent) => null;
+} {
+  const sink = eventSink<TransactionEvent>();
+
+  return {
+    waitFor: sink.waitFor,
+    beforeSendTransaction: sink.beforeSend,
+  };
+}
+
+/**
+ * A `beforeSend` hook that records every error and lets a test
+ * `await` the first one matching a predicate. `waitFor` resolves immediately if
+ * a match already arrived, so there is no ordering race with the hook.
+ */
+export function errorSink(): EventSink<Event> {
+  return eventSink<Event>();
+}
+
 /** Reject with a descriptive message if `p` does not settle within `ms`. */
 export function withTimeout<T>(p: Promise<T>, ms: number, what: string): Promise<T> {
   let timer: ReturnType<typeof setTimeout> | undefined;

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

@@ -0,0 +1,47 @@
+// <reference lib="deno.ns" />
+
+import { channel } from 'node:diagnostics_channel';
+import type { DenoClient } from '@sentry/deno';
+import { init } from '@sentry/deno';
+import { assert } from 'https://deno.land/std@0.212.0/assert/assert.ts';
+import { assertEquals } from 'https://deno.land/std@0.212.0/assert/assert_equals.ts';
+import { assertExists } from 'https://deno.land/std@0.212.0/assert/assert_exists.ts';
+import { errorSink, resetGlobals, withTimeout } from '../../src/index.ts';
+
+Deno.test('fastify instrumentation: included in default integrations (Deno 2.8.0+)', () => {
+  resetGlobals();
+  const client = init({ traceLifecycle: 'static', dsn: 'https://username@domain/123' }) as DenoClient;
+  const names = client.getOptions().integrations.map(i => i.name);
+  assert(names.includes('Fastify'), `Fastify should be in defaults, got ${names.join(', ')}`);
+});
+
+Deno.test('fastify instrumentation: tracing:fastify.request.handler:error channel captures the error', async () => {
+  resetGlobals();
+  const sink = errorSink();
+  init({
+    traceLifecycle: 'static',
+    dsn: 'https://username@domain/123',
+    beforeSend: sink.beforeSend,
+  });
+
+  const error = new Error('fastify boom');
+
+  // Fastify v5 publishes this native diagnostics channel when a request handler errors; the
+  // integration subscribes to it directly (no orchestrion injection needed). A 5xx reply passes the
+  // default `shouldHandleError`, so the error is captured.
+  channel('tracing:fastify.request.handler:error').publish({
+    error,
+    request: { method: 'GET', routeOptions: { url: '/boom' } },
+    reply: { statusCode: 500 },
+  });
+
+  const event = await withTimeout(
+    sink.waitFor(e => e.exception?.values?.[0]?.value === 'fastify boom'),
+    5000,
+    "the captured 'fastify boom' error",
+  );
+
+  assertExists(event.exception?.values?.[0]);
+  assertEquals(event.exception?.values?.[0]?.mechanism?.type, 'auto.function.fastify');
+  assertEquals(event.exception?.values?.[0]?.mechanism?.handled, false);
+});

dev-packages/node-integration-tests/suites/anr/stop-and-start.js

@@ -1,4 +1,5 @@
 const Sentry = require('@sentry/node');
+const { waitForDebuggerReady } = require('@sentry-internal/test-utils');
 
 setTimeout(() => {
   process.exit();
@@ -52,7 +53,9 @@ setTimeout(() => {
     setTimeout(() => {
       anr.startWorker();
 
-      setTimeout(() => {
+      // Wait for the restarted worker's debugger session to reconnect before blocking the event
+      // loop, otherwise on slow CI the worker isn't ready to sample and the ANR is missed entirely.
+      waitForDebuggerReady(() => {
         longWork();
       });
     }, 2000);

packages/bun/src/sdk.ts

@@ -12,7 +12,6 @@ import type { NodeClient } from '@sentry/node';
 import {
   consoleIntegration,
   contextLinesIntegration,
-  getAutoPerformanceIntegrations,
   httpIntegration,
   init as initNode,
   modulesIntegration,
@@ -26,6 +25,7 @@ import { fetchIntegration } from './integrations/fetch';
 import { makeFetchTransport } from './transports';
 import type { BunOptions } from './types';
 import { bunHttpServerIntegration } from './integrations/bunHttpServer';
+import { getErrorIntegrations, getTracingIntegrations } from '@sentry/server-utils';
 
 /**
  * The performance integrations for bun: the OTel auto-performance set, but with
@@ -40,7 +40,7 @@ function getPerformanceIntegrations(options: Options): Integration[] {
     return [];
   }
 
-  return getAutoPerformanceIntegrations();
+  return getTracingIntegrations();
 }
 
 /** Get the default integrations for the Bun SDK, excluding performance integrations. */
@@ -64,6 +64,9 @@ export function getDefaultIntegrationsWithoutPerformance(): Integration[] {
     nodeContextIntegration(),
     modulesIntegration(),
     processSessionIntegration(),
+    // Framework-level integrations. These are not performance-only: they also handle error capture, so
+    // they are added by default rather than gated behind tracing
+    ...getErrorIntegrations(),
     // Bun Specific
     bunServerIntegration(),
     bunHttpServerIntegration(),

packages/bun/test/init.test.ts

@@ -1,5 +1,5 @@
 import { type Integration } from '@sentry/core';
-import * as sentryNode from '@sentry/node';
+import * as sentryServerUtils from '@sentry/server-utils';
 import type { Mock } from 'bun:test';
 import { afterEach, beforeEach, describe, expect, it, mock, spyOn } from 'bun:test';
 import {
@@ -22,15 +22,14 @@ class MockIntegration implements Integration {
 }
 
 describe('init()', () => {
-  let mockAutoPerformanceIntegrations: Mock<() => Integration[]>;
+  let mockGetTracingIntegrations: Mock<() => Integration[]>;
 
   beforeEach(() => {
-    // @ts-expect-error weird
-    mockAutoPerformanceIntegrations = spyOn(sentryNode, 'getAutoPerformanceIntegrations');
+    mockGetTracingIntegrations = spyOn(sentryServerUtils, 'getTracingIntegrations');
   });
 
   afterEach(() => {
-    mockAutoPerformanceIntegrations.mockRestore();
+    mockGetTracingIntegrations.mockRestore();
   });
 
   describe('integrations', () => {
@@ -41,7 +40,7 @@ describe('init()', () => {
 
       expect(client?.getOptions().integrations).toEqual([]);
 
-      expect(mockAutoPerformanceIntegrations).toHaveBeenCalledTimes(0);
+      expect(mockGetTracingIntegrations).toHaveBeenCalledTimes(0);
     });
 
     it('enables spotlight with default URL from config `true`', () => {
@@ -75,7 +74,7 @@ describe('init()', () => {
       expect(mockDefaultIntegrations[1]?.setupOnce).toHaveBeenCalledTimes(1);
       expect(mockIntegrations[0]?.setupOnce).toHaveBeenCalledTimes(1);
       expect(mockIntegrations[1]?.setupOnce).toHaveBeenCalledTimes(1);
-      expect(mockAutoPerformanceIntegrations).toHaveBeenCalledTimes(0);
+      expect(mockGetTracingIntegrations).toHaveBeenCalledTimes(0);
     });
 
     it('installs integrations returned from a callback function', () => {
@@ -99,12 +98,12 @@ describe('init()', () => {
       expect(mockDefaultIntegrations[0]?.setupOnce).toHaveBeenCalledTimes(1);
       expect(mockDefaultIntegrations[1]?.setupOnce).toHaveBeenCalledTimes(0);
       expect(newIntegration.setupOnce).toHaveBeenCalledTimes(1);
-      expect(mockAutoPerformanceIntegrations).toHaveBeenCalledTimes(0);
+      expect(mockGetTracingIntegrations).toHaveBeenCalledTimes(0);
     });
 
     it('installs performance default instrumentations if tracing is enabled', () => {
       const autoPerformanceIntegrations = [new MockIntegration('Performance integration')];
-      mockAutoPerformanceIntegrations.mockImplementation(() => autoPerformanceIntegrations);
+      mockGetTracingIntegrations.mockImplementation(() => autoPerformanceIntegrations);
 
       const mockIntegrations = [
         new MockIntegration('Some mock integration 4.1'),
@@ -120,7 +119,7 @@ describe('init()', () => {
       expect(mockIntegrations[0]?.setupOnce).toHaveBeenCalledTimes(1);
       expect(mockIntegrations[1]?.setupOnce).toHaveBeenCalledTimes(1);
       expect(autoPerformanceIntegrations[0]?.setupOnce).toHaveBeenCalledTimes(1);
-      expect(mockAutoPerformanceIntegrations).toHaveBeenCalledTimes(1);
+      expect(mockGetTracingIntegrations).toHaveBeenCalledTimes(1);
 
       const integrations = getClient()?.getOptions().integrations;
       expect(integrations).toBeArray();
@@ -137,7 +136,7 @@ describe('init()', () => {
       const client = getClient();
 
       expect(client?.getOptions().integrations).toEqual([]);
-      expect(mockAutoPerformanceIntegrations).toHaveBeenCalledTimes(0);
+      expect(mockGetTracingIntegrations).toHaveBeenCalledTimes(0);
     });
 
     it('still installs user-provided integrations', () => {
@@ -162,12 +161,12 @@ describe('init()', () => {
       const full = getDefaultIntegrations({}).map(({ name }) => name);
 
       expect(withoutPerformance).toEqual(full);
-      expect(mockAutoPerformanceIntegrations).toHaveBeenCalledTimes(0);
+      expect(mockGetTracingIntegrations).toHaveBeenCalledTimes(0);
     });
 
     it('omits the performance integrations that the full set adds when tracing is enabled', () => {
       const performanceIntegration = new MockIntegration('Performance integration');
-      mockAutoPerformanceIntegrations.mockImplementation(() => [performanceIntegration]);
+      mockGetTracingIntegrations.mockImplementation(() => [performanceIntegration]);
 
       const withoutPerformance = getDefaultIntegrationsWithoutPerformance().map(({ name }) => name);
       const full = getDefaultIntegrations({ tracesSampleRate: 1 }).map(({ name }) => name);

packages/deno/src/sdk.ts

@@ -11,32 +11,7 @@ import {
   requestDataIntegration,
   stackParserFromStackParserOptions,
 } from '@sentry/core';
-import {
-  amqplibIntegration,
-  anthropicAIIntegration,
-  awsIntegration,
-  expressIntegration,
-  firebaseIntegration,
-  genericPoolIntegration,
-  googleGenAIIntegration,
-  graphqlIntegration,
-  hapiIntegration,
-  kafkaIntegration,
-  koaIntegration,
-  langChainIntegration,
-  langGraphIntegration,
-  lruMemoizerIntegration,
-  mongoIntegration,
-  mongooseIntegration,
-  mysqlIntegration,
-  mysql2Integration,
-  openAIIntegration,
-  postgresIntegration,
-  postgresJsIntegration,
-  tediousIntegration,
-  vercelAIIntegration,
-  redisIntegration,
-} from '@sentry/server-utils';
+import { getTracingIntegrations, getErrorIntegrations } from '@sentry/server-utils';
 import { DenoClient } from './client';
 import { breadcrumbsIntegration } from './integrations/breadcrumbs';
 import { denoContextIntegration } from './integrations/context';
@@ -64,39 +39,12 @@ export function getDefaultIntegrations(_options: Options): Integration[] {
     denoContextIntegration(),
     denoServeIntegration(),
     denoHttpIntegration(),
-    redisIntegration(),
-    graphqlIntegration(),
-    vercelAIIntegration(),
-    // orchestrion-based instrumentations. We add a deliberate list here rather
-    // than every channel integration: each one needs a Deno test proving it
-    // records spans.
-    //
-    // The orchestrion channels may be injected after (or while) the SDK loads.
-    // If they never load, these are no-ops.
-    amqplibIntegration(),
-    anthropicAIIntegration(),
-    awsIntegration(),
-    expressIntegration(),
-    firebaseIntegration(),
-    genericPoolIntegration(),
-    googleGenAIIntegration(),
-    hapiIntegration(),
-    kafkaIntegration(),
-    koaIntegration(),
-    langChainIntegration(),
-    langGraphIntegration(),
-    lruMemoizerIntegration(),
-    mongoIntegration(),
-    mongooseIntegration(),
-    mysqlIntegration(),
-    mysql2Integration(),
-    openAIIntegration(),
-    postgresIntegration(),
-    postgresJsIntegration(),
-    tediousIntegration(),
     contextLinesIntegration(),
     normalizePathsIntegration(),
     globalHandlersIntegration(),
+    // server-utils integrations
+    ...getErrorIntegrations(),
+    ...getTracingIntegrations(),
   ];
 }