feat(bun,deno,node): pg orchestrion instrumentation

.github/workflows/build.yml

@@ -1045,9 +1045,7 @@ jobs:
  use-installer: true
  token: ${{ secrets.GITHUB_TOKEN }}
  - name: Set up Deno
- 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'
+ if: contains(matrix.test-application, 'deno') || matrix.test-application == 'hono-4'
  uses: denoland/setup-deno@v2.0.4
  with:
  deno-version: ${{ matrix.deno-version || 'v2.8.0' }}
@@ -1170,7 +1168,7 @@ jobs:
  with:
  node-version-file: 'dev-packages/e2e-tests/test-applications/${{ matrix.test-application }}/package.json'
  - name: Set up Deno
- if: matrix.test-application == 'deno' || matrix.test-application == 'deno-streamed'
+ if: contains(matrix.test-application, 'deno')
  uses: denoland/setup-deno@v2.0.4
  with:
  deno-version: ${{ matrix.deno-version || 'v2.8.0' }}

dev-packages/bun-integration-tests/package.json

@@ -16,7 +16,8 @@
  "@sentry/bun": "10.63.0",
  "@sentry/hono": "10.63.0",
  "hono": "^4.12.25",
- "mysql": "^2.18.1"
+ "mysql": "^2.18.1",
+ "pg": "8.16.0"
  },
  "devDependencies": {
  "@sentry-internal/test-utils": "10.63.0",

dev-packages/bun-integration-tests/suites/orchestrion-postgres/build.ts

@@ -0,0 +1,43 @@
+// Builds the smoke scenario with the orchestrion `bun build` plugin and writes
+// the bundle to a temp dir, printing the output path for test.ts to execute.
+//
+// A successful build proves `bun build` runs with the plugin; running the
+// bundle (see test.ts) then proves the bundled `pg` is actually instrumented.
+
+// @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 { tmpdir } from 'os';
+import { join } from 'path';
+
+void (async () => {
+ const outdir = join(tmpdir(), `sentry-bun-orchestrion-pg-${process.pid}-${Date.now()}`);
+ const result = await Bun.build({
+ entrypoints: [join(__dirname, 'scenario.ts')],
+ target: 'bun',
+ outdir,
+ // Deliberately mark `pg` external. An externalized dependency is resolved
+ // from `node_modules` at runtime and never passes through the transform's
+ // `onLoad`, so its channel injection would be silently skipped. The plugin
+ // must strip instrumented packages back out of `external` so they get
+ // bundled (and thus transformed).
+ external: ['pg'],
+ plugins: [sentryBunPlugin()],
+ });
+
+ if (!result.success) {
+ // eslint-disable-next-line no-console
+ console.error('BUILD_FAILED', result.logs);
+ process.exit(1);
+ }
+
+ const output = result.outputs[0];
+ if (!output) {
+ // eslint-disable-next-line no-console
+ console.error('BUILD_FAILED no outputs');
+ process.exit(1);
+ }
+
+ // eslint-disable-next-line no-console
+ console.log(`BUILD_OK outfile=${output.path}`);
+})();

dev-packages/bun-integration-tests/suites/orchestrion-postgres/scenario.ts

@@ -0,0 +1,61 @@
+// Bundled entry for the `bun build` smoke test.
+//
+// Once `Bun.build` (with the orchestrion plugin) has transformed `pg`,
+// calling `client.query()` publishes to the `orchestrion:pg:query` tracing
+// channel.
+//
+// `start` fires synchronously on the call, so no live database is needed.
+//
+// We subscribe, run a query, and report which channel events fired
+// (plus the detection marker the plugin's banner sets at boot).
+
+import { tracingChannel } from 'node:diagnostics_channel';
+
+// @ts-ignore -- only the runtime value is needed; pg's types are irrelevant
+import pg from 'pg';
+
+interface QueryContext {
+ arguments?: unknown[];
+}
+interface Client {
+ query(sql: string, cb: () => void): void;
+}
+interface PgModule {
+ Client: new (opts: { host: string; user: string; database: string }) => Client;
+}
+
+const events: string[] = [];
+let statement = '';
+
+tracingChannel('orchestrion:pg:query').subscribe({
+ start(message: unknown) {
+ events.push('start');
+ const first = (message as QueryContext).arguments?.[0];
+ statement = typeof first === 'string' ? first : '';
+ },
+ end() {
+ events.push('end');
+ },
+ asyncStart() {},
+ asyncEnd() {
+ events.push('asyncEnd');
+ },
+ error() {},
+});
+
+const client = new (pg as PgModule).Client({ host: '127.0.0.1', user: 'root', database: 'mydb' });
+try {
+ client.query('SELECT 1 AS solution', () => {});
+} catch {
+ // No live server
+ // `start` has already published synchronously by this point.
+}
+
+const marker = (globalThis as { __SENTRY_ORCHESTRION__?: { runtime?: boolean; bundler?: boolean } })
+ .__SENTRY_ORCHESTRION__;
+
+setTimeout(() => {
+ // eslint-disable-next-line no-console
+ console.log(`SCENARIO events=${events.join(',')} statement=${statement} marker=${JSON.stringify(marker ?? null)}`);
+ process.exit(0);
+}, 200);

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

@@ -0,0 +1,65 @@
+import { spawnSync } from 'child_process';
+import { rmSync } from 'fs';
+import { dirname, join } from 'path';
+import { describe, expect, it } from 'vitest';
+
+const dir = __dirname;
+
+// Cap each `bun` subprocess. The test runs two of them sequentially, so its
+// own timeout must exceed `2 * SUBPROCESS_TIMEOUT_MS` otherwise the suite's
+// default `testTimeout` (20s) fails the test before these caps do,
+// for example on a slow CI runner where the build+run can take >20s.
+const SUBPROCESS_TIMEOUT_MS = 60_000;
+
+function runBun(args: string[]): { stdout: string; stderr: string; status: number | null } {
+ const res = spawnSync('bun', args, { cwd: dir, encoding: 'utf8', timeout: SUBPROCESS_TIMEOUT_MS });
+ return { stdout: res.stdout ?? '', stderr: res.stderr ?? '', status: res.status };
+}
+
+// Bun orchestrion instrumentation is BUILD-ONLY (`@sentry/bun/plugin` is a
+// `Bun.build` plugin; there is no `bun run` preload).
+//
+// A `bun run` runtime plugin cannot instrument CommonJS dependencies like
+// `pg`: any module returned by a runtime `onLoad` plugin in Bun loses its
+// CommonJS named exports
+//
+// When https://github.com/oven-sh/bun/pull/31770 lands, we can revisit an
+// auto-load plugin for `bun run`.
+describe('orchestrion pg instrumentation (Bun)', () => {
+ it(
+ 'bundles `pg` with the plugin, and the built output fires the pg channel when run',
+ () => {
+ // Build the scenario with the orchestrion `bun build` plugin.
+ const build = runBun(['run', join(dir, 'build.ts')]);
+ expect(build.status, `build failed:\nstderr:\n${build.stderr}\nstdout:\n${build.stdout}`).toBe(0);
+
+ const outfile = build.stdout.match(/BUILD_OK outfile=(.+)/)?.[1]?.trim();
+ expect(outfile, `no outfile in build output:\n${build.stdout}`).toBeTruthy();
+
+ try {
+ // Run the built bundle. The bundled (transformed) `pg` should publish
+ // to the `orchestrion:pg:query` channel when `client.query()` is
+ // called, and the plugin's banner should set the `bundler` marker at
+ // boot.
+ const run = runBun(['run', outfile as string]);
+ expect(run.status, `run failed:\nstderr:\n${run.stderr}\nstdout:\n${run.stdout}`).toBe(0);
+
+ const line = run.stdout.split('\n').find(l => l.startsWith('SCENARIO')) ?? '';
+ // channel `start` fired on `client.query()`
+ expect(line).toContain('events=start');
+ // with the expected SQL
+ expect(line).toContain('statement=SELECT 1 AS solution');
+ // injected banner ran at bundle boot
+ expect(line).toContain('"bundler":true');
+ } finally {
+ if (outfile) {
+ rmSync(dirname(outfile), { recursive: true, force: true });
+ }
+ }
+ // Allow for both sequential `runBun` calls hitting their subprocess
+ // cap, so the `spawnSync` timeouts (not the vitest 20s def) are the
+ // binding limit.
+ },
+ 2 * SUBPROCESS_TIMEOUT_MS,
+ );
+});

dev-packages/e2e-tests/test-applications/deno-pg/deno.json

@@ -0,0 +1,7 @@
+{
+ "imports": {
+ "@sentry/deno": "npm:@sentry/deno",
+ "pg": "npm:pg@8.16.0"
+ },
+ "nodeModulesDir": "manual"
+}

dev-packages/e2e-tests/test-applications/deno-pg/docker-compose.yml

@@ -0,0 +1,17 @@
+services:
+ db:
+ image: postgres:13
+ restart: always
+ container_name: e2e-tests-deno-pg
+ ports:
+ - '5432:5432'
+ environment:
+ POSTGRES_USER: postgres
+ POSTGRES_PASSWORD: password
+ POSTGRES_DB: postgres
+ healthcheck:
+ test: ['CMD-SHELL', 'pg_isready -U postgres -d postgres']
+ interval: 2s
+ timeout: 3s
+ retries: 30
+ start_period: 5s

dev-packages/e2e-tests/test-applications/deno-pg/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 PostgreSQL via Docker Compose. `--wait` blocks until the healthcheck
+ // in docker-compose.yml passes, so the Deno app can connect immediately.
+ execSync('docker compose up -d --wait', {
+ cwd: __dirname,
+ stdio: 'inherit',
+ });
+}

dev-packages/e2e-tests/test-applications/deno-pg/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/deno-pg/package.json

@@ -0,0 +1,23 @@
+{
+ "name": "deno-pg",
+ "version": "1.0.0",
+ "private": true,
+ "scripts": {
+ "start": "docker compose up -d --wait && deno run --allow-net --allow-env --allow-read --allow-sys --allow-write src/app.ts",
+ "test": "playwright test",
+ "clean": "npx rimraf node_modules pnpm-lock.yaml",
+ "test:build": "pnpm install",
+ "test:assert": "pnpm test"
+ },
+ "dependencies": {
+ "@sentry/deno": "file:../../packed/sentry-deno-packed.tgz",
+ "pg": "8.16.0"
+ },
+ "devDependencies": {
+ "@playwright/test": "~1.56.0",
+ "@sentry-internal/test-utils": "link:../../../test-utils"
+ },
+ "volta": {
+ "extends": "../../package.json"
+ }
+}

dev-packages/e2e-tests/test-applications/deno-pg/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/deno-pg/src/app.ts

