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

.github/workflows/build.yml

@@ -778,7 +778,7 @@ jobs:
     needs: [job_get_metadata, job_build]
     if: needs.job_build.outputs.changed_node_integration == 'true' || github.event_name != 'pull_request'
     runs-on: ubuntu-24.04
-    timeout-minutes: 20
+    timeout-minutes: 15
     strategy:
       fail-fast: false
       matrix:
@@ -1046,8 +1046,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'
@@ -1058,7 +1058,10 @@ jobs:
           use-installer: true
           token: ${{ secrets.GITHUB_TOKEN }}
       - name: Set up Deno
-        if: contains(matrix.test-application, 'deno') || matrix.test-application == 'hono-4'
+        if:
+          matrix.test-application == 'deno' || matrix.test-application == 'deno-streamed' || matrix.test-application ==
+          'deno-redis' || matrix.test-application == 'hono-4' || matrix.test-application == 'deno-mysql' ||
+          matrix.test-application == 'deno-pg'
         uses: denoland/setup-deno@v2.0.4
         with:
           deno-version: ${{ matrix.deno-version || 'v2.8.0' }}
@@ -1181,7 +1184,7 @@ jobs:
         with:
           node-version-file: 'dev-packages/e2e-tests/test-applications/${{ matrix.test-application }}/package.json'
       - name: Set up Deno
-        if: contains(matrix.test-application, 'deno')
+        if: matrix.test-application == 'deno' || matrix.test-application == 'deno-streamed'
         uses: denoland/setup-deno@v2.0.4
         with:
           deno-version: ${{ matrix.deno-version || 'v2.8.0' }}

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"]
+}

dev-packages/node-integration-tests/suites/tracing/postgres-streamed/test.ts

@@ -1,9 +1,15 @@
 import { SEMANTIC_ATTRIBUTE_SENTRY_OP } from '@sentry/core';
 import type { SerializedStreamedSpanContainer } from '@sentry/core';
 import { afterAll, describe, expect } from 'vitest';
-import { conditionalTest } from '../../../utils';
+import { conditionalTest, isOrchestrionEnabled } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
 
+// Query-span origin depends on which instrumentation is active. Blocks driving the SDK's default
+// integrations get the diagnostics-channel origin when the generic orchestrion run is enabled (via
+// INJECT_ORCHESTRION), since the OTel `Postgres` integration is then swapped for the channel one. Blocks
+// that pass an explicit `postgresIntegration()` (e.g. `ignoreConnectSpans`) keep the OTel origin.
+const QUERY_ORIGIN = isOrchestrionEnabled() ? 'auto.db.orchestrion.postgres' : 'auto.db.otel.postgres';
+
 const COMMON_DB_ATTRIBUTES = {
   'db.connection_string': {
     type: 'string',
@@ -74,22 +80,28 @@ const COMMON_DB_ATTRIBUTES = {
 /**
  * Builds the expected strict shape of a streamed postgres db span.
  *
- * Query spans carry a `db.statement` and the `auto.db.otel.postgres` origin. The `pg.connect` span
- * has no `db.statement`, and since the pg instrumentation sets no origin on it, it carries the
- * default `manual` origin (written as an attribute on the streamed-span path; the non-streamed/SDK
- * path omits the `manual` default).
+ * Query spans carry a `db.statement` and the query origin (`auto.db.otel.postgres`, or
+ * `auto.db.orchestrion.postgres` under the generic orchestrion run — see `QUERY_ORIGIN`). The
+ * `pg.connect` span has no `db.statement`, and since the pg instrumentation sets no origin on it, it
+ * carries the default `manual` origin (written as an attribute on the streamed-span path; the
+ * non-streamed/SDK path omits the `manual` default).
  *
  * `host` defaults to `localhost`, but the `pg-native` scenarios connect to the IPv4 loopback
  * (`127.0.0.1`) explicitly, so the reported peer name and connection string reflect that.
+ *
+ * `origin` defaults to `QUERY_ORIGIN`; blocks that force the OTel path (explicit `postgresIntegration()`)
+ * pass `auto.db.otel.postgres` explicitly.
  */
 function expectedDbSpan({
   name,
   statement,
   host = 'localhost',
+  origin = QUERY_ORIGIN,
 }: {
   name: string;
   statement?: string;
   host?: string;
+  origin?: string;
 }): unknown {
   const attributes: Record<string, unknown> = {
     ...COMMON_DB_ATTRIBUTES,
@@ -110,7 +122,7 @@ function expectedDbSpan({
     };
     attributes['sentry.origin'] = {
       type: 'string',
-      value: 'auto.db.otel.postgres',
+      value: origin,
     };
   } else {
     attributes['sentry.origin'] = {
@@ -192,13 +204,17 @@ describe('postgres auto instrumentation (streamed)', () => {
               expect(dbSpans.find(span => span.name.includes('connect'))).toBeUndefined();
               expect(dbSpans.length).toBe(3);
 
+              // This block passes an explicit `postgresIntegration({ ignoreConnectSpans: true })`, which
+              // survives the orchestrion swap, so query spans keep the OTel origin even under INJECT_ORCHESTRION.
+              const origin = 'auto.db.otel.postgres';
               expect(dbSpans).toEqual([
-                expectedDbSpan({ name: CREATE_USER_TABLE_STATEMENT, statement: CREATE_USER_TABLE_STATEMENT }),
+                expectedDbSpan({ name: CREATE_USER_TABLE_STATEMENT, statement: CREATE_USER_TABLE_STATEMENT, origin }),
                 expectedDbSpan({
                   name: 'INSERT INTO "User" ("email", "name") VALUES ($1, $2)',
                   statement: 'INSERT INTO "User" ("email", "name") VALUES ($1, $2)',
+                  origin,
                 }),
-                expectedDbSpan({ name: 'SELECT * FROM "User"', statement: 'SELECT * FROM "User"' }),
+                expectedDbSpan({ name: 'SELECT * FROM "User"', statement: 'SELECT * FROM "User"', origin }),
               ]);
             },
           })