feat(bun): enable new mysql, pg integrations in 'bun build'

.github/workflows/build.yml

@@ -1033,8 +1033,8 @@ jobs:
           node-version-file: 'dev-packages/e2e-tests/test-applications/${{ matrix.test-application }}/package.json'
       - name: Set up Bun
         if:
-          contains(fromJSON('["node-exports-test-app","nextjs-16-bun", "elysia-bun", "hono-4", "bun-bytecode"]'),
-          matrix.test-application)
+          contains(fromJSON('["node-exports-test-app","nextjs-16-bun", "elysia-bun", "hono-4", "bun-bytecode",
+          "bun-mysql"]'), matrix.test-application)
         uses: oven-sh/setup-bun@v2
         with:
           bun-version: '1.3.14'

dev-packages/e2e-tests/test-applications/bun-mysql/.gitignore

@@ -0,0 +1 @@
+dist

dev-packages/e2e-tests/test-applications/bun-mysql/build.ts

@@ -0,0 +1,32 @@
+// Builds `src/app.ts` with the orchestrion `bun build` plugin, emitting
+// `dist/app.js` for the server to run. The plugin injects the
+// `orchestrion:mysql:query` diagnostics channel into the bundled `mysql`.
+
+// @ts-ignore -- subpath export resolved by Bun at runtime; the package
+// tsconfig's node module resolution can't see `exports` subpaths.
+import { sentryBunPlugin } from '@sentry/bun/plugin';
+import { join } from 'path';
+
+void (async () => {
+  const result = await Bun.build({
+    entrypoints: [join(__dirname, 'src/app.ts')],
+    target: 'bun',
+    outdir: join(__dirname, 'dist'),
+    // `@sentry/bun` (and its deps) stay external, so we don't bundle the
+    // whole SDK/OTel stack. `mysql` is also listed, but the plugin strips
+    // instrumented packages back out of `external` so they get bundled and
+    // transformed (channel injection only happens on code that passes through
+    // the bundler).
+    external: ['@sentry/bun', 'mysql'],
+    plugins: [sentryBunPlugin()],
+  });
+
+  if (!result.success) {
+    // eslint-disable-next-line no-console
+    console.error('BUILD_FAILED', result.logs);
+    process.exit(1);
+  }
+
+  // eslint-disable-next-line no-console
+  console.log('BUILD_OK');
+})();

dev-packages/e2e-tests/test-applications/bun-mysql/docker-compose.yml

@@ -0,0 +1,18 @@
+services:
+  db:
+    image: mysql:8.0
+    restart: always
+    container_name: e2e-tests-bun-mysql
+    # The `mysql` 2.x driver doesn't speak MySQL 8's default
+    # `caching_sha2_password` auth, so force the legacy plugin.
+    command: ['--default-authentication-plugin=mysql_native_password']
+    ports:
+      - '3306:3306'
+    environment:
+      MYSQL_ROOT_PASSWORD: password
+    healthcheck:
+      test: ['CMD-SHELL', 'mysqladmin ping -h 127.0.0.1 -uroot -ppassword']
+      interval: 2s
+      timeout: 3s
+      retries: 30
+      start_period: 10s

dev-packages/e2e-tests/test-applications/bun-mysql/global-setup.mjs

@@ -0,0 +1,14 @@
+import { execSync } from 'child_process';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export default async function globalSetup() {
+  // Start MySQL via Docker Compose. `--wait` blocks until the healthcheck
+  // in docker-compose.yml passes, so the app can connect immediately.
+  execSync('docker compose up -d --wait', {
+    cwd: __dirname,
+    stdio: 'inherit',
+  });
+}

dev-packages/e2e-tests/test-applications/bun-mysql/global-teardown.mjs

@@ -0,0 +1,12 @@
+import { execSync } from 'child_process';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export default async function globalTeardown() {
+  execSync('docker compose down --volumes', {
+    cwd: __dirname,
+    stdio: 'inherit',
+  });
+}

dev-packages/e2e-tests/test-applications/bun-mysql/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "bun-mysql",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "start": "docker compose up -d --wait && bun run dist/app.js",
+    "test": "playwright test",
+    "clean": "npx rimraf node_modules pnpm-lock.yaml dist",
+    "test:build": "pnpm install && bun run build.ts",
+    "test:assert": "pnpm test"
+  },
+  "dependencies": {
+    "@sentry/bun": "file:../../packed/sentry-bun-packed.tgz",
+    "mysql": "2.18.1"
+  },
+  "devDependencies": {
+    "@playwright/test": "~1.56.0",
+    "@sentry-internal/test-utils": "link:../../../test-utils",
+    "bun-types": "^1.2.9"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  }
+}