@@ -0,0 +1,69 @@
+// `@sentry/deno/import` MUST be the very first import: it registers the
+// orchestrion runtime hook, which transforms `pg` (imported dynamically below)
+// to publish the `orchestrion:pg:query` diagnostics channel.
+// In Deno 2.8.0–2.8.2 the hook only works as the first import in the entry
+// graph.
+import '@sentry/deno/import';
+import * as Sentry from '@sentry/deno';
+
+Sentry.init({
+ environment: 'qa',
+ dsn: Deno.env.get('E2E_TEST_DSN'),
+ debug: !!Deno.env.get('DEBUG'),
+ tunnel: 'http://localhost:3031/', // proxy server
+ tracesSampleRate: 1,
+});
+
+// Dynamic import AFTER init so the orchestrion hook (registered above) is in
+// place to transform `pg/lib/client.js`'s `query`, and so
+// `denoPostgresIntegration` (wired by `init()`) is already subscribed.
+const { default: pg } = await import('pg');
+
+const client = new pg.Client({
+ host: Deno.env.get('PGHOST') ?? '127.0.0.1',
+ port: Number(Deno.env.get('PGPORT') ?? 5432),
+ user: 'postgres',
+ password: 'password',
+ database: 'postgres',
+});
+
+// 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.
+client.on('error', (err: unknown) => {
+ // eslint-disable-next-line no-console
+ console.error('pg client error', err);
+});
+
+client.connect((err: unknown) => {
+ if (err) {
+ // eslint-disable-next-line no-console
+ console.error('pg connect error', err);
+ }
+});
+
+const port = 3030;
+
+Deno.serve({ port, hostname: '0.0.0.0' }, async (req: Request) => {
+ const url = new URL(req.url);
+
+ // Runs two queries, the second NESTED inside the first's callback. pg
+ // 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 `denoPostgresIntegration`'s AsyncLocalStorage
+ // context strategy restored the parent across the async boundary.
+ if (url.pathname === '/test-pg') {
+ await new Promise<void>((resolve, reject) => {
+ client.query('SELECT 1 + 1 AS solution', (err: unknown) => {
+ if (err) return reject(err);
+ client.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/deno-pg/start-event-proxy.mjs

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

.github/workflows/build.yml

@@ -1045,9 +1045,7 @@ jobs:
  use-installer: true
  token: ${{ secrets.GITHUB_TOKEN }}
  - name: Set up Deno
- 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'
+ if: contains(matrix.test-application, 'deno') || matrix.test-application == 'hono-4'
  uses: denoland/setup-deno@v2.0.4
  with:
  deno-version: ${{ matrix.deno-version || 'v2.8.0' }}
@@ -1170,7 +1168,7 @@ jobs:
  with:
  node-version-file: 'dev-packages/e2e-tests/test-applications/${{ matrix.test-application }}/package.json'
  - name: Set up Deno
- if: matrix.test-application == 'deno' || matrix.test-application == 'deno-streamed'
+ if: contains(matrix.test-application, 'deno')
  uses: denoland/setup-deno@v2.0.4
  with:
  deno-version: ${{ matrix.deno-version || 'v2.8.0' }}

dev-packages/bun-integration-tests/package.json

@@ -16,7 +16,8 @@
  "@sentry/bun": "10.63.0",
  "@sentry/hono": "10.63.0",
  "hono": "^4.12.25",
- "mysql": "^2.18.1"
+ "mysql": "^2.18.1",
+ "pg": "8.16.0"
  },
  "devDependencies": {
  "@sentry-internal/test-utils": "10.63.0",

dev-packages/bun-integration-tests/suites/orchestrion-postgres/build.ts

@@ -0,0 +1,43 @@
+// Builds the smoke scenario with the orchestrion `bun build` plugin and writes
+// the bundle to a temp dir, printing the output path for test.ts to execute.
+//
+// A successful build proves `bun build` runs with the plugin; running the
+// bundle (see test.ts) then proves the bundled `pg` is actually instrumented.
+
+// @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 { tmpdir } from 'os';
+import { join } from 'path';
+
+void (async () => {
+ const outdir = join(tmpdir(), `sentry-bun-orchestrion-pg-${process.pid}-${Date.now()}`);
+ const result = await Bun.build({
+ entrypoints: [join(__dirname, 'scenario.ts')],
+ target: 'bun',
+ outdir,
+ // Deliberately mark `pg` external. An externalized dependency is resolved
+ // from `node_modules` at runtime and never passes through the transform's
+ // `onLoad`, so its channel injection would be silently skipped. The plugin
+ // must strip instrumented packages back out of `external` so they get
+ // bundled (and thus transformed).
+ external: ['pg'],
+ plugins: [sentryBunPlugin()],
+ });
+
+ if (!result.success) {
+ // eslint-disable-next-line no-console
+ console.error('BUILD_FAILED', result.logs);
+ process.exit(1);
+ }
+
+ const output = result.outputs[0];
+ if (!output) {
+ // eslint-disable-next-line no-console
+ console.error('BUILD_FAILED no outputs');
+ process.exit(1);
+ }
+
+ // eslint-disable-next-line no-console
+ console.log(`BUILD_OK outfile=${output.path}`);
+})();

dev-packages/bun-integration-tests/suites/orchestrion-postgres/scenario.ts

@@ -0,0 +1,61 @@
+// Bundled entry for the `bun build` smoke test.
+//
+// Once `Bun.build` (with the orchestrion plugin) has transformed `pg`,
+// calling `client.query()` publishes to the `orchestrion:pg:query` tracing
+// channel.
+//
+// `start` fires synchronously on the call, so no live database is needed.
+//
+// We subscribe, run a query, and report which channel events fired
+// (plus the detection marker the plugin's banner sets at boot).
+
+import { tracingChannel } from 'node:diagnostics_channel';
+
+// @ts-ignore -- only the runtime value is needed; pg's types are irrelevant
+import pg from 'pg';
+
+interface QueryContext {
+ arguments?: unknown[];
+}
+interface Client {
+ query(sql: string, cb: () => void): void;
+}
+interface PgModule {
+ Client: new (opts: { host: string; user: string; database: string }) => Client;
+}
+
+const events: string[] = [];
+let statement = '';
+
+tracingChannel('orchestrion:pg:query').subscribe({
+ start(message: unknown) {
+ events.push('start');
+ const first = (message as QueryContext).arguments?.[0];
+ statement = typeof first === 'string' ? first : '';
+ },
+ end() {
+ events.push('end');
+ },
+ asyncStart() {},
+ asyncEnd() {
+ events.push('asyncEnd');
+ },
+ error() {},
+});
+
+const client = new (pg as PgModule).Client({ host: '127.0.0.1', user: 'root', database: 'mydb' });
+try {
+ client.query('SELECT 1 AS solution', () => {});
+} catch {
+ // No live server
+ // `start` has already published synchronously by this point.
+}
+
+const marker = (globalThis as { __SENTRY_ORCHESTRION__?: { runtime?: boolean; bundler?: boolean } })
+ .__SENTRY_ORCHESTRION__;
+
+setTimeout(() => {
+ // eslint-disable-next-line no-console
+ console.log(`SCENARIO events=${events.join(',')} statement=${statement} marker=${JSON.stringify(marker ?? null)}`);
+ process.exit(0);
+}, 200);

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

@@ -0,0 +1,65 @@
+import { spawnSync } from 'child_process';
+import { rmSync } from 'fs';
+import { dirname, join } from 'path';
+import { describe, expect, it } from 'vitest';
+
+const dir = __dirname;
+
+// Cap each `bun` subprocess. The test runs two of them sequentially, so its
+// own timeout must exceed `2 * SUBPROCESS_TIMEOUT_MS` otherwise the suite's
+// default `testTimeout` (20s) fails the test before these caps do,
+// for example on a slow CI runner where the build+run can take >20s.
+const SUBPROCESS_TIMEOUT_MS = 60_000;
+
+function runBun(args: string[]): { stdout: string; stderr: string; status: number | null } {
+ const res = spawnSync('bun', args, { cwd: dir, encoding: 'utf8', timeout: SUBPROCESS_TIMEOUT_MS });
+ return { stdout: res.stdout ?? '', stderr: res.stderr ?? '', status: res.status };
+}
+
+// Bun orchestrion instrumentation is BUILD-ONLY (`@sentry/bun/plugin` is a
+// `Bun.build` plugin; there is no `bun run` preload).
+//
+// A `bun run` runtime plugin cannot instrument CommonJS dependencies like
+// `pg`: any module returned by a runtime `onLoad` plugin in Bun loses its
+// CommonJS named exports
+//
+// When https://github.com/oven-sh/bun/pull/31770 lands, we can revisit an
+// auto-load plugin for `bun run`.
+describe('orchestrion pg instrumentation (Bun)', () => {
+ it(
+ 'bundles `pg` with the plugin, and the built output fires the pg channel when run',
+ () => {
+ // Build the scenario with the orchestrion `bun build` plugin.
+ const build = runBun(['run', join(dir, 'build.ts')]);
+ expect(build.status, `build failed:\nstderr:\n${build.stderr}\nstdout:\n${build.stdout}`).toBe(0);
+
+ const outfile = build.stdout.match(/BUILD_OK outfile=(.+)/)?.[1]?.trim();
+ expect(outfile, `no outfile in build output:\n${build.stdout}`).toBeTruthy();
+
+ try {
+ // Run the built bundle. The bundled (transformed) `pg` should publish
+ // to the `orchestrion:pg:query` channel when `client.query()` is
+ // called, and the plugin's banner should set the `bundler` marker at
+ // boot.
+ const run = runBun(['run', outfile as string]);
+ expect(run.status, `run failed:\nstderr:\n${run.stderr}\nstdout:\n${run.stdout}`).toBe(0);
+
+ const line = run.stdout.split('\n').find(l => l.startsWith('SCENARIO')) ?? '';
+ // channel `start` fired on `client.query()`
+ expect(line).toContain('events=start');
+ // with the expected SQL
+ expect(line).toContain('statement=SELECT 1 AS solution');
+ // injected banner ran at bundle boot
+ expect(line).toContain('"bundler":true');
+ } finally {
+ if (outfile) {
+ rmSync(dirname(outfile), { recursive: true, force: true });
+ }
+ }
+ // Allow for both sequential `runBun` calls hitting their subprocess
+ // cap, so the `spawnSync` timeouts (not the vitest 20s def) are the
+ // binding limit.
+ },
+ 2 * SUBPROCESS_TIMEOUT_MS,
+ );
+});

dev-packages/e2e-tests/test-applications/deno-pg/deno.json

@@ -0,0 +1,7 @@
+{
+ "imports": {
+ "@sentry/deno": "npm:@sentry/deno",
+ "pg": "npm:pg@8.16.0"
+ },
+ "nodeModulesDir": "manual"
+}

dev-packages/e2e-tests/test-applications/deno-pg/docker-compose.yml

@@ -0,0 +1,17 @@
+services:
+ db:
+ image: postgres:13
+ restart: always
+ container_name: e2e-tests-deno-pg
+ ports:
+ - '5432:5432'
+ environment:
+ POSTGRES_USER: postgres
+ POSTGRES_PASSWORD: password
+ POSTGRES_DB: postgres
+ healthcheck:
+ test: ['CMD-SHELL', 'pg_isready -U postgres -d postgres']
+ interval: 2s
+ timeout: 3s
+ retries: 30
+ start_period: 5s

dev-packages/e2e-tests/test-applications/deno-pg/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 PostgreSQL via Docker Compose. `--wait` blocks until the healthcheck
+ // in docker-compose.yml passes, so the Deno app can connect immediately.
+ execSync('docker compose up -d --wait', {
+ cwd: __dirname,
+ stdio: 'inherit',
+ });
+}

dev-packages/e2e-tests/test-applications/deno-pg/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/deno-pg/package.json

@@ -0,0 +1,23 @@
+{
+ "name": "deno-pg",
+ "version": "1.0.0",
+ "private": true,
+ "scripts": {
+ "start": "docker compose up -d --wait && deno run --allow-net --allow-env --allow-read --allow-sys --allow-write src/app.ts",
+ "test": "playwright test",
+ "clean": "npx rimraf node_modules pnpm-lock.yaml",
+ "test:build": "pnpm install",
+ "test:assert": "pnpm test"
+ },
+ "dependencies": {
+ "@sentry/deno": "file:../../packed/sentry-deno-packed.tgz",
+ "pg": "8.16.0"
+ },
+ "devDependencies": {
+ "@playwright/test": "~1.56.0",
+ "@sentry-internal/test-utils": "link:../../../test-utils"
+ },
+ "volta": {
+ "extends": "../../package.json"
+ }
+}

dev-packages/e2e-tests/test-applications/deno-pg/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/deno-pg/src/app.ts

@@ -0,0 +1,69 @@
+// `@sentry/deno/import` MUST be the very first import: it registers the
+// orchestrion runtime hook, which transforms `pg` (imported dynamically below)
+// to publish the `orchestrion:pg:query` diagnostics channel.
+// In Deno 2.8.0–2.8.2 the hook only works as the first import in the entry
+// graph.
+import '@sentry/deno/import';
+import * as Sentry from '@sentry/deno';
+
+Sentry.init({
+ environment: 'qa',
+ dsn: Deno.env.get('E2E_TEST_DSN'),
+ debug: !!Deno.env.get('DEBUG'),
+ tunnel: 'http://localhost:3031/', // proxy server
+ tracesSampleRate: 1,
+});
+
+// Dynamic import AFTER init so the orchestrion hook (registered above) is in
+// place to transform `pg/lib/client.js`'s `query`, and so
+// `denoPostgresIntegration` (wired by `init()`) is already subscribed.
+const { default: pg } = await import('pg');
+
+const client = new pg.Client({
+ host: Deno.env.get('PGHOST') ?? '127.0.0.1',
+ port: Number(Deno.env.get('PGPORT') ?? 5432),
+ user: 'postgres',
+ password: 'password',
+ database: 'postgres',
+});
+
+// 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.
+client.on('error', (err: unknown) => {
+ // eslint-disable-next-line no-console
+ console.error('pg client error', err);
+});
+
+client.connect((err: unknown) => {
+ if (err) {
+ // eslint-disable-next-line no-console
+ console.error('pg connect error', err);
+ }
+});
+
+const port = 3030;
+
+Deno.serve({ port, hostname: '0.0.0.0' }, async (req: Request) => {
+ const url = new URL(req.url);
+
+ // Runs two queries, the second NESTED inside the first's callback. pg
+ // 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 `denoPostgresIntegration`'s AsyncLocalStorage
+ // context strategy restored the parent across the async boundary.
+ if (url.pathname === '/test-pg') {
+ await new Promise<void>((resolve, reject) => {
+ client.query('SELECT 1 + 1 AS solution', (err: unknown) => {
+ if (err) return reject(err);
+ client.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/deno-pg/start-event-proxy.mjs

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

.github/workflows/build.yml

@@ -1045,9 +1045,7 @@ jobs:
  use-installer: true
  token: ${{ secrets.GITHUB_TOKEN }}
  - name: Set up Deno
- 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'
+ if: contains(matrix.test-application, 'deno') || matrix.test-application == 'hono-4'
  uses: denoland/setup-deno@v2.0.4
  with:
  deno-version: ${{ matrix.deno-version || 'v2.8.0' }}
@@ -1170,7 +1168,7 @@ jobs:
  with:
  node-version-file: 'dev-packages/e2e-tests/test-applications/${{ matrix.test-application }}/package.json'
  - name: Set up Deno
- if: matrix.test-application == 'deno' || matrix.test-application == 'deno-streamed'
+ if: contains(matrix.test-application, 'deno')
  uses: denoland/setup-deno@v2.0.4
  with:
  deno-version: ${{ matrix.deno-version || 'v2.8.0' }}

dev-packages/bun-integration-tests/package.json

@@ -16,7 +16,8 @@
  "@sentry/bun": "10.63.0",
  "@sentry/hono": "10.63.0",
  "hono": "^4.12.25",
- "mysql": "^2.18.1"
+ "mysql": "^2.18.1",
+ "pg": "8.16.0"
  },
  "devDependencies": {
  "@sentry-internal/test-utils": "10.63.0",

dev-packages/bun-integration-tests/suites/orchestrion-postgres/build.ts

@@ -0,0 +1,43 @@
+// Builds the smoke scenario with the orchestrion `bun build` plugin and writes
+// the bundle to a temp dir, printing the output path for test.ts to execute.
+//
+// A successful build proves `bun build` runs with the plugin; running the
+// bundle (see test.ts) then proves the bundled `pg` is actually instrumented.
+
+// @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 { tmpdir } from 'os';
+import { join } from 'path';
+
+void (async () => {
+ const outdir = join(tmpdir(), `sentry-bun-orchestrion-pg-${process.pid}-${Date.now()}`);
+ const result = await Bun.build({
+ entrypoints: [join(__dirname, 'scenario.ts')],
+ target: 'bun',
+ outdir,
+ // Deliberately mark `pg` external. An externalized dependency is resolved
+ // from `node_modules` at runtime and never passes through the transform's
+ // `onLoad`, so its channel injection would be silently skipped. The plugin
+ // must strip instrumented packages back out of `external` so they get
+ // bundled (and thus transformed).
+ external: ['pg'],
+ plugins: [sentryBunPlugin()],
+ });
+
+ if (!result.success) {
+ // eslint-disable-next-line no-console
+ console.error('BUILD_FAILED', result.logs);
+ process.exit(1);
+ }
+
+ const output = result.outputs[0];
+ if (!output) {
+ // eslint-disable-next-line no-console
+ console.error('BUILD_FAILED no outputs');
+ process.exit(1);
+ }
+
+ // eslint-disable-next-line no-console
+ console.log(`BUILD_OK outfile=${output.path}`);
+})();

dev-packages/bun-integration-tests/suites/orchestrion-postgres/scenario.ts

@@ -0,0 +1,61 @@
+// Bundled entry for the `bun build` smoke test.
+//
+// Once `Bun.build` (with the orchestrion plugin) has transformed `pg`,
+// calling `client.query()` publishes to the `orchestrion:pg:query` tracing
+// channel.
+//
+// `start` fires synchronously on the call, so no live database is needed.
+//
+// We subscribe, run a query, and report which channel events fired
+// (plus the detection marker the plugin's banner sets at boot).
+
+import { tracingChannel } from 'node:diagnostics_channel';
+
+// @ts-ignore -- only the runtime value is needed; pg's types are irrelevant
+import pg from 'pg';
+
+interface QueryContext {
+ arguments?: unknown[];
+}
+interface Client {
+ query(sql: string, cb: () => void): void;
+}
+interface PgModule {
+ Client: new (opts: { host: string; user: string; database: string }) => Client;
+}
+
+const events: string[] = [];
+let statement = '';
+
+tracingChannel('orchestrion:pg:query').subscribe({
+ start(message: unknown) {
+ events.push('start');
+ const first = (message as QueryContext).arguments?.[0];
+ statement = typeof first === 'string' ? first : '';
+ },
+ end() {
+ events.push('end');
+ },
+ asyncStart() {},
+ asyncEnd() {
+ events.push('asyncEnd');
+ },
+ error() {},
+});
+
+const client = new (pg as PgModule).Client({ host: '127.0.0.1', user: 'root', database: 'mydb' });
+try {
+ client.query('SELECT 1 AS solution', () => {});
+} catch {
+ // No live server
+ // `start` has already published synchronously by this point.
+}
+
+const marker = (globalThis as { __SENTRY_ORCHESTRION__?: { runtime?: boolean; bundler?: boolean } })
+ .__SENTRY_ORCHESTRION__;
+
+setTimeout(() => {
+ // eslint-disable-next-line no-console
+ console.log(`SCENARIO events=${events.join(',')} statement=${statement} marker=${JSON.stringify(marker ?? null)}`);
+ process.exit(0);
+}, 200);

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

@@ -0,0 +1,65 @@
+import { spawnSync } from 'child_process';
+import { rmSync } from 'fs';
+import { dirname, join } from 'path';
+import { describe, expect, it } from 'vitest';
+
+const dir = __dirname;
+
+// Cap each `bun` subprocess. The test runs two of them sequentially, so its
+// own timeout must exceed `2 * SUBPROCESS_TIMEOUT_MS` otherwise the suite's
+// default `testTimeout` (20s) fails the test before these caps do,
+// for example on a slow CI runner where the build+run can take >20s.
+const SUBPROCESS_TIMEOUT_MS = 60_000;
+
+function runBun(args: string[]): { stdout: string; stderr: string; status: number | null } {
+ const res = spawnSync('bun', args, { cwd: dir, encoding: 'utf8', timeout: SUBPROCESS_TIMEOUT_MS });
+ return { stdout: res.stdout ?? '', stderr: res.stderr ?? '', status: res.status };
+}
+
+// Bun orchestrion instrumentation is BUILD-ONLY (`@sentry/bun/plugin` is a
+// `Bun.build` plugin; there is no `bun run` preload).
+//
+// A `bun run` runtime plugin cannot instrument CommonJS dependencies like
+// `pg`: any module returned by a runtime `onLoad` plugin in Bun loses its
+// CommonJS named exports
+//
+// When https://github.com/oven-sh/bun/pull/31770 lands, we can revisit an
+// auto-load plugin for `bun run`.
+describe('orchestrion pg instrumentation (Bun)', () => {
+ it(
+ 'bundles `pg` with the plugin, and the built output fires the pg channel when run',
+ () => {
+ // Build the scenario with the orchestrion `bun build` plugin.
+ const build = runBun(['run', join(dir, 'build.ts')]);
+ expect(build.status, `build failed:\nstderr:\n${build.stderr}\nstdout:\n${build.stdout}`).toBe(0);
+
+ const outfile = build.stdout.match(/BUILD_OK outfile=(.+)/)?.[1]?.trim();
+ expect(outfile, `no outfile in build output:\n${build.stdout}`).toBeTruthy();
+
+ try {
+ // Run the built bundle. The bundled (transformed) `pg` should publish
+ // to the `orchestrion:pg:query` channel when `client.query()` is
+ // called, and the plugin's banner should set the `bundler` marker at
+ // boot.
+ const run = runBun(['run', outfile as string]);
+ expect(run.status, `run failed:\nstderr:\n${run.stderr}\nstdout:\n${run.stdout}`).toBe(0);
+
+ const line = run.stdout.split('\n').find(l => l.startsWith('SCENARIO')) ?? '';
+ // channel `start` fired on `client.query()`
+ expect(line).toContain('events=start');
+ // with the expected SQL
+ expect(line).toContain('statement=SELECT 1 AS solution');
+ // injected banner ran at bundle boot
+ expect(line).toContain('"bundler":true');
+ } finally {
+ if (outfile) {
+ rmSync(dirname(outfile), { recursive: true, force: true });
+ }
+ }
+ // Allow for both sequential `runBun` calls hitting their subprocess
+ // cap, so the `spawnSync` timeouts (not the vitest 20s def) are the
+ // binding limit.
+ },
+ 2 * SUBPROCESS_TIMEOUT_MS,
+ );
+});

dev-packages/e2e-tests/test-applications/deno-pg/deno.json

@@ -0,0 +1,7 @@
+{
+ "imports": {
+ "@sentry/deno": "npm:@sentry/deno",
+ "pg": "npm:pg@8.16.0"
+ },
+ "nodeModulesDir": "manual"
+}

dev-packages/e2e-tests/test-applications/deno-pg/docker-compose.yml

@@ -0,0 +1,17 @@
+services:
+ db:
+ image: postgres:13
+ restart: always
+ container_name: e2e-tests-deno-pg
+ ports:
+ - '5432:5432'
+ environment:
+ POSTGRES_USER: postgres
+ POSTGRES_PASSWORD: password
+ POSTGRES_DB: postgres
+ healthcheck:
+ test: ['CMD-SHELL', 'pg_isready -U postgres -d postgres']
+ interval: 2s
+ timeout: 3s
+ retries: 30
+ start_period: 5s

dev-packages/e2e-tests/test-applications/deno-pg/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 PostgreSQL via Docker Compose. `--wait` blocks until the healthcheck
+ // in docker-compose.yml passes, so the Deno app can connect immediately.
+ execSync('docker compose up -d --wait', {
+ cwd: __dirname,
+ stdio: 'inherit',
+ });
+}

dev-packages/e2e-tests/test-applications/deno-pg/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/deno-pg/package.json

@@ -0,0 +1,23 @@
+{
+ "name": "deno-pg",
+ "version": "1.0.0",
+ "private": true,
+ "scripts": {
+ "start": "docker compose up -d --wait && deno run --allow-net --allow-env --allow-read --allow-sys --allow-write src/app.ts",
+ "test": "playwright test",
+ "clean": "npx rimraf node_modules pnpm-lock.yaml",
+ "test:build": "pnpm install",
+ "test:assert": "pnpm test"
+ },
+ "dependencies": {
+ "@sentry/deno": "file:../../packed/sentry-deno-packed.tgz",
+ "pg": "8.16.0"
+ },
+ "devDependencies": {
+ "@playwright/test": "~1.56.0",
+ "@sentry-internal/test-utils": "link:../../../test-utils"
+ },
+ "volta": {
+ "extends": "../../package.json"
+ }
+}

dev-packages/e2e-tests/test-applications/deno-pg/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/deno-pg/src/app.ts

@@ -0,0 +1,69 @@
+// `@sentry/deno/import` MUST be the very first import: it registers the
+// orchestrion runtime hook, which transforms `pg` (imported dynamically below)
+// to publish the `orchestrion:pg:query` diagnostics channel.
+// In Deno 2.8.0–2.8.2 the hook only works as the first import in the entry
+// graph.
+import '@sentry/deno/import';
+import * as Sentry from '@sentry/deno';
+
+Sentry.init({
+ environment: 'qa',
+ dsn: Deno.env.get('E2E_TEST_DSN'),
+ debug: !!Deno.env.get('DEBUG'),
+ tunnel: 'http://localhost:3031/', // proxy server
+ tracesSampleRate: 1,
+});
+
+// Dynamic import AFTER init so the orchestrion hook (registered above) is in
+// place to transform `pg/lib/client.js`'s `query`, and so
+// `denoPostgresIntegration` (wired by `init()`) is already subscribed.
+const { default: pg } = await import('pg');
+
+const client = new pg.Client({
+ host: Deno.env.get('PGHOST') ?? '127.0.0.1',
+ port: Number(Deno.env.get('PGPORT') ?? 5432),
+ user: 'postgres',
+ password: 'password',
+ database: 'postgres',
+});
+
+// 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.
+client.on('error', (err: unknown) => {
+ // eslint-disable-next-line no-console
+ console.error('pg client error', err);
+});
+
+client.connect((err: unknown) => {
+ if (err) {
+ // eslint-disable-next-line no-console
+ console.error('pg connect error', err);
+ }
+});
+
+const port = 3030;
+
+Deno.serve({ port, hostname: '0.0.0.0' }, async (req: Request) => {
+ const url = new URL(req.url);
+
+ // Runs two queries, the second NESTED inside the first's callback. pg
+ // 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 `denoPostgresIntegration`'s AsyncLocalStorage
+ // context strategy restored the parent across the async boundary.
+ if (url.pathname === '/test-pg') {
+ await new Promise<void>((resolve, reject) => {
+ client.query('SELECT 1 + 1 AS solution', (err: unknown) => {
+ if (err) return reject(err);
+ client.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/deno-pg/start-event-proxy.mjs

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

.github/workflows/build.yml

@@ -1045,9 +1045,7 @@ jobs:
  use-installer: true
  token: ${{ secrets.GITHUB_TOKEN }}
  - name: Set up Deno
- 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'
+ if: contains(matrix.test-application, 'deno') || matrix.test-application == 'hono-4'
  uses: denoland/setup-deno@v2.0.4
  with:
  deno-version: ${{ matrix.deno-version || 'v2.8.0' }}
@@ -1170,7 +1168,7 @@ jobs:
  with:
  node-version-file: 'dev-packages/e2e-tests/test-applications/${{ matrix.test-application }}/package.json'
  - name: Set up Deno
- if: matrix.test-application == 'deno' || matrix.test-application == 'deno-streamed'
+ if: contains(matrix.test-application, 'deno')
  uses: denoland/setup-deno@v2.0.4
  with:
  deno-version: ${{ matrix.deno-version || 'v2.8.0' }}

dev-packages/bun-integration-tests/package.json

@@ -16,7 +16,8 @@
  "@sentry/bun": "10.63.0",
  "@sentry/hono": "10.63.0",
  "hono": "^4.12.25",
- "mysql": "^2.18.1"
+ "mysql": "^2.18.1",
+ "pg": "8.16.0"
  },
  "devDependencies": {
  "@sentry-internal/test-utils": "10.63.0",

dev-packages/bun-integration-tests/suites/orchestrion-postgres/build.ts

@@ -0,0 +1,43 @@
+// Builds the smoke scenario with the orchestrion `bun build` plugin and writes
+// the bundle to a temp dir, printing the output path for test.ts to execute.
+//
+// A successful build proves `bun build` runs with the plugin; running the
+// bundle (see test.ts) then proves the bundled `pg` is actually instrumented.
+
+// @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 { tmpdir } from 'os';
+import { join } from 'path';
+
+void (async () => {
+ const outdir = join(tmpdir(), `sentry-bun-orchestrion-pg-${process.pid}-${Date.now()}`);
+ const result = await Bun.build({
+ entrypoints: [join(__dirname, 'scenario.ts')],
+ target: 'bun',
+ outdir,
+ // Deliberately mark `pg` external. An externalized dependency is resolved
+ // from `node_modules` at runtime and never passes through the transform's
+ // `onLoad`, so its channel injection would be silently skipped. The plugin
+ // must strip instrumented packages back out of `external` so they get
+ // bundled (and thus transformed).
+ external: ['pg'],
+ plugins: [sentryBunPlugin()],
+ });
+
+ if (!result.success) {
+ // eslint-disable-next-line no-console
+ console.error('BUILD_FAILED', result.logs);
+ process.exit(1);
+ }
+
+ const output = result.outputs[0];
+ if (!output) {
+ // eslint-disable-next-line no-console
+ console.error('BUILD_FAILED no outputs');
+ process.exit(1);
+ }
+
+ // eslint-disable-next-line no-console
+ console.log(`BUILD_OK outfile=${output.path}`);
+})();

dev-packages/bun-integration-tests/suites/orchestrion-postgres/scenario.ts

@@ -0,0 +1,61 @@
+// Bundled entry for the `bun build` smoke test.
+//
+// Once `Bun.build` (with the orchestrion plugin) has transformed `pg`,
+// calling `client.query()` publishes to the `orchestrion:pg:query` tracing
+// channel.
+//
+// `start` fires synchronously on the call, so no live database is needed.
+//
+// We subscribe, run a query, and report which channel events fired
+// (plus the detection marker the plugin's banner sets at boot).
+
+import { tracingChannel } from 'node:diagnostics_channel';
+
+// @ts-ignore -- only the runtime value is needed; pg's types are irrelevant
+import pg from 'pg';
+
+interface QueryContext {
+ arguments?: unknown[];
+}
+interface Client {
+ query(sql: string, cb: () => void): void;
+}
+interface PgModule {
+ Client: new (opts: { host: string; user: string; database: string }) => Client;
+}
+
+const events: string[] = [];
+let statement = '';
+
+tracingChannel('orchestrion:pg:query').subscribe({
+ start(message: unknown) {
+ events.push('start');
+ const first = (message as QueryContext).arguments?.[0];
+ statement = typeof first === 'string' ? first : '';
+ },
+ end() {
+ events.push('end');
+ },
+ asyncStart() {},
+ asyncEnd() {
+ events.push('asyncEnd');
+ },
+ error() {},
+});
+
+const client = new (pg as PgModule).Client({ host: '127.0.0.1', user: 'root', database: 'mydb' });
+try {
+ client.query('SELECT 1 AS solution', () => {});
+} catch {
+ // No live server
+ // `start` has already published synchronously by this point.
+}
+
+const marker = (globalThis as { __SENTRY_ORCHESTRION__?: { runtime?: boolean; bundler?: boolean } })
+ .__SENTRY_ORCHESTRION__;
+
+setTimeout(() => {
+ // eslint-disable-next-line no-console
+ console.log(`SCENARIO events=${events.join(',')} statement=${statement} marker=${JSON.stringify(marker ?? null)}`);
+ process.exit(0);
+}, 200);

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

@@ -0,0 +1,65 @@
+import { spawnSync } from 'child_process';
+import { rmSync } from 'fs';
+import { dirname, join } from 'path';
+import { describe, expect, it } from 'vitest';
+
+const dir = __dirname;
+
+// Cap each `bun` subprocess. The test runs two of them sequentially, so its
+// own timeout must exceed `2 * SUBPROCESS_TIMEOUT_MS` otherwise the suite's
+// default `testTimeout` (20s) fails the test before these caps do,
+// for example on a slow CI runner where the build+run can take >20s.
+const SUBPROCESS_TIMEOUT_MS = 60_000;
+
+function runBun(args: string[]): { stdout: string; stderr: string; status: number | null } {
+ const res = spawnSync('bun', args, { cwd: dir, encoding: 'utf8', timeout: SUBPROCESS_TIMEOUT_MS });
+ return { stdout: res.stdout ?? '', stderr: res.stderr ?? '', status: res.status };
+}
+
+// Bun orchestrion instrumentation is BUILD-ONLY (`@sentry/bun/plugin` is a
+// `Bun.build` plugin; there is no `bun run` preload).
+//
+// A `bun run` runtime plugin cannot instrument CommonJS dependencies like
+// `pg`: any module returned by a runtime `onLoad` plugin in Bun loses its
+// CommonJS named exports
+//
+// When https://github.com/oven-sh/bun/pull/31770 lands, we can revisit an
+// auto-load plugin for `bun run`.
+describe('orchestrion pg instrumentation (Bun)', () => {
+ it(
+ 'bundles `pg` with the plugin, and the built output fires the pg channel when run',
+ () => {
+ // Build the scenario with the orchestrion `bun build` plugin.
+ const build = runBun(['run', join(dir, 'build.ts')]);
+ expect(build.status, `build failed:\nstderr:\n${build.stderr}\nstdout:\n${build.stdout}`).toBe(0);
+
+ const outfile = build.stdout.match(/BUILD_OK outfile=(.+)/)?.[1]?.trim();
+ expect(outfile, `no outfile in build output:\n${build.stdout}`).toBeTruthy();
+
+ try {
+ // Run the built bundle. The bundled (transformed) `pg` should publish
+ // to the `orchestrion:pg:query` channel when `client.query()` is
+ // called, and the plugin's banner should set the `bundler` marker at
+ // boot.
+ const run = runBun(['run', outfile as string]);
+ expect(run.status, `run failed:\nstderr:\n${run.stderr}\nstdout:\n${run.stdout}`).toBe(0);
+
+ const line = run.stdout.split('\n').find(l => l.startsWith('SCENARIO')) ?? '';
+ // channel `start` fired on `client.query()`
+ expect(line).toContain('events=start');
+ // with the expected SQL
+ expect(line).toContain('statement=SELECT 1 AS solution');
+ // injected banner ran at bundle boot
+ expect(line).toContain('"bundler":true');
+ } finally {
+ if (outfile) {
+ rmSync(dirname(outfile), { recursive: true, force: true });
+ }
+ }
+ // Allow for both sequential `runBun` calls hitting their subprocess
+ // cap, so the `spawnSync` timeouts (not the vitest 20s def) are the
+ // binding limit.
+ },
+ 2 * SUBPROCESS_TIMEOUT_MS,
+ );
+});

dev-packages/e2e-tests/test-applications/deno-pg/deno.json

@@ -0,0 +1,7 @@
+{
+ "imports": {
+ "@sentry/deno": "npm:@sentry/deno",
+ "pg": "npm:pg@8.16.0"
+ },
+ "nodeModulesDir": "manual"
+}

dev-packages/e2e-tests/test-applications/deno-pg/docker-compose.yml

@@ -0,0 +1,17 @@
+services:
+ db:
+ image: postgres:13
+ restart: always
+ container_name: e2e-tests-deno-pg
+ ports:
+ - '5432:5432'
+ environment:
+ POSTGRES_USER: postgres
+ POSTGRES_PASSWORD: password
+ POSTGRES_DB: postgres
+ healthcheck:
+ test: ['CMD-SHELL', 'pg_isready -U postgres -d postgres']
+ interval: 2s
+ timeout: 3s
+ retries: 30
+ start_period: 5s

dev-packages/e2e-tests/test-applications/deno-pg/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 PostgreSQL via Docker Compose. `--wait` blocks until the healthcheck
+ // in docker-compose.yml passes, so the Deno app can connect immediately.
+ execSync('docker compose up -d --wait', {
+ cwd: __dirname,
+ stdio: 'inherit',
+ });
+}

dev-packages/e2e-tests/test-applications/deno-pg/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/deno-pg/package.json

@@ -0,0 +1,23 @@
+{
+ "name": "deno-pg",
+ "version": "1.0.0",
+ "private": true,
+ "scripts": {
+ "start": "docker compose up -d --wait && deno run --allow-net --allow-env --allow-read --allow-sys --allow-write src/app.ts",
+ "test": "playwright test",
+ "clean": "npx rimraf node_modules pnpm-lock.yaml",
+ "test:build": "pnpm install",
+ "test:assert": "pnpm test"
+ },
+ "dependencies": {
+ "@sentry/deno": "file:../../packed/sentry-deno-packed.tgz",
+ "pg": "8.16.0"
+ },
+ "devDependencies": {
+ "@playwright/test": "~1.56.0",
+ "@sentry-internal/test-utils": "link:../../../test-utils"
+ },
+ "volta": {
+ "extends": "../../package.json"
+ }
+}

dev-packages/e2e-tests/test-applications/deno-pg/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/deno-pg/src/app.ts

@@ -0,0 +1,69 @@
+// `@sentry/deno/import` MUST be the very first import: it registers the
+// orchestrion runtime hook, which transforms `pg` (imported dynamically below)
+// to publish the `orchestrion:pg:query` diagnostics channel.
+// In Deno 2.8.0–2.8.2 the hook only works as the first import in the entry
+// graph.
+import '@sentry/deno/import';
+import * as Sentry from '@sentry/deno';
+
+Sentry.init({
+ environment: 'qa',
+ dsn: Deno.env.get('E2E_TEST_DSN'),
+ debug: !!Deno.env.get('DEBUG'),
+ tunnel: 'http://localhost:3031/', // proxy server
+ tracesSampleRate: 1,
+});
+
+// Dynamic import AFTER init so the orchestrion hook (registered above) is in
+// place to transform `pg/lib/client.js`'s `query`, and so
+// `denoPostgresIntegration` (wired by `init()`) is already subscribed.
+const { default: pg } = await import('pg');
+
+const client = new pg.Client({
+ host: Deno.env.get('PGHOST') ?? '127.0.0.1',
+ port: Number(Deno.env.get('PGPORT') ?? 5432),
+ user: 'postgres',
+ password: 'password',
+ database: 'postgres',
+});
+
+// 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.
+client.on('error', (err: unknown) => {
+ // eslint-disable-next-line no-console
+ console.error('pg client error', err);
+});
+
+client.connect((err: unknown) => {
+ if (err) {
+ // eslint-disable-next-line no-console
+ console.error('pg connect error', err);
+ }
+});
+
+const port = 3030;
+
+Deno.serve({ port, hostname: '0.0.0.0' }, async (req: Request) => {
+ const url = new URL(req.url);
+
+ // Runs two queries, the second NESTED inside the first's callback. pg
+ // 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 `denoPostgresIntegration`'s AsyncLocalStorage
+ // context strategy restored the parent across the async boundary.
+ if (url.pathname === '/test-pg') {
+ await new Promise<void>((resolve, reject) => {
+ client.query('SELECT 1 + 1 AS solution', (err: unknown) => {
+ if (err) return reject(err);
+ client.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/deno-pg/start-event-proxy.mjs

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

.github/workflows/build.yml

@@ -1045,9 +1045,7 @@ jobs:
  use-installer: true
  token: ${{ secrets.GITHUB_TOKEN }}
  - name: Set up Deno
- 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'
+ if: contains(matrix.test-application, 'deno') || matrix.test-application == 'hono-4'
  uses: denoland/setup-deno@v2.0.4
  with:
  deno-version: ${{ matrix.deno-version || 'v2.8.0' }}
@@ -1170,7 +1168,7 @@ jobs:
  with:
  node-version-file: 'dev-packages/e2e-tests/test-applications/${{ matrix.test-application }}/package.json'
  - name: Set up Deno
- if: matrix.test-application == 'deno' || matrix.test-application == 'deno-streamed'
+ if: contains(matrix.test-application, 'deno')
  uses: denoland/setup-deno@v2.0.4
  with:
  deno-version: ${{ matrix.deno-version || 'v2.8.0' }}

dev-packages/bun-integration-tests/package.json

@@ -16,7 +16,8 @@
  "@sentry/bun": "10.63.0",
  "@sentry/hono": "10.63.0",
  "hono": "^4.12.25",
- "mysql": "^2.18.1"
+ "mysql": "^2.18.1",
+ "pg": "8.16.0"
  },
  "devDependencies": {
  "@sentry-internal/test-utils": "10.63.0",

dev-packages/bun-integration-tests/suites/orchestrion-postgres/build.ts

@@ -0,0 +1,43 @@
+// Builds the smoke scenario with the orchestrion `bun build` plugin and writes
+// the bundle to a temp dir, printing the output path for test.ts to execute.
+//
+// A successful build proves `bun build` runs with the plugin; running the
+// bundle (see test.ts) then proves the bundled `pg` is actually instrumented.
+
+// @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 { tmpdir } from 'os';
+import { join } from 'path';
+
+void (async () => {
+ const outdir = join(tmpdir(), `sentry-bun-orchestrion-pg-${process.pid}-${Date.now()}`);
+ const result = await Bun.build({
+ entrypoints: [join(__dirname, 'scenario.ts')],
+ target: 'bun',
+ outdir,
+ // Deliberately mark `pg` external. An externalized dependency is resolved
+ // from `node_modules` at runtime and never passes through the transform's
+ // `onLoad`, so its channel injection would be silently skipped. The plugin
+ // must strip instrumented packages back out of `external` so they get
+ // bundled (and thus transformed).
+ external: ['pg'],
+ plugins: [sentryBunPlugin()],
+ });
+
+ if (!result.success) {
+ // eslint-disable-next-line no-console
+ console.error('BUILD_FAILED', result.logs);
+ process.exit(1);
+ }
+
+ const output = result.outputs[0];
+ if (!output) {
+ // eslint-disable-next-line no-console
+ console.error('BUILD_FAILED no outputs');
+ process.exit(1);
+ }
+
+ // eslint-disable-next-line no-console
+ console.log(`BUILD_OK outfile=${output.path}`);
+})();

dev-packages/bun-integration-tests/suites/orchestrion-postgres/scenario.ts

@@ -0,0 +1,61 @@
+// Bundled entry for the `bun build` smoke test.
+//
+// Once `Bun.build` (with the orchestrion plugin) has transformed `pg`,
+// calling `client.query()` publishes to the `orchestrion:pg:query` tracing
+// channel.
+//
+// `start` fires synchronously on the call, so no live database is needed.
+//
+// We subscribe, run a query, and report which channel events fired
+// (plus the detection marker the plugin's banner sets at boot).
+
+import { tracingChannel } from 'node:diagnostics_channel';
+
+// @ts-ignore -- only the runtime value is needed; pg's types are irrelevant
+import pg from 'pg';
+
+interface QueryContext {
+ arguments?: unknown[];
+}
+interface Client {
+ query(sql: string, cb: () => void): void;
+}
+interface PgModule {
+ Client: new (opts: { host: string; user: string; database: string }) => Client;
+}
+
+const events: string[] = [];
+let statement = '';
+
+tracingChannel('orchestrion:pg:query').subscribe({
+ start(message: unknown) {
+ events.push('start');
+ const first = (message as QueryContext).arguments?.[0];
+ statement = typeof first === 'string' ? first : '';
+ },
+ end() {
+ events.push('end');
+ },
+ asyncStart() {},
+ asyncEnd() {
+ events.push('asyncEnd');
+ },
+ error() {},
+});
+
+const client = new (pg as PgModule).Client({ host: '127.0.0.1', user: 'root', database: 'mydb' });
+try {
+ client.query('SELECT 1 AS solution', () => {});
+} catch {
+ // No live server
+ // `start` has already published synchronously by this point.
+}
+
+const marker = (globalThis as { __SENTRY_ORCHESTRION__?: { runtime?: boolean; bundler?: boolean } })
+ .__SENTRY_ORCHESTRION__;
+
+setTimeout(() => {
+ // eslint-disable-next-line no-console
+ console.log(`SCENARIO events=${events.join(',')} statement=${statement} marker=${JSON.stringify(marker ?? null)}`);
+ process.exit(0);
+}, 200);

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

@@ -0,0 +1,65 @@
+import { spawnSync } from 'child_process';
+import { rmSync } from 'fs';
+import { dirname, join } from 'path';
+import { describe, expect, it } from 'vitest';
+
+const dir = __dirname;
+
+// Cap each `bun` subprocess. The test runs two of them sequentially, so its
+// own timeout must exceed `2 * SUBPROCESS_TIMEOUT_MS` otherwise the suite's
+// default `testTimeout` (20s) fails the test before these caps do,
+// for example on a slow CI runner where the build+run can take >20s.
+const SUBPROCESS_TIMEOUT_MS = 60_000;
+
+function runBun(args: string[]): { stdout: string; stderr: string; status: number | null } {
+ const res = spawnSync('bun', args, { cwd: dir, encoding: 'utf8', timeout: SUBPROCESS_TIMEOUT_MS });
+ return { stdout: res.stdout ?? '', stderr: res.stderr ?? '', status: res.status };
+}
+
+// Bun orchestrion instrumentation is BUILD-ONLY (`@sentry/bun/plugin` is a
+// `Bun.build` plugin; there is no `bun run` preload).
+//
+// A `bun run` runtime plugin cannot instrument CommonJS dependencies like
+// `pg`: any module returned by a runtime `onLoad` plugin in Bun loses its
+// CommonJS named exports
+//
+// When https://github.com/oven-sh/bun/pull/31770 lands, we can revisit an
+// auto-load plugin for `bun run`.
+describe('orchestrion pg instrumentation (Bun)', () => {
+ it(
+ 'bundles `pg` with the plugin, and the built output fires the pg channel when run',
+ () => {
+ // Build the scenario with the orchestrion `bun build` plugin.
+ const build = runBun(['run', join(dir, 'build.ts')]);
+ expect(build.status, `build failed:\nstderr:\n${build.stderr}\nstdout:\n${build.stdout}`).toBe(0);
+
+ const outfile = build.stdout.match(/BUILD_OK outfile=(.+)/)?.[1]?.trim();
+ expect(outfile, `no outfile in build output:\n${build.stdout}`).toBeTruthy();
+
+ try {
+ // Run the built bundle. The bundled (transformed) `pg` should publish
+ // to the `orchestrion:pg:query` channel when `client.query()` is
+ // called, and the plugin's banner should set the `bundler` marker at
+ // boot.
+ const run = runBun(['run', outfile as string]);
+ expect(run.status, `run failed:\nstderr:\n${run.stderr}\nstdout:\n${run.stdout}`).toBe(0);
+
+ const line = run.stdout.split('\n').find(l => l.startsWith('SCENARIO')) ?? '';
+ // channel `start` fired on `client.query()`
+ expect(line).toContain('events=start');
+ // with the expected SQL
+ expect(line).toContain('statement=SELECT 1 AS solution');
+ // injected banner ran at bundle boot
+ expect(line).toContain('"bundler":true');
+ } finally {
+ if (outfile) {
+ rmSync(dirname(outfile), { recursive: true, force: true });
+ }
+ }
+ // Allow for both sequential `runBun` calls hitting their subprocess
+ // cap, so the `spawnSync` timeouts (not the vitest 20s def) are the
+ // binding limit.
+ },
+ 2 * SUBPROCESS_TIMEOUT_MS,
+ );
+});

dev-packages/e2e-tests/test-applications/deno-pg/deno.json

@@ -0,0 +1,7 @@
+{
+ "imports": {
+ "@sentry/deno": "npm:@sentry/deno",
+ "pg": "npm:pg@8.16.0"
+ },
+ "nodeModulesDir": "manual"
+}

dev-packages/e2e-tests/test-applications/deno-pg/docker-compose.yml

@@ -0,0 +1,17 @@
+services:
+ db:
+ image: postgres:13
+ restart: always
+ container_name: e2e-tests-deno-pg
+ ports:
+ - '5432:5432'
+ environment:
+ POSTGRES_USER: postgres
+ POSTGRES_PASSWORD: password
+ POSTGRES_DB: postgres
+ healthcheck:
+ test: ['CMD-SHELL', 'pg_isready -U postgres -d postgres']
+ interval: 2s
+ timeout: 3s
+ retries: 30
+ start_period: 5s

dev-packages/e2e-tests/test-applications/deno-pg/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 PostgreSQL via Docker Compose. `--wait` blocks until the healthcheck
+ // in docker-compose.yml passes, so the Deno app can connect immediately.
+ execSync('docker compose up -d --wait', {
+ cwd: __dirname,
+ stdio: 'inherit',
+ });
+}

dev-packages/e2e-tests/test-applications/deno-pg/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/deno-pg/package.json

@@ -0,0 +1,23 @@
+{
+ "name": "deno-pg",
+ "version": "1.0.0",
+ "private": true,
+ "scripts": {
+ "start": "docker compose up -d --wait && deno run --allow-net --allow-env --allow-read --allow-sys --allow-write src/app.ts",
+ "test": "playwright test",
+ "clean": "npx rimraf node_modules pnpm-lock.yaml",
+ "test:build": "pnpm install",
+ "test:assert": "pnpm test"
+ },
+ "dependencies": {
+ "@sentry/deno": "file:../../packed/sentry-deno-packed.tgz",
+ "pg": "8.16.0"
+ },
+ "devDependencies": {
+ "@playwright/test": "~1.56.0",
+ "@sentry-internal/test-utils": "link:../../../test-utils"
+ },
+ "volta": {
+ "extends": "../../package.json"
+ }
+}

dev-packages/e2e-tests/test-applications/deno-pg/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/deno-pg/src/app.ts

@@ -0,0 +1,69 @@
+// `@sentry/deno/import` MUST be the very first import: it registers the
+// orchestrion runtime hook, which transforms `pg` (imported dynamically below)
+// to publish the `orchestrion:pg:query` diagnostics channel.
+// In Deno 2.8.0–2.8.2 the hook only works as the first import in the entry
+// graph.
+import '@sentry/deno/import';
+import * as Sentry from '@sentry/deno';
+
+Sentry.init({
+ environment: 'qa',
+ dsn: Deno.env.get('E2E_TEST_DSN'),
+ debug: !!Deno.env.get('DEBUG'),
+ tunnel: 'http://localhost:3031/', // proxy server
+ tracesSampleRate: 1,
+});
+
+// Dynamic import AFTER init so the orchestrion hook (registered above) is in
+// place to transform `pg/lib/client.js`'s `query`, and so
+// `denoPostgresIntegration` (wired by `init()`) is already subscribed.
+const { default: pg } = await import('pg');
+
+const client = new pg.Client({
+ host: Deno.env.get('PGHOST') ?? '127.0.0.1',
+ port: Number(Deno.env.get('PGPORT') ?? 5432),
+ user: 'postgres',
+ password: 'password',
+ database: 'postgres',
+});
+
+// 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.
+client.on('error', (err: unknown) => {
+ // eslint-disable-next-line no-console
+ console.error('pg client error', err);
+});
+
+client.connect((err: unknown) => {
+ if (err) {
+ // eslint-disable-next-line no-console
+ console.error('pg connect error', err);
+ }
+});
+
+const port = 3030;
+
+Deno.serve({ port, hostname: '0.0.0.0' }, async (req: Request) => {
+ const url = new URL(req.url);
+
+ // Runs two queries, the second NESTED inside the first's callback. pg
+ // 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 `denoPostgresIntegration`'s AsyncLocalStorage
+ // context strategy restored the parent across the async boundary.
+ if (url.pathname === '/test-pg') {
+ await new Promise<void>((resolve, reject) => {
+ client.query('SELECT 1 + 1 AS solution', (err: unknown) => {
+ if (err) return reject(err);
+ client.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/deno-pg/start-event-proxy.mjs

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

.github/workflows/build.yml

@@ -1045,9 +1045,7 @@ jobs:
  use-installer: true
  token: ${{ secrets.GITHUB_TOKEN }}
  - name: Set up Deno
- 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'
+ if: contains(matrix.test-application, 'deno') || matrix.test-application == 'hono-4'
  uses: denoland/setup-deno@v2.0.4
  with:
  deno-version: ${{ matrix.deno-version || 'v2.8.0' }}
@@ -1170,7 +1168,7 @@ jobs:
  with:
  node-version-file: 'dev-packages/e2e-tests/test-applications/${{ matrix.test-application }}/package.json'
  - name: Set up Deno
- if: matrix.test-application == 'deno' || matrix.test-application == 'deno-streamed'
+ if: contains(matrix.test-application, 'deno')
  uses: denoland/setup-deno@v2.0.4
  with:
  deno-version: ${{ matrix.deno-version || 'v2.8.0' }}

dev-packages/bun-integration-tests/package.json

@@ -16,7 +16,8 @@
  "@sentry/bun": "10.63.0",
  "@sentry/hono": "10.63.0",
  "hono": "^4.12.25",
- "mysql": "^2.18.1"
+ "mysql": "^2.18.1",
+ "pg": "8.16.0"
  },
  "devDependencies": {
  "@sentry-internal/test-utils": "10.63.0",

dev-packages/bun-integration-tests/suites/orchestrion-postgres/build.ts

@@ -0,0 +1,43 @@
+// Builds the smoke scenario with the orchestrion `bun build` plugin and writes
+// the bundle to a temp dir, printing the output path for test.ts to execute.
+//
+// A successful build proves `bun build` runs with the plugin; running the
+// bundle (see test.ts) then proves the bundled `pg` is actually instrumented.
+
+// @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 { tmpdir } from 'os';
+import { join } from 'path';
+
+void (async () => {
+ const outdir = join(tmpdir(), `sentry-bun-orchestrion-pg-${process.pid}-${Date.now()}`);
+ const result = await Bun.build({
+ entrypoints: [join(__dirname, 'scenario.ts')],
+ target: 'bun',
+ outdir,
+ // Deliberately mark `pg` external. An externalized dependency is resolved
+ // from `node_modules` at runtime and never passes through the transform's
+ // `onLoad`, so its channel injection would be silently skipped. The plugin
+ // must strip instrumented packages back out of `external` so they get
+ // bundled (and thus transformed).
+ external: ['pg'],
+ plugins: [sentryBunPlugin()],
+ });
+
+ if (!result.success) {
+ // eslint-disable-next-line no-console
+ console.error('BUILD_FAILED', result.logs);
+ process.exit(1);
+ }
+
+ const output = result.outputs[0];
+ if (!output) {
+ // eslint-disable-next-line no-console
+ console.error('BUILD_FAILED no outputs');
+ process.exit(1);
+ }
+
+ // eslint-disable-next-line no-console
+ console.log(`BUILD_OK outfile=${output.path}`);
+})();

dev-packages/bun-integration-tests/suites/orchestrion-postgres/scenario.ts

@@ -0,0 +1,61 @@
+// Bundled entry for the `bun build` smoke test.
+//
+// Once `Bun.build` (with the orchestrion plugin) has transformed `pg`,
+// calling `client.query()` publishes to the `orchestrion:pg:query` tracing
+// channel.
+//
+// `start` fires synchronously on the call, so no live database is needed.
+//
+// We subscribe, run a query, and report which channel events fired
+// (plus the detection marker the plugin's banner sets at boot).
+
+import { tracingChannel } from 'node:diagnostics_channel';
+
+// @ts-ignore -- only the runtime value is needed; pg's types are irrelevant
+import pg from 'pg';
+
+interface QueryContext {
+ arguments?: unknown[];
+}
+interface Client {
+ query(sql: string, cb: () => void): void;
+}
+interface PgModule {
+ Client: new (opts: { host: string; user: string; database: string }) => Client;
+}
+
+const events: string[] = [];
+let statement = '';
+
+tracingChannel('orchestrion:pg:query').subscribe({
+ start(message: unknown) {
+ events.push('start');
+ const first = (message as QueryContext).arguments?.[0];
+ statement = typeof first === 'string' ? first : '';
+ },
+ end() {
+ events.push('end');
+ },
+ asyncStart() {},
+ asyncEnd() {
+ events.push('asyncEnd');
+ },
+ error() {},
+});
+
+const client = new (pg as PgModule).Client({ host: '127.0.0.1', user: 'root', database: 'mydb' });
+try {
+ client.query('SELECT 1 AS solution', () => {});
+} catch {
+ // No live server
+ // `start` has already published synchronously by this point.
+}
+
+const marker = (globalThis as { __SENTRY_ORCHESTRION__?: { runtime?: boolean; bundler?: boolean } })
+ .__SENTRY_ORCHESTRION__;
+
+setTimeout(() => {
+ // eslint-disable-next-line no-console
+ console.log(`SCENARIO events=${events.join(',')} statement=${statement} marker=${JSON.stringify(marker ?? null)}`);
+ process.exit(0);
+}, 200);

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

@@ -0,0 +1,65 @@
+import { spawnSync } from 'child_process';
+import { rmSync } from 'fs';
+import { dirname, join } from 'path';
+import { describe, expect, it } from 'vitest';
+
+const dir = __dirname;
+
+// Cap each `bun` subprocess. The test runs two of them sequentially, so its
+// own timeout must exceed `2 * SUBPROCESS_TIMEOUT_MS` otherwise the suite's
+// default `testTimeout` (20s) fails the test before these caps do,
+// for example on a slow CI runner where the build+run can take >20s.
+const SUBPROCESS_TIMEOUT_MS = 60_000;
+
+function runBun(args: string[]): { stdout: string; stderr: string; status: number | null } {
+ const res = spawnSync('bun', args, { cwd: dir, encoding: 'utf8', timeout: SUBPROCESS_TIMEOUT_MS });
+ return { stdout: res.stdout ?? '', stderr: res.stderr ?? '', status: res.status };
+}
+
+// Bun orchestrion instrumentation is BUILD-ONLY (`@sentry/bun/plugin` is a
+// `Bun.build` plugin; there is no `bun run` preload).
+//
+// A `bun run` runtime plugin cannot instrument CommonJS dependencies like
+// `pg`: any module returned by a runtime `onLoad` plugin in Bun loses its
+// CommonJS named exports
+//
+// When https://github.com/oven-sh/bun/pull/31770 lands, we can revisit an
+// auto-load plugin for `bun run`.
+describe('orchestrion pg instrumentation (Bun)', () => {
+ it(
+ 'bundles `pg` with the plugin, and the built output fires the pg channel when run',
+ () => {
+ // Build the scenario with the orchestrion `bun build` plugin.
+ const build = runBun(['run', join(dir, 'build.ts')]);
+ expect(build.status, `build failed:\nstderr:\n${build.stderr}\nstdout:\n${build.stdout}`).toBe(0);
+
+ const outfile = build.stdout.match(/BUILD_OK outfile=(.+)/)?.[1]?.trim();
+ expect(outfile, `no outfile in build output:\n${build.stdout}`).toBeTruthy();
+
+ try {
+ // Run the built bundle. The bundled (transformed) `pg` should publish
+ // to the `orchestrion:pg:query` channel when `client.query()` is
+ // called, and the plugin's banner should set the `bundler` marker at
+ // boot.
+ const run = runBun(['run', outfile as string]);
+ expect(run.status, `run failed:\nstderr:\n${run.stderr}\nstdout:\n${run.stdout}`).toBe(0);
+
+ const line = run.stdout.split('\n').find(l => l.startsWith('SCENARIO')) ?? '';
+ // channel `start` fired on `client.query()`
+ expect(line).toContain('events=start');
+ // with the expected SQL
+ expect(line).toContain('statement=SELECT 1 AS solution');
+ // injected banner ran at bundle boot
+ expect(line).toContain('"bundler":true');
+ } finally {
+ if (outfile) {
+ rmSync(dirname(outfile), { recursive: true, force: true });
+ }
+ }
+ // Allow for both sequential `runBun` calls hitting their subprocess
+ // cap, so the `spawnSync` timeouts (not the vitest 20s def) are the
+ // binding limit.
+ },
+ 2 * SUBPROCESS_TIMEOUT_MS,
+ );
+});

dev-packages/e2e-tests/test-applications/deno-pg/deno.json

@@ -0,0 +1,7 @@
+{
+ "imports": {
+ "@sentry/deno": "npm:@sentry/deno",
+ "pg": "npm:pg@8.16.0"
+ },
+ "nodeModulesDir": "manual"
+}

dev-packages/e2e-tests/test-applications/deno-pg/docker-compose.yml

@@ -0,0 +1,17 @@
+services:
+ db:
+ image: postgres:13
+ restart: always
+ container_name: e2e-tests-deno-pg
+ ports:
+ - '5432:5432'
+ environment:
+ POSTGRES_USER: postgres
+ POSTGRES_PASSWORD: password
+ POSTGRES_DB: postgres
+ healthcheck:
+ test: ['CMD-SHELL', 'pg_isready -U postgres -d postgres']
+ interval: 2s
+ timeout: 3s
+ retries: 30
+ start_period: 5s

dev-packages/e2e-tests/test-applications/deno-pg/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 PostgreSQL via Docker Compose. `--wait` blocks until the healthcheck
+ // in docker-compose.yml passes, so the Deno app can connect immediately.
+ execSync('docker compose up -d --wait', {
+ cwd: __dirname,
+ stdio: 'inherit',
+ });
+}

dev-packages/e2e-tests/test-applications/deno-pg/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/deno-pg/package.json

@@ -0,0 +1,23 @@
+{
+ "name": "deno-pg",
+ "version": "1.0.0",
+ "private": true,
+ "scripts": {
+ "start": "docker compose up -d --wait && deno run --allow-net --allow-env --allow-read --allow-sys --allow-write src/app.ts",
+ "test": "playwright test",
+ "clean": "npx rimraf node_modules pnpm-lock.yaml",
+ "test:build": "pnpm install",
+ "test:assert": "pnpm test"
+ },
+ "dependencies": {
+ "@sentry/deno": "file:../../packed/sentry-deno-packed.tgz",
+ "pg": "8.16.0"
+ },
+ "devDependencies": {
+ "@playwright/test": "~1.56.0",
+ "@sentry-internal/test-utils": "link:../../../test-utils"
+ },
+ "volta": {
+ "extends": "../../package.json"
+ }
+}

dev-packages/e2e-tests/test-applications/deno-pg/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/deno-pg/src/app.ts

@@ -0,0 +1,69 @@
+// `@sentry/deno/import` MUST be the very first import: it registers the
+// orchestrion runtime hook, which transforms `pg` (imported dynamically below)
+// to publish the `orchestrion:pg:query` diagnostics channel.
+// In Deno 2.8.0–2.8.2 the hook only works as the first import in the entry
+// graph.
+import '@sentry/deno/import';
+import * as Sentry from '@sentry/deno';
+
+Sentry.init({
+ environment: 'qa',
+ dsn: Deno.env.get('E2E_TEST_DSN'),
+ debug: !!Deno.env.get('DEBUG'),
+ tunnel: 'http://localhost:3031/', // proxy server
+ tracesSampleRate: 1,
+});
+
+// Dynamic import AFTER init so the orchestrion hook (registered above) is in
+// place to transform `pg/lib/client.js`'s `query`, and so
+// `denoPostgresIntegration` (wired by `init()`) is already subscribed.
+const { default: pg } = await import('pg');
+
+const client = new pg.Client({
+ host: Deno.env.get('PGHOST') ?? '127.0.0.1',
+ port: Number(Deno.env.get('PGPORT') ?? 5432),
+ user: 'postgres',
+ password: 'password',
+ database: 'postgres',
+});
+
+// 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.
+client.on('error', (err: unknown) => {
+ // eslint-disable-next-line no-console
+ console.error('pg client error', err);
+});
+
+client.connect((err: unknown) => {
+ if (err) {
+ // eslint-disable-next-line no-console
+ console.error('pg connect error', err);
+ }
+});
+
+const port = 3030;
+
+Deno.serve({ port, hostname: '0.0.0.0' }, async (req: Request) => {
+ const url = new URL(req.url);
+
+ // Runs two queries, the second NESTED inside the first's callback. pg
+ // 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 `denoPostgresIntegration`'s AsyncLocalStorage
+ // context strategy restored the parent across the async boundary.
+ if (url.pathname === '/test-pg') {
+ await new Promise<void>((resolve, reject) => {
+ client.query('SELECT 1 + 1 AS solution', (err: unknown) => {
+ if (err) return reject(err);
+ client.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/deno-pg/start-event-proxy.mjs

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

.github/workflows/build.yml

@@ -1045,9 +1045,7 @@ jobs:
  use-installer: true
  token: ${{ secrets.GITHUB_TOKEN }}
  - name: Set up Deno
- 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'
+ if: contains(matrix.test-application, 'deno') || matrix.test-application == 'hono-4'
  uses: denoland/setup-deno@v2.0.4
  with:
  deno-version: ${{ matrix.deno-version || 'v2.8.0' }}
@@ -1170,7 +1168,7 @@ jobs:
  with:
  node-version-file: 'dev-packages/e2e-tests/test-applications/${{ matrix.test-application }}/package.json'
  - name: Set up Deno
- if: matrix.test-application == 'deno' || matrix.test-application == 'deno-streamed'
+ if: contains(matrix.test-application, 'deno')
  uses: denoland/setup-deno@v2.0.4
  with:
  deno-version: ${{ matrix.deno-version || 'v2.8.0' }}

dev-packages/bun-integration-tests/package.json

@@ -16,7 +16,8 @@
  "@sentry/bun": "10.63.0",
  "@sentry/hono": "10.63.0",
  "hono": "^4.12.25",
- "mysql": "^2.18.1"
+ "mysql": "^2.18.1",
+ "pg": "8.16.0"
  },
  "devDependencies": {
  "@sentry-internal/test-utils": "10.63.0",

dev-packages/bun-integration-tests/suites/orchestrion-postgres/build.ts

@@ -0,0 +1,43 @@
+// Builds the smoke scenario with the orchestrion `bun build` plugin and writes
+// the bundle to a temp dir, printing the output path for test.ts to execute.
+//
+// A successful build proves `bun build` runs with the plugin; running the
+// bundle (see test.ts) then proves the bundled `pg` is actually instrumented.
+
+// @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 { tmpdir } from 'os';
+import { join } from 'path';
+
+void (async () => {
+ const outdir = join(tmpdir(), `sentry-bun-orchestrion-pg-${process.pid}-${Date.now()}`);
+ const result = await Bun.build({
+ entrypoints: [join(__dirname, 'scenario.ts')],
+ target: 'bun',
+ outdir,
+ // Deliberately mark `pg` external. An externalized dependency is resolved
+ // from `node_modules` at runtime and never passes through the transform's
+ // `onLoad`, so its channel injection would be silently skipped. The plugin
+ // must strip instrumented packages back out of `external` so they get
+ // bundled (and thus transformed).
+ external: ['pg'],
+ plugins: [sentryBunPlugin()],
+ });
+
+ if (!result.success) {
+ // eslint-disable-next-line no-console
+ console.error('BUILD_FAILED', result.logs);
+ process.exit(1);
+ }
+
+ const output = result.outputs[0];
+ if (!output) {
+ // eslint-disable-next-line no-console
+ console.error('BUILD_FAILED no outputs');
+ process.exit(1);
+ }
+
+ // eslint-disable-next-line no-console
+ console.log(`BUILD_OK outfile=${output.path}`);
+})();

dev-packages/bun-integration-tests/suites/orchestrion-postgres/scenario.ts

@@ -0,0 +1,61 @@
+// Bundled entry for the `bun build` smoke test.
+//
+// Once `Bun.build` (with the orchestrion plugin) has transformed `pg`,
+// calling `client.query()` publishes to the `orchestrion:pg:query` tracing
+// channel.
+//
+// `start` fires synchronously on the call, so no live database is needed.
+//
+// We subscribe, run a query, and report which channel events fired
+// (plus the detection marker the plugin's banner sets at boot).
+
+import { tracingChannel } from 'node:diagnostics_channel';
+
+// @ts-ignore -- only the runtime value is needed; pg's types are irrelevant
+import pg from 'pg';
+
+interface QueryContext {
+ arguments?: unknown[];
+}
+interface Client {
+ query(sql: string, cb: () => void): void;
+}
+interface PgModule {
+ Client: new (opts: { host: string; user: string; database: string }) => Client;
+}
+
+const events: string[] = [];
+let statement = '';
+
+tracingChannel('orchestrion:pg:query').subscribe({
+ start(message: unknown) {
+ events.push('start');
+ const first = (message as QueryContext).arguments?.[0];
+ statement = typeof first === 'string' ? first : '';
+ },
+ end() {
+ events.push('end');
+ },
+ asyncStart() {},
+ asyncEnd() {
+ events.push('asyncEnd');
+ },
+ error() {},
+});
+
+const client = new (pg as PgModule).Client({ host: '127.0.0.1', user: 'root', database: 'mydb' });
+try {
+ client.query('SELECT 1 AS solution', () => {});
+} catch {
+ // No live server
+ // `start` has already published synchronously by this point.
+}
+
+const marker = (globalThis as { __SENTRY_ORCHESTRION__?: { runtime?: boolean; bundler?: boolean } })
+ .__SENTRY_ORCHESTRION__;
+
+setTimeout(() => {
+ // eslint-disable-next-line no-console
+ console.log(`SCENARIO events=${events.join(',')} statement=${statement} marker=${JSON.stringify(marker ?? null)}`);
+ process.exit(0);
+}, 200);

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

@@ -0,0 +1,65 @@
+import { spawnSync } from 'child_process';
+import { rmSync } from 'fs';
+import { dirname, join } from 'path';
+import { describe, expect, it } from 'vitest';
+
+const dir = __dirname;
+
+// Cap each `bun` subprocess. The test runs two of them sequentially, so its
+// own timeout must exceed `2 * SUBPROCESS_TIMEOUT_MS` otherwise the suite's
+// default `testTimeout` (20s) fails the test before these caps do,
+// for example on a slow CI runner where the build+run can take >20s.
+const SUBPROCESS_TIMEOUT_MS = 60_000;
+
+function runBun(args: string[]): { stdout: string; stderr: string; status: number | null } {
+ const res = spawnSync('bun', args, { cwd: dir, encoding: 'utf8', timeout: SUBPROCESS_TIMEOUT_MS });
+ return { stdout: res.stdout ?? '', stderr: res.stderr ?? '', status: res.status };
+}
+
+// Bun orchestrion instrumentation is BUILD-ONLY (`@sentry/bun/plugin` is a
+// `Bun.build` plugin; there is no `bun run` preload).
+//
+// A `bun run` runtime plugin cannot instrument CommonJS dependencies like
+// `pg`: any module returned by a runtime `onLoad` plugin in Bun loses its
+// CommonJS named exports
+//
+// When https://github.com/oven-sh/bun/pull/31770 lands, we can revisit an
+// auto-load plugin for `bun run`.
+describe('orchestrion pg instrumentation (Bun)', () => {
+ it(
+ 'bundles `pg` with the plugin, and the built output fires the pg channel when run',
+ () => {
+ // Build the scenario with the orchestrion `bun build` plugin.
+ const build = runBun(['run', join(dir, 'build.ts')]);
+ expect(build.status, `build failed:\nstderr:\n${build.stderr}\nstdout:\n${build.stdout}`).toBe(0);
+
+ const outfile = build.stdout.match(/BUILD_OK outfile=(.+)/)?.[1]?.trim();
+ expect(outfile, `no outfile in build output:\n${build.stdout}`).toBeTruthy();
+
+ try {
+ // Run the built bundle. The bundled (transformed) `pg` should publish
+ // to the `orchestrion:pg:query` channel when `client.query()` is
+ // called, and the plugin's banner should set the `bundler` marker at
+ // boot.
+ const run = runBun(['run', outfile as string]);
+ expect(run.status, `run failed:\nstderr:\n${run.stderr}\nstdout:\n${run.stdout}`).toBe(0);
+
+ const line = run.stdout.split('\n').find(l => l.startsWith('SCENARIO')) ?? '';
+ // channel `start` fired on `client.query()`
+ expect(line).toContain('events=start');
+ // with the expected SQL
+ expect(line).toContain('statement=SELECT 1 AS solution');
+ // injected banner ran at bundle boot
+ expect(line).toContain('"bundler":true');
+ } finally {
+ if (outfile) {
+ rmSync(dirname(outfile), { recursive: true, force: true });
+ }
+ }
+ // Allow for both sequential `runBun` calls hitting their subprocess
+ // cap, so the `spawnSync` timeouts (not the vitest 20s def) are the
+ // binding limit.
+ },
+ 2 * SUBPROCESS_TIMEOUT_MS,
+ );
+});

dev-packages/e2e-tests/test-applications/deno-pg/deno.json

@@ -0,0 +1,7 @@
+{
+ "imports": {
+ "@sentry/deno": "npm:@sentry/deno",
+ "pg": "npm:pg@8.16.0"
+ },
+ "nodeModulesDir": "manual"
+}

dev-packages/e2e-tests/test-applications/deno-pg/docker-compose.yml

@@ -0,0 +1,17 @@
+services:
+ db:
+ image: postgres:13
+ restart: always
+ container_name: e2e-tests-deno-pg
+ ports:
+ - '5432:5432'
+ environment:
+ POSTGRES_USER: postgres
+ POSTGRES_PASSWORD: password
+ POSTGRES_DB: postgres
+ healthcheck:
+ test: ['CMD-SHELL', 'pg_isready -U postgres -d postgres']
+ interval: 2s
+ timeout: 3s
+ retries: 30
+ start_period: 5s

dev-packages/e2e-tests/test-applications/deno-pg/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 PostgreSQL via Docker Compose. `--wait` blocks until the healthcheck
+ // in docker-compose.yml passes, so the Deno app can connect immediately.
+ execSync('docker compose up -d --wait', {
+ cwd: __dirname,
+ stdio: 'inherit',
+ });
+}

dev-packages/e2e-tests/test-applications/deno-pg/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/deno-pg/package.json

@@ -0,0 +1,23 @@
+{
+ "name": "deno-pg",
+ "version": "1.0.0",
+ "private": true,
+ "scripts": {
+ "start": "docker compose up -d --wait && deno run --allow-net --allow-env --allow-read --allow-sys --allow-write src/app.ts",
+ "test": "playwright test",
+ "clean": "npx rimraf node_modules pnpm-lock.yaml",
+ "test:build": "pnpm install",
+ "test:assert": "pnpm test"
+ },
+ "dependencies": {
+ "@sentry/deno": "file:../../packed/sentry-deno-packed.tgz",
+ "pg": "8.16.0"
+ },
+ "devDependencies": {
+ "@playwright/test": "~1.56.0",
+ "@sentry-internal/test-utils": "link:../../../test-utils"
+ },
+ "volta": {
+ "extends": "../../package.json"
+ }
+}

dev-packages/e2e-tests/test-applications/deno-pg/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/deno-pg/src/app.ts

@@ -0,0 +1,69 @@
+// `@sentry/deno/import` MUST be the very first import: it registers the
+// orchestrion runtime hook, which transforms `pg` (imported dynamically below)
+// to publish the `orchestrion:pg:query` diagnostics channel.
+// In Deno 2.8.0–2.8.2 the hook only works as the first import in the entry
+// graph.
+import '@sentry/deno/import';
+import * as Sentry from '@sentry/deno';
+
+Sentry.init({
+ environment: 'qa',
+ dsn: Deno.env.get('E2E_TEST_DSN'),
+ debug: !!Deno.env.get('DEBUG'),
+ tunnel: 'http://localhost:3031/', // proxy server
+ tracesSampleRate: 1,
+});
+
+// Dynamic import AFTER init so the orchestrion hook (registered above) is in
+// place to transform `pg/lib/client.js`'s `query`, and so
+// `denoPostgresIntegration` (wired by `init()`) is already subscribed.
+const { default: pg } = await import('pg');
+
+const client = new pg.Client({
+ host: Deno.env.get('PGHOST') ?? '127.0.0.1',
+ port: Number(Deno.env.get('PGPORT') ?? 5432),
+ user: 'postgres',
+ password: 'password',
+ database: 'postgres',
+});
+
+// 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.
+client.on('error', (err: unknown) => {
+ // eslint-disable-next-line no-console
+ console.error('pg client error', err);
+});
+
+client.connect((err: unknown) => {
+ if (err) {
+ // eslint-disable-next-line no-console
+ console.error('pg connect error', err);
+ }
+});
+
+const port = 3030;
+
+Deno.serve({ port, hostname: '0.0.0.0' }, async (req: Request) => {
+ const url = new URL(req.url);
+
+ // Runs two queries, the second NESTED inside the first's callback. pg
+ // 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 `denoPostgresIntegration`'s AsyncLocalStorage
+ // context strategy restored the parent across the async boundary.
+ if (url.pathname === '/test-pg') {
+ await new Promise<void>((resolve, reject) => {
+ client.query('SELECT 1 + 1 AS solution', (err: unknown) => {
+ if (err) return reject(err);
+ client.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/deno-pg/start-event-proxy.mjs

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

.github/workflows/build.yml

@@ -1045,9 +1045,7 @@ jobs:
  use-installer: true
  token: ${{ secrets.GITHUB_TOKEN }}
  - name: Set up Deno
- 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'
+ if: contains(matrix.test-application, 'deno') || matrix.test-application == 'hono-4'
  uses: denoland/setup-deno@v2.0.4
  with:
  deno-version: ${{ matrix.deno-version || 'v2.8.0' }}
@@ -1170,7 +1168,7 @@ jobs:
  with:
  node-version-file: 'dev-packages/e2e-tests/test-applications/${{ matrix.test-application }}/package.json'
  - name: Set up Deno
- if: matrix.test-application == 'deno' || matrix.test-application == 'deno-streamed'
+ if: contains(matrix.test-application, 'deno')
  uses: denoland/setup-deno@v2.0.4
  with:
  deno-version: ${{ matrix.deno-version || 'v2.8.0' }}

dev-packages/bun-integration-tests/package.json

@@ -16,7 +16,8 @@
  "@sentry/bun": "10.63.0",
  "@sentry/hono": "10.63.0",
  "hono": "^4.12.25",
- "mysql": "^2.18.1"
+ "mysql": "^2.18.1",
+ "pg": "8.16.0"
  },
  "devDependencies": {
  "@sentry-internal/test-utils": "10.63.0",

dev-packages/bun-integration-tests/suites/orchestrion-postgres/build.ts

@@ -0,0 +1,43 @@
+// Builds the smoke scenario with the orchestrion `bun build` plugin and writes
+// the bundle to a temp dir, printing the output path for test.ts to execute.
+//
+// A successful build proves `bun build` runs with the plugin; running the
+// bundle (see test.ts) then proves the bundled `pg` is actually instrumented.
+
+// @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 { tmpdir } from 'os';
+import { join } from 'path';
+
+void (async () => {
+ const outdir = join(tmpdir(), `sentry-bun-orchestrion-pg-${process.pid}-${Date.now()}`);
+ const result = await Bun.build({
+ entrypoints: [join(__dirname, 'scenario.ts')],
+ target: 'bun',
+ outdir,
+ // Deliberately mark `pg` external. An externalized dependency is resolved
+ // from `node_modules` at runtime and never passes through the transform's
+ // `onLoad`, so its channel injection would be silently skipped. The plugin
+ // must strip instrumented packages back out of `external` so they get
+ // bundled (and thus transformed).
+ external: ['pg'],
+ plugins: [sentryBunPlugin()],
+ });
+
+ if (!result.success) {
+ // eslint-disable-next-line no-console
+ console.error('BUILD_FAILED', result.logs);
+ process.exit(1);
+ }
+
+ const output = result.outputs[0];
+ if (!output) {
+ // eslint-disable-next-line no-console
+ console.error('BUILD_FAILED no outputs');
+ process.exit(1);
+ }
+
+ // eslint-disable-next-line no-console
+ console.log(`BUILD_OK outfile=${output.path}`);
+})();

dev-packages/bun-integration-tests/suites/orchestrion-postgres/scenario.ts

@@ -0,0 +1,61 @@
+// Bundled entry for the `bun build` smoke test.
+//
+// Once `Bun.build` (with the orchestrion plugin) has transformed `pg`,
+// calling `client.query()` publishes to the `orchestrion:pg:query` tracing
+// channel.
+//
+// `start` fires synchronously on the call, so no live database is needed.
+//
+// We subscribe, run a query, and report which channel events fired
+// (plus the detection marker the plugin's banner sets at boot).
+
+import { tracingChannel } from 'node:diagnostics_channel';
+
+// @ts-ignore -- only the runtime value is needed; pg's types are irrelevant
+import pg from 'pg';
+
+interface QueryContext {
+ arguments?: unknown[];
+}
+interface Client {
+ query(sql: string, cb: () => void): void;
+}
+interface PgModule {
+ Client: new (opts: { host: string; user: string; database: string }) => Client;
+}
+
+const events: string[] = [];
+let statement = '';
+
+tracingChannel('orchestrion:pg:query').subscribe({
+ start(message: unknown) {
+ events.push('start');
+ const first = (message as QueryContext).arguments?.[0];
+ statement = typeof first === 'string' ? first : '';
+ },
+ end() {
+ events.push('end');
+ },
+ asyncStart() {},
+ asyncEnd() {
+ events.push('asyncEnd');
+ },
+ error() {},
+});
+
+const client = new (pg as PgModule).Client({ host: '127.0.0.1', user: 'root', database: 'mydb' });
+try {
+ client.query('SELECT 1 AS solution', () => {});
+} catch {
+ // No live server
+ // `start` has already published synchronously by this point.
+}
+
+const marker = (globalThis as { __SENTRY_ORCHESTRION__?: { runtime?: boolean; bundler?: boolean } })
+ .__SENTRY_ORCHESTRION__;
+
+setTimeout(() => {
+ // eslint-disable-next-line no-console
+ console.log(`SCENARIO events=${events.join(',')} statement=${statement} marker=${JSON.stringify(marker ?? null)}`);
+ process.exit(0);
+}, 200);

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

@@ -0,0 +1,65 @@
+import { spawnSync } from 'child_process';
+import { rmSync } from 'fs';
+import { dirname, join } from 'path';
+import { describe, expect, it } from 'vitest';
+
+const dir = __dirname;
+
+// Cap each `bun` subprocess. The test runs two of them sequentially, so its
+// own timeout must exceed `2 * SUBPROCESS_TIMEOUT_MS` otherwise the suite's
+// default `testTimeout` (20s) fails the test before these caps do,
+// for example on a slow CI runner where the build+run can take >20s.
+const SUBPROCESS_TIMEOUT_MS = 60_000;
+
+function runBun(args: string[]): { stdout: string; stderr: string; status: number | null } {
+ const res = spawnSync('bun', args, { cwd: dir, encoding: 'utf8', timeout: SUBPROCESS_TIMEOUT_MS });
+ return { stdout: res.stdout ?? '', stderr: res.stderr ?? '', status: res.status };
+}
+
+// Bun orchestrion instrumentation is BUILD-ONLY (`@sentry/bun/plugin` is a
+// `Bun.build` plugin; there is no `bun run` preload).
+//
+// A `bun run` runtime plugin cannot instrument CommonJS dependencies like
+// `pg`: any module returned by a runtime `onLoad` plugin in Bun loses its
+// CommonJS named exports
+//
+// When https://github.com/oven-sh/bun/pull/31770 lands, we can revisit an
+// auto-load plugin for `bun run`.
+describe('orchestrion pg instrumentation (Bun)', () => {
+ it(
+ 'bundles `pg` with the plugin, and the built output fires the pg channel when run',
+ () => {
+ // Build the scenario with the orchestrion `bun build` plugin.
+ const build = runBun(['run', join(dir, 'build.ts')]);
+ expect(build.status, `build failed:\nstderr:\n${build.stderr}\nstdout:\n${build.stdout}`).toBe(0);
+
+ const outfile = build.stdout.match(/BUILD_OK outfile=(.+)/)?.[1]?.trim();
+ expect(outfile, `no outfile in build output:\n${build.stdout}`).toBeTruthy();
+
+ try {
+ // Run the built bundle. The bundled (transformed) `pg` should publish
+ // to the `orchestrion:pg:query` channel when `client.query()` is
+ // called, and the plugin's banner should set the `bundler` marker at
+ // boot.
+ const run = runBun(['run', outfile as string]);
+ expect(run.status, `run failed:\nstderr:\n${run.stderr}\nstdout:\n${run.stdout}`).toBe(0);
+
+ const line = run.stdout.split('\n').find(l => l.startsWith('SCENARIO')) ?? '';
+ // channel `start` fired on `client.query()`
+ expect(line).toContain('events=start');
+ // with the expected SQL
+ expect(line).toContain('statement=SELECT 1 AS solution');
+ // injected banner ran at bundle boot
+ expect(line).toContain('"bundler":true');
+ } finally {
+ if (outfile) {
+ rmSync(dirname(outfile), { recursive: true, force: true });
+ }
+ }
+ // Allow for both sequential `runBun` calls hitting their subprocess
+ // cap, so the `spawnSync` timeouts (not the vitest 20s def) are the
+ // binding limit.
+ },
+ 2 * SUBPROCESS_TIMEOUT_MS,
+ );
+});

dev-packages/e2e-tests/test-applications/deno-pg/deno.json

@@ -0,0 +1,7 @@
+{
+ "imports": {
+ "@sentry/deno": "npm:@sentry/deno",
+ "pg": "npm:pg@8.16.0"
+ },
+ "nodeModulesDir": "manual"
+}

dev-packages/e2e-tests/test-applications/deno-pg/docker-compose.yml

@@ -0,0 +1,17 @@
+services:
+ db:
+ image: postgres:13
+ restart: always
+ container_name: e2e-tests-deno-pg
+ ports:
+ - '5432:5432'
+ environment:
+ POSTGRES_USER: postgres
+ POSTGRES_PASSWORD: password
+ POSTGRES_DB: postgres
+ healthcheck:
+ test: ['CMD-SHELL', 'pg_isready -U postgres -d postgres']
+ interval: 2s
+ timeout: 3s
+ retries: 30
+ start_period: 5s

dev-packages/e2e-tests/test-applications/deno-pg/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 PostgreSQL via Docker Compose. `--wait` blocks until the healthcheck
+ // in docker-compose.yml passes, so the Deno app can connect immediately.
+ execSync('docker compose up -d --wait', {
+ cwd: __dirname,
+ stdio: 'inherit',
+ });
+}

dev-packages/e2e-tests/test-applications/deno-pg/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/deno-pg/package.json

@@ -0,0 +1,23 @@
+{
+ "name": "deno-pg",
+ "version": "1.0.0",
+ "private": true,
+ "scripts": {
+ "start": "docker compose up -d --wait && deno run --allow-net --allow-env --allow-read --allow-sys --allow-write src/app.ts",
+ "test": "playwright test",
+ "clean": "npx rimraf node_modules pnpm-lock.yaml",
+ "test:build": "pnpm install",
+ "test:assert": "pnpm test"
+ },
+ "dependencies": {
+ "@sentry/deno": "file:../../packed/sentry-deno-packed.tgz",
+ "pg": "8.16.0"
+ },
+ "devDependencies": {
+ "@playwright/test": "~1.56.0",
+ "@sentry-internal/test-utils": "link:../../../test-utils"
+ },
+ "volta": {
+ "extends": "../../package.json"
+ }
+}

dev-packages/e2e-tests/test-applications/deno-pg/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/deno-pg/src/app.ts

@@ -0,0 +1,69 @@
+// `@sentry/deno/import` MUST be the very first import: it registers the
+// orchestrion runtime hook, which transforms `pg` (imported dynamically below)
+// to publish the `orchestrion:pg:query` diagnostics channel.
+// In Deno 2.8.0–2.8.2 the hook only works as the first import in the entry
+// graph.
+import '@sentry/deno/import';
+import * as Sentry from '@sentry/deno';
+
+Sentry.init({
+ environment: 'qa',
+ dsn: Deno.env.get('E2E_TEST_DSN'),
+ debug: !!Deno.env.get('DEBUG'),
+ tunnel: 'http://localhost:3031/', // proxy server
+ tracesSampleRate: 1,
+});
+
+// Dynamic import AFTER init so the orchestrion hook (registered above) is in
+// place to transform `pg/lib/client.js`'s `query`, and so
+// `denoPostgresIntegration` (wired by `init()`) is already subscribed.
+const { default: pg } = await import('pg');
+
+const client = new pg.Client({
+ host: Deno.env.get('PGHOST') ?? '127.0.0.1',
+ port: Number(Deno.env.get('PGPORT') ?? 5432),
+ user: 'postgres',
+ password: 'password',
+ database: 'postgres',
+});
+
+// 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.
+client.on('error', (err: unknown) => {
+ // eslint-disable-next-line no-console
+ console.error('pg client error', err);
+});
+
+client.connect((err: unknown) => {
+ if (err) {
+ // eslint-disable-next-line no-console
+ console.error('pg connect error', err);
+ }
+});
+
+const port = 3030;
+
+Deno.serve({ port, hostname: '0.0.0.0' }, async (req: Request) => {
+ const url = new URL(req.url);
+
+ // Runs two queries, the second NESTED inside the first's callback. pg
+ // 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 `denoPostgresIntegration`'s AsyncLocalStorage
+ // context strategy restored the parent across the async boundary.
+ if (url.pathname === '/test-pg') {
+ await new Promise<void>((resolve, reject) => {
+ client.query('SELECT 1 + 1 AS solution', (err: unknown) => {
+ if (err) return reject(err);
+ client.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/deno-pg/start-event-proxy.mjs

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