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 }),
  ]);
  },
  })

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

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

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

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

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

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

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