dev-packages/e2e-tests/test-applications/bun-mysql/playwright.config.mjs

@@ -0,0 +1,12 @@
+import { getPlaywrightConfig } from '@sentry-internal/test-utils';
+
+const config = getPlaywrightConfig({
+  startCommand: `pnpm start`,
+  port: 3030,
+});
+
+export default {
+  ...config,
+  globalSetup: './global-setup.mjs',
+  globalTeardown: './global-teardown.mjs',
+};

dev-packages/e2e-tests/test-applications/bun-mysql/src/app.ts

@@ -0,0 +1,73 @@
+import * as Sentry from '@sentry/bun';
+
+// @ts-ignore -- `mysql` ships no type declarations; only needed at runtime.
+import mysql from 'mysql';
+
+Sentry.init({
+  environment: 'qa',
+  dsn: process.env.E2E_TEST_DSN,
+  debug: !!process.env.DEBUG,
+  tunnel: 'http://localhost:3031/', // proxy server
+  tracesSampleRate: 1,
+});
+
+interface Connection {
+  query(sql: string, cb: (err: unknown) => void): void;
+  connect(cb: (err: unknown) => void): void;
+  on(event: string, cb: (err: unknown) => void): void;
+}
+interface MysqlModule {
+  createConnection(opts: { host: string; port: number; user: string; password: string }): Connection;
+}
+
+// `mysql` was transformed at build time (by `@sentry/bun/plugin`) to publish
+// the `orchestrion:mysql:query` channel. The Bun SDK subscribes to it, so the
+// queries below produce db spans without any OTel require-hook.
+const connection = (mysql as MysqlModule).createConnection({
+  host: process.env.MYSQL_HOST ?? '127.0.0.1',
+  port: Number(process.env.MYSQL_PORT ?? 3306),
+  user: 'root',
+  password: 'password',
+});
+
+// Swallow connection errors (e.g. the DB container going away at teardown) so
+// they don't become an uncaught exception that crashes the process on shutdown.
+connection.on('error', (err: unknown) => {
+  // eslint-disable-next-line no-console
+  console.error('mysql connection error', err);
+});
+
+connection.connect((err: unknown) => {
+  if (err) {
+    // eslint-disable-next-line no-console
+    console.error('mysql connect error', err);
+  }
+});
+
+Bun.serve({
+  port: 3030,
+  hostname: '0.0.0.0',
+  async fetch(req: Request) {
+    const url = new URL(req.url);
+
+    // Runs two queries, the second NESTED inside the first's callback. mysql
+    // dispatches that callback from its socket data handler (a fresh async
+    // context), so the nested query's span only lands on this request's
+    // http.server transaction if the channel subscriber restored the parent
+    // across the async boundary.
+    if (url.pathname === '/test-mysql') {
+      await new Promise<void>((resolve, reject) => {
+        connection.query('SELECT 1 + 1 AS solution', (err: unknown) => {
+          if (err) return reject(err);
+          connection.query('SELECT NOW()', (err2: unknown) => {
+            if (err2) return reject(err2);
+            resolve();
+          });
+        });
+      });
+      return Response.json({ status: 'ok' });
+    }
+
+    return new Response('Not found', { status: 404 });
+  },
+});

dev-packages/e2e-tests/test-applications/bun-mysql/start-event-proxy.mjs

@@ -0,0 +1,6 @@
+import { startEventProxyServer } from '@sentry-internal/test-utils';
+
+startEventProxyServer({
+  port: 3031,
+  proxyServerName: 'bun-mysql',
+});

dev-packages/e2e-tests/test-applications/bun-mysql/tests/mysql.test.ts

@@ -0,0 +1,55 @@
+import { expect, test } from '@playwright/test';
+import { waitForTransaction } from '@sentry-internal/test-utils';
+
+test('mysql queries emit a db span with orchestrion-channel attributes', async ({ baseURL }) => {
+  // Each incoming request gets a Sentry http.server transaction; the mysql
+  // queries run inside it, so their db spans attach to that transaction. The
+  // channels were injected at build time by `@sentry/bun/plugin`, and the Bun
+  // SDK subscribes to them by default.
+  const transactionPromise = waitForTransaction('bun-mysql', event => {
+    return (
+      event?.contexts?.trace?.op === 'http.server' &&
+      (event.request?.url ?? '').includes('/test-mysql') &&
+      (event.spans?.some(span => span.op === 'db') ?? false)
+    );
+  });
+
+  const res = await fetch(`${baseURL}/test-mysql`);
+  expect(res.status).toBe(200);
+  await res.json();
+
+  const transaction = await transactionPromise;
+  const dbSpans = transaction.spans!.filter(span => span.op === 'db');
+
+  const firstQuery = dbSpans.find(span => span.description === 'SELECT 1 + 1 AS solution');
+  expect(firstQuery).toBeDefined();
+  expect(firstQuery!.data?.['sentry.origin']).toBe('auto.db.orchestrion.mysql');
+  expect(firstQuery!.data?.['db.system']).toBe('mysql');
+  expect(firstQuery!.data?.['db.statement']).toBe('SELECT 1 + 1 AS solution');
+  expect(firstQuery!.data?.['net.peer.port']).toBe(3306);
+  expect(firstQuery!.data?.['db.user']).toBe('root');
+});
+
+test('a nested query lands on the same transaction (async context restored)', async ({ baseURL }) => {
+  // The second query runs inside the first query's callback — i.e. across
+  // mysql's async socket-callback dispatch. Both spans appearing on the SAME
+  // http.server transaction proves the channel subscriber restored the parent
+  // span across that async boundary (otherwise the nested query would start its
+  // own trace and never join this transaction).
+  const transactionPromise = waitForTransaction('bun-mysql', event => {
+    return (
+      event?.contexts?.trace?.op === 'http.server' &&
+      (event.request?.url ?? '').includes('/test-mysql') &&
+      (event.spans?.filter(span => span.op === 'db').length ?? 0) >= 2
+    );
+  });
+
+  const res = await fetch(`${baseURL}/test-mysql`);
+  expect(res.status).toBe(200);
+  await res.json();
+
+  const transaction = await transactionPromise;
+  const descriptions = transaction.spans!.filter(span => span.op === 'db').map(span => span.description);
+  expect(descriptions).toContain('SELECT 1 + 1 AS solution');
+  expect(descriptions).toContain('SELECT NOW()');
+});

dev-packages/e2e-tests/test-applications/bun-mysql/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "types": ["bun-types"],
+    "esModuleInterop": true,
+    "lib": ["es2020"],
+    "strict": true,
+    "outDir": "dist",
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*.ts", "build.ts"]
+}

packages/bun/src/sdk.ts

@@ -22,12 +22,50 @@ import {
   onUnhandledRejectionIntegration,
   processSessionIntegration,
 } from '@sentry/node';
+import { CHANNEL_INTEGRATION_FACTORIES, isOrchestrionInjected } from '@sentry/server-utils/orchestrion';
 import { bunServerIntegration } from './integrations/bunserver';
 import { makeFetchTransport } from './transports';
 import type { BunOptions } from './types';
 
+// The OTel integrations that bun replaces with their orchestrion
+// diagnostics-channel equivalents. Bun's orchestrion instrumentation is
+// injected at build time by `@sentry/bun/plugin`; the OTel versions rely on a
+// runtime require-hook that bun doesn't support.
+const CHANNEL_REPLACED_OTEL_INTEGRATIONS = new Set(Object.keys(CHANNEL_INTEGRATION_FACTORIES));
+
+/**
+ * The orchestrion channel-subscriber integrations, listening on the diagnostics
+ * channels that `@sentry/bun/plugin` injects at build time.
+ */
+function getChannelIntegrations(): Integration[] {
+  return Object.values(CHANNEL_INTEGRATION_FACTORIES).map(integrationFactory => integrationFactory());
+}
+
+/**
+ * The performance integrations for bun: the OTel auto-performance set, but
+ * with the orchestrion diagnostics-channel subscribers *only* when the
+ * orchestrion channels were actually injected (i.e. the app was built with
+ * `@sentry/bun/plugin`). Without that, the channels never fire, so leave
+ * it alone.
+ */
+function getPerformanceIntegrations(options: Options): Integration[] {
+  if (!hasSpansEnabled(options)) {
+    return [];
+  }
+
+  const autoPerformanceIntegrations = getAutoPerformanceIntegrations();
+  if (!isOrchestrionInjected()) {
+    return autoPerformanceIntegrations;
+  }
+
+  return [
+    ...autoPerformanceIntegrations.filter(integration => !CHANNEL_REPLACED_OTEL_INTEGRATIONS.has(integration.name)),
+    ...getChannelIntegrations(),
+  ];
+}
+
 /** Get the default integrations for the Bun SDK. */
-export function getDefaultIntegrations(_options: Options): Integration[] {
+export function getDefaultIntegrations(options: Options): Integration[] {
   // We return a copy of the defaultIntegrations here to avoid mutating this
   return [
     // Common
@@ -51,7 +89,7 @@ export function getDefaultIntegrations(_options: Options): Integration[] {
     processSessionIntegration(),
     // Bun Specific
     bunServerIntegration(),
-    ...(hasSpansEnabled(_options) ? getAutoPerformanceIntegrations() : []),
+    ...getPerformanceIntegrations(options),
   ];
 }
 

packages/node/src/sdk/experimentalUseDiagnosticsChannelInjection.ts

@@ -1,9 +1,4 @@
-import {
-  lruMemoizerChannelIntegration,
-  detectOrchestrionSetup,
-  mysqlChannelIntegration,
-  postgresChannelIntegration,
-} from '@sentry/server-utils/orchestrion';
+import { CHANNEL_INTEGRATION_FACTORIES, detectOrchestrionSetup } from '@sentry/server-utils/orchestrion';
 import { registerDiagnosticsChannelInjection } from '@sentry/server-utils/orchestrion/register';
 import type { DiagnosticsChannelInjection } from './diagnosticsChannelInjection';
 import { setDiagnosticsChannelInjectionLoader } from './diagnosticsChannelInjection';
@@ -62,12 +57,7 @@ import { setDiagnosticsChannelInjectionLoader } from './diagnosticsChannelInject
 export function experimentalUseDiagnosticsChannelInjection(): void {
   setDiagnosticsChannelInjectionLoader(
     (): DiagnosticsChannelInjection => ({
-      // Keyed by the OTel integration name each one replaces.
-      integrationFactories: {
-        Mysql: mysqlChannelIntegration,
-        Postgres: postgresChannelIntegration,
-        LruMemoizer: lruMemoizerChannelIntegration,
-      },
+      integrationFactories: CHANNEL_INTEGRATION_FACTORIES,
       register: registerDiagnosticsChannelInjection,
       detect: detectOrchestrionSetup,
     }),