ref(node): Streamline pg instrumentation

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-connect-error.mjs

@@ -0,0 +1,22 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+// Nothing is listening on this port, so `connect()` fails and the connect span
+// must be recorded with an errored status.
+const client = new Client({ port: 5499, user: 'test', password: 'test', database: 'tests' });
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ await client.connect().catch(() => {
+ // expected: connection refused
+ });
+ },
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-connect-then.mjs

@@ -0,0 +1,25 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ () =>
+ // Chain off `connect()` with `.then()` instead of awaiting it: the query
+ // issued from the continuation must still be parented to the active
+ // transaction, proving the trace context survives the connect promise.
+ new Promise((resolve, reject) => {
+ const client = new Client({ port: 5494, user: 'test', password: 'test', database: 'tests' });
+ client
+ .connect()
+ .then(() => client.query('SELECT 1 AS connect_then'))
+ .then(() => client.end())
+ .then(resolve, reject);
+ }),
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-no-parent.mjs

@@ -0,0 +1,26 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+const client = new Client({ port: 5494, user: 'test', password: 'test', database: 'tests' });
+
+async function run() {
+ // No active span here: `requireParentSpan` means the connect and this query
+ // must NOT produce spans.
+ await client.connect();
+ await client.query('SELECT 1 AS unparented');
+
+ // With an active span, the query is instrumented as a child span.
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ await client.query('SELECT 2 AS parented');
+ },
+ );
+
+ await client.end();
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-pool.mjs

@@ -0,0 +1,30 @@
+import * as Sentry from '@sentry/node';
+import pg from 'pg';
+
+const { Pool } = pg;
+
+// The connection string carries credentials so we can assert they are masked
+// out of the `db.connection_string` span attribute.
+const pool = new Pool({ connectionString: 'postgresql://test:test@localhost:5494/tests' });
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ try {
+ // Callback-style query exercises the callback-patching path (the
+ // promise-based scenarios never hit it).
+ await new Promise((resolve, reject) => {
+ pool.query('SELECT 1 AS foo', (err, res) => (err ? reject(err) : resolve(res)));
+ });
+ } finally {
+ await pool.end();
+ }
+ },
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario.mjs

@@ -23,6 +23,18 @@ async function run() {
 
  await client.query('INSERT INTO "User" ("email", "name") VALUES ($1, $2)', ['tim', 'tim@domain.com']);
  await client.query('SELECT * FROM "User"');
+
+ // A named (prepared) query records its name as the `db.postgresql.plan` attribute
+ await client.query({
+ name: 'select-user-by-email',
+ text: 'SELECT * FROM "User" WHERE "email" = $1',
+ values: ['tim'],
+ });
+
+ // A failing query should still produce an errored span
+ await client.query('SELECT * FROM "does_not_exist_table"').catch(() => {
+ // swallow: we only care about the span it produces
+ });
  } finally {
  await client.end();
  }

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

@@ -48,6 +48,33 @@ describe('postgres auto instrumentation', () => {
  status: 'ok',
  origin: 'auto.db.otel.postgres',
  }),
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT * FROM "User" WHERE "email" = $1',
+ 'db.postgresql.plan': 'select-user-by-email',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT * FROM "User" WHERE "email" = $1',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT * FROM "does_not_exist_table"',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT * FROM "does_not_exist_table"',
+ op: 'db',
+ status: 'internal_error',
+ origin: 'auto.db.otel.postgres',
+ }),
  ]),
  };
 
@@ -114,6 +141,161 @@ describe('postgres auto instrumentation', () => {
  });
  });
 
+ describe('pool', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ // Pool connect span: no origin is set on connect spans, so it defaults
+ // to 'manual', and the connection-string credentials are masked out.
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.connection_string': 'postgresql://localhost:5494/tests',
+ 'sentry.op': 'db',
+ }),
+ description: 'pg-pool.connect',
+ op: 'db',
+ status: 'ok',
+ origin: 'manual',
+ }),
+ // Callback-style query (no awaited promise returned to the caller).
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 1 AS foo',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 1 AS foo',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ };
+
+ createEsmAndCjsTests(__dirname, 'scenario-pool.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test(
+ 'auto-instruments `pg.Pool`, masks connection-string credentials, and handles callback-style queries',
+ { timeout: 90_000 },
+ async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({ transaction: EXPECTED_TRANSACTION })
+ .start()
+ .completed();
+ },
+ );
+ });
+ });
+
+ describe('connect error', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'sentry.op': 'db',
+ }),
+ description: 'pg.connect',
+ op: 'db',
+ status: 'internal_error',
+ origin: 'manual',
+ }),
+ ]),
+ };
+
+ // No DB needed: the scenario connects to a port where nothing is listening.
+ createEsmAndCjsTests(__dirname, 'scenario-connect-error.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('records an errored connect span when the connection fails', { timeout: 90_000 }, async () => {
+ await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+ });
+ });
+ });
+
+ // A query chained off `connect()` with `.then()` (rather than awaited) must still
+ // be parented to the active transaction. Since the instrumentation requires a
+ // parent span, the query only produces a span if the trace context survives the
+ // connect promise's continuation.
+ describe('connect promise continuation', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 1 AS connect_then',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 1 AS connect_then',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ };
+
+ createEsmAndCjsTests(__dirname, 'scenario-connect-then.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('parents a query chained off connect() to the active transaction', { timeout: 90_000 }, async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({ transaction: EXPECTED_TRANSACTION })
+ .start()
+ .completed();
+ });
+ });
+ });
+
+ describe('requireParentSpan', () => {
+ createEsmAndCjsTests(__dirname, 'scenario-no-parent.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('does not instrument queries or connects without an active parent span', { timeout: 90_000 }, async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({
+ transaction: txn => {
+ const descriptions = txn.spans?.map(span => span.description) ?? [];
+ // The unparented connect + query must not have produced spans
+ expect(descriptions).not.toContain('SELECT 1 AS unparented');
+ expect(descriptions.find(name => name?.includes('connect'))).toBeUndefined();
+ // Only the parented query is instrumented
+ expect(txn).toMatchObject({
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 2 AS parented',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 2 AS parented',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ });
+ },
+ })
+ .start()
+ .completed();
+ });
+ });
+ });
+
  conditionalTest({ max: 25 })('pg-native', () => {
  const EXPECTED_TRANSACTION = {
  transaction: 'Test Transaction',

packages/node/src/integrations/tracing/postgres/index.ts

@@ -1,7 +1,7 @@
 import { PgInstrumentation } from './vendored/instrumentation';
 import type { IntegrationFn } from '@sentry/core';
 import { defineIntegration } from '@sentry/core';
-import { addOriginToSpan, generateInstrumentOnce } from '@sentry/node-core';
+import { generateInstrumentOnce } from '@sentry/node-core';
 
 interface PostgresIntegrationOptions {
  ignoreConnectSpans?: boolean;
@@ -13,10 +13,6 @@ export const instrumentPostgres = generateInstrumentOnce(
  INTEGRATION_NAME,
  PgInstrumentation,
  (options?: PostgresIntegrationOptions) => ({
- requireParentSpan: true,
- requestHook(span) {
- addOriginToSpan(span, 'auto.db.otel.postgres');
- },
  ignoreConnectSpans: options?.ignoreConnectSpans ?? false,
  }),
 );

packages/node/src/integrations/tracing/postgres/vendored/enums/AttributeNames.ts

@@ -6,11 +6,9 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-pg
  * - Upstream version: @opentelemetry/instrumentation-pg@0.70.0
  */
-/* eslint-disable */
 
 // Postgresql specific attributes not covered by semantic conventions
 export enum AttributeNames {
- PG_VALUES = 'db.postgresql.values',
  PG_PLAN = 'db.postgresql.plan',
  IDLE_TIMEOUT_MILLIS = 'db.postgresql.idle.timeout.millis',
  MAX_CLIENT = 'db.postgresql.max.client',

packages/node/src/integrations/tracing/postgres/vendored/enums/SpanNames.ts

@@ -6,7 +6,6 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-pg
  * - Upstream version: @opentelemetry/instrumentation-pg@0.70.0
  */
-/* eslint-disable */
 
 // Contains span names produced by instrumentation
 export enum SpanNames {

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-connect-error.mjs

@@ -0,0 +1,22 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+// Nothing is listening on this port, so `connect()` fails and the connect span
+// must be recorded with an errored status.
+const client = new Client({ port: 5499, user: 'test', password: 'test', database: 'tests' });
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ await client.connect().catch(() => {
+ // expected: connection refused
+ });
+ },
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-connect-then.mjs

@@ -0,0 +1,25 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ () =>
+ // Chain off `connect()` with `.then()` instead of awaiting it: the query
+ // issued from the continuation must still be parented to the active
+ // transaction, proving the trace context survives the connect promise.
+ new Promise((resolve, reject) => {
+ const client = new Client({ port: 5494, user: 'test', password: 'test', database: 'tests' });
+ client
+ .connect()
+ .then(() => client.query('SELECT 1 AS connect_then'))
+ .then(() => client.end())
+ .then(resolve, reject);
+ }),
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-no-parent.mjs

@@ -0,0 +1,26 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+const client = new Client({ port: 5494, user: 'test', password: 'test', database: 'tests' });
+
+async function run() {
+ // No active span here: `requireParentSpan` means the connect and this query
+ // must NOT produce spans.
+ await client.connect();
+ await client.query('SELECT 1 AS unparented');
+
+ // With an active span, the query is instrumented as a child span.
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ await client.query('SELECT 2 AS parented');
+ },
+ );
+
+ await client.end();
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-pool.mjs

@@ -0,0 +1,30 @@
+import * as Sentry from '@sentry/node';
+import pg from 'pg';
+
+const { Pool } = pg;
+
+// The connection string carries credentials so we can assert they are masked
+// out of the `db.connection_string` span attribute.
+const pool = new Pool({ connectionString: 'postgresql://test:test@localhost:5494/tests' });
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ try {
+ // Callback-style query exercises the callback-patching path (the
+ // promise-based scenarios never hit it).
+ await new Promise((resolve, reject) => {
+ pool.query('SELECT 1 AS foo', (err, res) => (err ? reject(err) : resolve(res)));
+ });
+ } finally {
+ await pool.end();
+ }
+ },
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario.mjs

@@ -23,6 +23,18 @@ async function run() {
 
  await client.query('INSERT INTO "User" ("email", "name") VALUES ($1, $2)', ['tim', 'tim@domain.com']);
  await client.query('SELECT * FROM "User"');
+
+ // A named (prepared) query records its name as the `db.postgresql.plan` attribute
+ await client.query({
+ name: 'select-user-by-email',
+ text: 'SELECT * FROM "User" WHERE "email" = $1',
+ values: ['tim'],
+ });
+
+ // A failing query should still produce an errored span
+ await client.query('SELECT * FROM "does_not_exist_table"').catch(() => {
+ // swallow: we only care about the span it produces
+ });
  } finally {
  await client.end();
  }

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

@@ -48,6 +48,33 @@ describe('postgres auto instrumentation', () => {
  status: 'ok',
  origin: 'auto.db.otel.postgres',
  }),
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT * FROM "User" WHERE "email" = $1',
+ 'db.postgresql.plan': 'select-user-by-email',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT * FROM "User" WHERE "email" = $1',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT * FROM "does_not_exist_table"',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT * FROM "does_not_exist_table"',
+ op: 'db',
+ status: 'internal_error',
+ origin: 'auto.db.otel.postgres',
+ }),
  ]),
  };
 
@@ -114,6 +141,161 @@ describe('postgres auto instrumentation', () => {
  });
  });
 
+ describe('pool', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ // Pool connect span: no origin is set on connect spans, so it defaults
+ // to 'manual', and the connection-string credentials are masked out.
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.connection_string': 'postgresql://localhost:5494/tests',
+ 'sentry.op': 'db',
+ }),
+ description: 'pg-pool.connect',
+ op: 'db',
+ status: 'ok',
+ origin: 'manual',
+ }),
+ // Callback-style query (no awaited promise returned to the caller).
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 1 AS foo',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 1 AS foo',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ };
+
+ createEsmAndCjsTests(__dirname, 'scenario-pool.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test(
+ 'auto-instruments `pg.Pool`, masks connection-string credentials, and handles callback-style queries',
+ { timeout: 90_000 },
+ async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({ transaction: EXPECTED_TRANSACTION })
+ .start()
+ .completed();
+ },
+ );
+ });
+ });
+
+ describe('connect error', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'sentry.op': 'db',
+ }),
+ description: 'pg.connect',
+ op: 'db',
+ status: 'internal_error',
+ origin: 'manual',
+ }),
+ ]),
+ };
+
+ // No DB needed: the scenario connects to a port where nothing is listening.
+ createEsmAndCjsTests(__dirname, 'scenario-connect-error.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('records an errored connect span when the connection fails', { timeout: 90_000 }, async () => {
+ await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+ });
+ });
+ });
+
+ // A query chained off `connect()` with `.then()` (rather than awaited) must still
+ // be parented to the active transaction. Since the instrumentation requires a
+ // parent span, the query only produces a span if the trace context survives the
+ // connect promise's continuation.
+ describe('connect promise continuation', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 1 AS connect_then',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 1 AS connect_then',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ };
+
+ createEsmAndCjsTests(__dirname, 'scenario-connect-then.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('parents a query chained off connect() to the active transaction', { timeout: 90_000 }, async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({ transaction: EXPECTED_TRANSACTION })
+ .start()
+ .completed();
+ });
+ });
+ });
+
+ describe('requireParentSpan', () => {
+ createEsmAndCjsTests(__dirname, 'scenario-no-parent.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('does not instrument queries or connects without an active parent span', { timeout: 90_000 }, async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({
+ transaction: txn => {
+ const descriptions = txn.spans?.map(span => span.description) ?? [];
+ // The unparented connect + query must not have produced spans
+ expect(descriptions).not.toContain('SELECT 1 AS unparented');
+ expect(descriptions.find(name => name?.includes('connect'))).toBeUndefined();
+ // Only the parented query is instrumented
+ expect(txn).toMatchObject({
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 2 AS parented',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 2 AS parented',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ });
+ },
+ })
+ .start()
+ .completed();
+ });
+ });
+ });
+
  conditionalTest({ max: 25 })('pg-native', () => {
  const EXPECTED_TRANSACTION = {
  transaction: 'Test Transaction',

packages/node/src/integrations/tracing/postgres/index.ts

@@ -1,7 +1,7 @@
 import { PgInstrumentation } from './vendored/instrumentation';
 import type { IntegrationFn } from '@sentry/core';
 import { defineIntegration } from '@sentry/core';
-import { addOriginToSpan, generateInstrumentOnce } from '@sentry/node-core';
+import { generateInstrumentOnce } from '@sentry/node-core';
 
 interface PostgresIntegrationOptions {
  ignoreConnectSpans?: boolean;
@@ -13,10 +13,6 @@ export const instrumentPostgres = generateInstrumentOnce(
  INTEGRATION_NAME,
  PgInstrumentation,
  (options?: PostgresIntegrationOptions) => ({
- requireParentSpan: true,
- requestHook(span) {
- addOriginToSpan(span, 'auto.db.otel.postgres');
- },
  ignoreConnectSpans: options?.ignoreConnectSpans ?? false,
  }),
 );

packages/node/src/integrations/tracing/postgres/vendored/enums/AttributeNames.ts

@@ -6,11 +6,9 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-pg
  * - Upstream version: @opentelemetry/instrumentation-pg@0.70.0
  */
-/* eslint-disable */
 
 // Postgresql specific attributes not covered by semantic conventions
 export enum AttributeNames {
- PG_VALUES = 'db.postgresql.values',
  PG_PLAN = 'db.postgresql.plan',
  IDLE_TIMEOUT_MILLIS = 'db.postgresql.idle.timeout.millis',
  MAX_CLIENT = 'db.postgresql.max.client',

packages/node/src/integrations/tracing/postgres/vendored/enums/SpanNames.ts

@@ -6,7 +6,6 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-pg
  * - Upstream version: @opentelemetry/instrumentation-pg@0.70.0
  */
-/* eslint-disable */
 
 // Contains span names produced by instrumentation
 export enum SpanNames {

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-connect-error.mjs

@@ -0,0 +1,22 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+// Nothing is listening on this port, so `connect()` fails and the connect span
+// must be recorded with an errored status.
+const client = new Client({ port: 5499, user: 'test', password: 'test', database: 'tests' });
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ await client.connect().catch(() => {
+ // expected: connection refused
+ });
+ },
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-connect-then.mjs

@@ -0,0 +1,25 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ () =>
+ // Chain off `connect()` with `.then()` instead of awaiting it: the query
+ // issued from the continuation must still be parented to the active
+ // transaction, proving the trace context survives the connect promise.
+ new Promise((resolve, reject) => {
+ const client = new Client({ port: 5494, user: 'test', password: 'test', database: 'tests' });
+ client
+ .connect()
+ .then(() => client.query('SELECT 1 AS connect_then'))
+ .then(() => client.end())
+ .then(resolve, reject);
+ }),
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-no-parent.mjs

@@ -0,0 +1,26 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+const client = new Client({ port: 5494, user: 'test', password: 'test', database: 'tests' });
+
+async function run() {
+ // No active span here: `requireParentSpan` means the connect and this query
+ // must NOT produce spans.
+ await client.connect();
+ await client.query('SELECT 1 AS unparented');
+
+ // With an active span, the query is instrumented as a child span.
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ await client.query('SELECT 2 AS parented');
+ },
+ );
+
+ await client.end();
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-pool.mjs

@@ -0,0 +1,30 @@
+import * as Sentry from '@sentry/node';
+import pg from 'pg';
+
+const { Pool } = pg;
+
+// The connection string carries credentials so we can assert they are masked
+// out of the `db.connection_string` span attribute.
+const pool = new Pool({ connectionString: 'postgresql://test:test@localhost:5494/tests' });
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ try {
+ // Callback-style query exercises the callback-patching path (the
+ // promise-based scenarios never hit it).
+ await new Promise((resolve, reject) => {
+ pool.query('SELECT 1 AS foo', (err, res) => (err ? reject(err) : resolve(res)));
+ });
+ } finally {
+ await pool.end();
+ }
+ },
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario.mjs

@@ -23,6 +23,18 @@ async function run() {
 
  await client.query('INSERT INTO "User" ("email", "name") VALUES ($1, $2)', ['tim', 'tim@domain.com']);
  await client.query('SELECT * FROM "User"');
+
+ // A named (prepared) query records its name as the `db.postgresql.plan` attribute
+ await client.query({
+ name: 'select-user-by-email',
+ text: 'SELECT * FROM "User" WHERE "email" = $1',
+ values: ['tim'],
+ });
+
+ // A failing query should still produce an errored span
+ await client.query('SELECT * FROM "does_not_exist_table"').catch(() => {
+ // swallow: we only care about the span it produces
+ });
  } finally {
  await client.end();
  }

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

@@ -48,6 +48,33 @@ describe('postgres auto instrumentation', () => {
  status: 'ok',
  origin: 'auto.db.otel.postgres',
  }),
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT * FROM "User" WHERE "email" = $1',
+ 'db.postgresql.plan': 'select-user-by-email',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT * FROM "User" WHERE "email" = $1',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT * FROM "does_not_exist_table"',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT * FROM "does_not_exist_table"',
+ op: 'db',
+ status: 'internal_error',
+ origin: 'auto.db.otel.postgres',
+ }),
  ]),
  };
 
@@ -114,6 +141,161 @@ describe('postgres auto instrumentation', () => {
  });
  });
 
+ describe('pool', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ // Pool connect span: no origin is set on connect spans, so it defaults
+ // to 'manual', and the connection-string credentials are masked out.
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.connection_string': 'postgresql://localhost:5494/tests',
+ 'sentry.op': 'db',
+ }),
+ description: 'pg-pool.connect',
+ op: 'db',
+ status: 'ok',
+ origin: 'manual',
+ }),
+ // Callback-style query (no awaited promise returned to the caller).
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 1 AS foo',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 1 AS foo',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ };
+
+ createEsmAndCjsTests(__dirname, 'scenario-pool.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test(
+ 'auto-instruments `pg.Pool`, masks connection-string credentials, and handles callback-style queries',
+ { timeout: 90_000 },
+ async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({ transaction: EXPECTED_TRANSACTION })
+ .start()
+ .completed();
+ },
+ );
+ });
+ });
+
+ describe('connect error', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'sentry.op': 'db',
+ }),
+ description: 'pg.connect',
+ op: 'db',
+ status: 'internal_error',
+ origin: 'manual',
+ }),
+ ]),
+ };
+
+ // No DB needed: the scenario connects to a port where nothing is listening.
+ createEsmAndCjsTests(__dirname, 'scenario-connect-error.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('records an errored connect span when the connection fails', { timeout: 90_000 }, async () => {
+ await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+ });
+ });
+ });
+
+ // A query chained off `connect()` with `.then()` (rather than awaited) must still
+ // be parented to the active transaction. Since the instrumentation requires a
+ // parent span, the query only produces a span if the trace context survives the
+ // connect promise's continuation.
+ describe('connect promise continuation', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 1 AS connect_then',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 1 AS connect_then',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ };
+
+ createEsmAndCjsTests(__dirname, 'scenario-connect-then.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('parents a query chained off connect() to the active transaction', { timeout: 90_000 }, async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({ transaction: EXPECTED_TRANSACTION })
+ .start()
+ .completed();
+ });
+ });
+ });
+
+ describe('requireParentSpan', () => {
+ createEsmAndCjsTests(__dirname, 'scenario-no-parent.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('does not instrument queries or connects without an active parent span', { timeout: 90_000 }, async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({
+ transaction: txn => {
+ const descriptions = txn.spans?.map(span => span.description) ?? [];
+ // The unparented connect + query must not have produced spans
+ expect(descriptions).not.toContain('SELECT 1 AS unparented');
+ expect(descriptions.find(name => name?.includes('connect'))).toBeUndefined();
+ // Only the parented query is instrumented
+ expect(txn).toMatchObject({
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 2 AS parented',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 2 AS parented',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ });
+ },
+ })
+ .start()
+ .completed();
+ });
+ });
+ });
+
  conditionalTest({ max: 25 })('pg-native', () => {
  const EXPECTED_TRANSACTION = {
  transaction: 'Test Transaction',

packages/node/src/integrations/tracing/postgres/index.ts

@@ -1,7 +1,7 @@
 import { PgInstrumentation } from './vendored/instrumentation';
 import type { IntegrationFn } from '@sentry/core';
 import { defineIntegration } from '@sentry/core';
-import { addOriginToSpan, generateInstrumentOnce } from '@sentry/node-core';
+import { generateInstrumentOnce } from '@sentry/node-core';
 
 interface PostgresIntegrationOptions {
  ignoreConnectSpans?: boolean;
@@ -13,10 +13,6 @@ export const instrumentPostgres = generateInstrumentOnce(
  INTEGRATION_NAME,
  PgInstrumentation,
  (options?: PostgresIntegrationOptions) => ({
- requireParentSpan: true,
- requestHook(span) {
- addOriginToSpan(span, 'auto.db.otel.postgres');
- },
  ignoreConnectSpans: options?.ignoreConnectSpans ?? false,
  }),
 );

packages/node/src/integrations/tracing/postgres/vendored/enums/AttributeNames.ts

@@ -6,11 +6,9 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-pg
  * - Upstream version: @opentelemetry/instrumentation-pg@0.70.0
  */
-/* eslint-disable */
 
 // Postgresql specific attributes not covered by semantic conventions
 export enum AttributeNames {
- PG_VALUES = 'db.postgresql.values',
  PG_PLAN = 'db.postgresql.plan',
  IDLE_TIMEOUT_MILLIS = 'db.postgresql.idle.timeout.millis',
  MAX_CLIENT = 'db.postgresql.max.client',

packages/node/src/integrations/tracing/postgres/vendored/enums/SpanNames.ts

@@ -6,7 +6,6 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-pg
  * - Upstream version: @opentelemetry/instrumentation-pg@0.70.0
  */
-/* eslint-disable */
 
 // Contains span names produced by instrumentation
 export enum SpanNames {

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-connect-error.mjs

@@ -0,0 +1,22 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+// Nothing is listening on this port, so `connect()` fails and the connect span
+// must be recorded with an errored status.
+const client = new Client({ port: 5499, user: 'test', password: 'test', database: 'tests' });
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ await client.connect().catch(() => {
+ // expected: connection refused
+ });
+ },
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-connect-then.mjs

@@ -0,0 +1,25 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ () =>
+ // Chain off `connect()` with `.then()` instead of awaiting it: the query
+ // issued from the continuation must still be parented to the active
+ // transaction, proving the trace context survives the connect promise.
+ new Promise((resolve, reject) => {
+ const client = new Client({ port: 5494, user: 'test', password: 'test', database: 'tests' });
+ client
+ .connect()
+ .then(() => client.query('SELECT 1 AS connect_then'))
+ .then(() => client.end())
+ .then(resolve, reject);
+ }),
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-no-parent.mjs

@@ -0,0 +1,26 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+const client = new Client({ port: 5494, user: 'test', password: 'test', database: 'tests' });
+
+async function run() {
+ // No active span here: `requireParentSpan` means the connect and this query
+ // must NOT produce spans.
+ await client.connect();
+ await client.query('SELECT 1 AS unparented');
+
+ // With an active span, the query is instrumented as a child span.
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ await client.query('SELECT 2 AS parented');
+ },
+ );
+
+ await client.end();
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-pool.mjs

@@ -0,0 +1,30 @@
+import * as Sentry from '@sentry/node';
+import pg from 'pg';
+
+const { Pool } = pg;
+
+// The connection string carries credentials so we can assert they are masked
+// out of the `db.connection_string` span attribute.
+const pool = new Pool({ connectionString: 'postgresql://test:test@localhost:5494/tests' });
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ try {
+ // Callback-style query exercises the callback-patching path (the
+ // promise-based scenarios never hit it).
+ await new Promise((resolve, reject) => {
+ pool.query('SELECT 1 AS foo', (err, res) => (err ? reject(err) : resolve(res)));
+ });
+ } finally {
+ await pool.end();
+ }
+ },
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario.mjs

@@ -23,6 +23,18 @@ async function run() {
 
  await client.query('INSERT INTO "User" ("email", "name") VALUES ($1, $2)', ['tim', 'tim@domain.com']);
  await client.query('SELECT * FROM "User"');
+
+ // A named (prepared) query records its name as the `db.postgresql.plan` attribute
+ await client.query({
+ name: 'select-user-by-email',
+ text: 'SELECT * FROM "User" WHERE "email" = $1',
+ values: ['tim'],
+ });
+
+ // A failing query should still produce an errored span
+ await client.query('SELECT * FROM "does_not_exist_table"').catch(() => {
+ // swallow: we only care about the span it produces
+ });
  } finally {
  await client.end();
  }

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

@@ -48,6 +48,33 @@ describe('postgres auto instrumentation', () => {
  status: 'ok',
  origin: 'auto.db.otel.postgres',
  }),
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT * FROM "User" WHERE "email" = $1',
+ 'db.postgresql.plan': 'select-user-by-email',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT * FROM "User" WHERE "email" = $1',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT * FROM "does_not_exist_table"',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT * FROM "does_not_exist_table"',
+ op: 'db',
+ status: 'internal_error',
+ origin: 'auto.db.otel.postgres',
+ }),
  ]),
  };
 
@@ -114,6 +141,161 @@ describe('postgres auto instrumentation', () => {
  });
  });
 
+ describe('pool', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ // Pool connect span: no origin is set on connect spans, so it defaults
+ // to 'manual', and the connection-string credentials are masked out.
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.connection_string': 'postgresql://localhost:5494/tests',
+ 'sentry.op': 'db',
+ }),
+ description: 'pg-pool.connect',
+ op: 'db',
+ status: 'ok',
+ origin: 'manual',
+ }),
+ // Callback-style query (no awaited promise returned to the caller).
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 1 AS foo',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 1 AS foo',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ };
+
+ createEsmAndCjsTests(__dirname, 'scenario-pool.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test(
+ 'auto-instruments `pg.Pool`, masks connection-string credentials, and handles callback-style queries',
+ { timeout: 90_000 },
+ async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({ transaction: EXPECTED_TRANSACTION })
+ .start()
+ .completed();
+ },
+ );
+ });
+ });
+
+ describe('connect error', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'sentry.op': 'db',
+ }),
+ description: 'pg.connect',
+ op: 'db',
+ status: 'internal_error',
+ origin: 'manual',
+ }),
+ ]),
+ };
+
+ // No DB needed: the scenario connects to a port where nothing is listening.
+ createEsmAndCjsTests(__dirname, 'scenario-connect-error.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('records an errored connect span when the connection fails', { timeout: 90_000 }, async () => {
+ await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+ });
+ });
+ });
+
+ // A query chained off `connect()` with `.then()` (rather than awaited) must still
+ // be parented to the active transaction. Since the instrumentation requires a
+ // parent span, the query only produces a span if the trace context survives the
+ // connect promise's continuation.
+ describe('connect promise continuation', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 1 AS connect_then',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 1 AS connect_then',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ };
+
+ createEsmAndCjsTests(__dirname, 'scenario-connect-then.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('parents a query chained off connect() to the active transaction', { timeout: 90_000 }, async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({ transaction: EXPECTED_TRANSACTION })
+ .start()
+ .completed();
+ });
+ });
+ });
+
+ describe('requireParentSpan', () => {
+ createEsmAndCjsTests(__dirname, 'scenario-no-parent.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('does not instrument queries or connects without an active parent span', { timeout: 90_000 }, async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({
+ transaction: txn => {
+ const descriptions = txn.spans?.map(span => span.description) ?? [];
+ // The unparented connect + query must not have produced spans
+ expect(descriptions).not.toContain('SELECT 1 AS unparented');
+ expect(descriptions.find(name => name?.includes('connect'))).toBeUndefined();
+ // Only the parented query is instrumented
+ expect(txn).toMatchObject({
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 2 AS parented',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 2 AS parented',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ });
+ },
+ })
+ .start()
+ .completed();
+ });
+ });
+ });
+
  conditionalTest({ max: 25 })('pg-native', () => {
  const EXPECTED_TRANSACTION = {
  transaction: 'Test Transaction',

packages/node/src/integrations/tracing/postgres/index.ts

@@ -1,7 +1,7 @@
 import { PgInstrumentation } from './vendored/instrumentation';
 import type { IntegrationFn } from '@sentry/core';
 import { defineIntegration } from '@sentry/core';
-import { addOriginToSpan, generateInstrumentOnce } from '@sentry/node-core';
+import { generateInstrumentOnce } from '@sentry/node-core';
 
 interface PostgresIntegrationOptions {
  ignoreConnectSpans?: boolean;
@@ -13,10 +13,6 @@ export const instrumentPostgres = generateInstrumentOnce(
  INTEGRATION_NAME,
  PgInstrumentation,
  (options?: PostgresIntegrationOptions) => ({
- requireParentSpan: true,
- requestHook(span) {
- addOriginToSpan(span, 'auto.db.otel.postgres');
- },
  ignoreConnectSpans: options?.ignoreConnectSpans ?? false,
  }),
 );

packages/node/src/integrations/tracing/postgres/vendored/enums/AttributeNames.ts

@@ -6,11 +6,9 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-pg
  * - Upstream version: @opentelemetry/instrumentation-pg@0.70.0
  */
-/* eslint-disable */
 
 // Postgresql specific attributes not covered by semantic conventions
 export enum AttributeNames {
- PG_VALUES = 'db.postgresql.values',
  PG_PLAN = 'db.postgresql.plan',
  IDLE_TIMEOUT_MILLIS = 'db.postgresql.idle.timeout.millis',
  MAX_CLIENT = 'db.postgresql.max.client',

packages/node/src/integrations/tracing/postgres/vendored/enums/SpanNames.ts

@@ -6,7 +6,6 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-pg
  * - Upstream version: @opentelemetry/instrumentation-pg@0.70.0
  */
-/* eslint-disable */
 
 // Contains span names produced by instrumentation
 export enum SpanNames {

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-connect-error.mjs

@@ -0,0 +1,22 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+// Nothing is listening on this port, so `connect()` fails and the connect span
+// must be recorded with an errored status.
+const client = new Client({ port: 5499, user: 'test', password: 'test', database: 'tests' });
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ await client.connect().catch(() => {
+ // expected: connection refused
+ });
+ },
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-connect-then.mjs

@@ -0,0 +1,25 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ () =>
+ // Chain off `connect()` with `.then()` instead of awaiting it: the query
+ // issued from the continuation must still be parented to the active
+ // transaction, proving the trace context survives the connect promise.
+ new Promise((resolve, reject) => {
+ const client = new Client({ port: 5494, user: 'test', password: 'test', database: 'tests' });
+ client
+ .connect()
+ .then(() => client.query('SELECT 1 AS connect_then'))
+ .then(() => client.end())
+ .then(resolve, reject);
+ }),
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-no-parent.mjs

@@ -0,0 +1,26 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+const client = new Client({ port: 5494, user: 'test', password: 'test', database: 'tests' });
+
+async function run() {
+ // No active span here: `requireParentSpan` means the connect and this query
+ // must NOT produce spans.
+ await client.connect();
+ await client.query('SELECT 1 AS unparented');
+
+ // With an active span, the query is instrumented as a child span.
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ await client.query('SELECT 2 AS parented');
+ },
+ );
+
+ await client.end();
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-pool.mjs

@@ -0,0 +1,30 @@
+import * as Sentry from '@sentry/node';
+import pg from 'pg';
+
+const { Pool } = pg;
+
+// The connection string carries credentials so we can assert they are masked
+// out of the `db.connection_string` span attribute.
+const pool = new Pool({ connectionString: 'postgresql://test:test@localhost:5494/tests' });
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ try {
+ // Callback-style query exercises the callback-patching path (the
+ // promise-based scenarios never hit it).
+ await new Promise((resolve, reject) => {
+ pool.query('SELECT 1 AS foo', (err, res) => (err ? reject(err) : resolve(res)));
+ });
+ } finally {
+ await pool.end();
+ }
+ },
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario.mjs

@@ -23,6 +23,18 @@ async function run() {
 
  await client.query('INSERT INTO "User" ("email", "name") VALUES ($1, $2)', ['tim', 'tim@domain.com']);
  await client.query('SELECT * FROM "User"');
+
+ // A named (prepared) query records its name as the `db.postgresql.plan` attribute
+ await client.query({
+ name: 'select-user-by-email',
+ text: 'SELECT * FROM "User" WHERE "email" = $1',
+ values: ['tim'],
+ });
+
+ // A failing query should still produce an errored span
+ await client.query('SELECT * FROM "does_not_exist_table"').catch(() => {
+ // swallow: we only care about the span it produces
+ });
  } finally {
  await client.end();
  }

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

@@ -48,6 +48,33 @@ describe('postgres auto instrumentation', () => {
  status: 'ok',
  origin: 'auto.db.otel.postgres',
  }),
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT * FROM "User" WHERE "email" = $1',
+ 'db.postgresql.plan': 'select-user-by-email',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT * FROM "User" WHERE "email" = $1',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT * FROM "does_not_exist_table"',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT * FROM "does_not_exist_table"',
+ op: 'db',
+ status: 'internal_error',
+ origin: 'auto.db.otel.postgres',
+ }),
  ]),
  };
 
@@ -114,6 +141,161 @@ describe('postgres auto instrumentation', () => {
  });
  });
 
+ describe('pool', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ // Pool connect span: no origin is set on connect spans, so it defaults
+ // to 'manual', and the connection-string credentials are masked out.
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.connection_string': 'postgresql://localhost:5494/tests',
+ 'sentry.op': 'db',
+ }),
+ description: 'pg-pool.connect',
+ op: 'db',
+ status: 'ok',
+ origin: 'manual',
+ }),
+ // Callback-style query (no awaited promise returned to the caller).
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 1 AS foo',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 1 AS foo',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ };
+
+ createEsmAndCjsTests(__dirname, 'scenario-pool.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test(
+ 'auto-instruments `pg.Pool`, masks connection-string credentials, and handles callback-style queries',
+ { timeout: 90_000 },
+ async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({ transaction: EXPECTED_TRANSACTION })
+ .start()
+ .completed();
+ },
+ );
+ });
+ });
+
+ describe('connect error', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'sentry.op': 'db',
+ }),
+ description: 'pg.connect',
+ op: 'db',
+ status: 'internal_error',
+ origin: 'manual',
+ }),
+ ]),
+ };
+
+ // No DB needed: the scenario connects to a port where nothing is listening.
+ createEsmAndCjsTests(__dirname, 'scenario-connect-error.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('records an errored connect span when the connection fails', { timeout: 90_000 }, async () => {
+ await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+ });
+ });
+ });
+
+ // A query chained off `connect()` with `.then()` (rather than awaited) must still
+ // be parented to the active transaction. Since the instrumentation requires a
+ // parent span, the query only produces a span if the trace context survives the
+ // connect promise's continuation.
+ describe('connect promise continuation', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 1 AS connect_then',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 1 AS connect_then',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ };
+
+ createEsmAndCjsTests(__dirname, 'scenario-connect-then.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('parents a query chained off connect() to the active transaction', { timeout: 90_000 }, async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({ transaction: EXPECTED_TRANSACTION })
+ .start()
+ .completed();
+ });
+ });
+ });
+
+ describe('requireParentSpan', () => {
+ createEsmAndCjsTests(__dirname, 'scenario-no-parent.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('does not instrument queries or connects without an active parent span', { timeout: 90_000 }, async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({
+ transaction: txn => {
+ const descriptions = txn.spans?.map(span => span.description) ?? [];
+ // The unparented connect + query must not have produced spans
+ expect(descriptions).not.toContain('SELECT 1 AS unparented');
+ expect(descriptions.find(name => name?.includes('connect'))).toBeUndefined();
+ // Only the parented query is instrumented
+ expect(txn).toMatchObject({
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 2 AS parented',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 2 AS parented',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ });
+ },
+ })
+ .start()
+ .completed();
+ });
+ });
+ });
+
  conditionalTest({ max: 25 })('pg-native', () => {
  const EXPECTED_TRANSACTION = {
  transaction: 'Test Transaction',

packages/node/src/integrations/tracing/postgres/index.ts

@@ -1,7 +1,7 @@
 import { PgInstrumentation } from './vendored/instrumentation';
 import type { IntegrationFn } from '@sentry/core';
 import { defineIntegration } from '@sentry/core';
-import { addOriginToSpan, generateInstrumentOnce } from '@sentry/node-core';
+import { generateInstrumentOnce } from '@sentry/node-core';
 
 interface PostgresIntegrationOptions {
  ignoreConnectSpans?: boolean;
@@ -13,10 +13,6 @@ export const instrumentPostgres = generateInstrumentOnce(
  INTEGRATION_NAME,
  PgInstrumentation,
  (options?: PostgresIntegrationOptions) => ({
- requireParentSpan: true,
- requestHook(span) {
- addOriginToSpan(span, 'auto.db.otel.postgres');
- },
  ignoreConnectSpans: options?.ignoreConnectSpans ?? false,
  }),
 );

packages/node/src/integrations/tracing/postgres/vendored/enums/AttributeNames.ts

@@ -6,11 +6,9 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-pg
  * - Upstream version: @opentelemetry/instrumentation-pg@0.70.0
  */
-/* eslint-disable */
 
 // Postgresql specific attributes not covered by semantic conventions
 export enum AttributeNames {
- PG_VALUES = 'db.postgresql.values',
  PG_PLAN = 'db.postgresql.plan',
  IDLE_TIMEOUT_MILLIS = 'db.postgresql.idle.timeout.millis',
  MAX_CLIENT = 'db.postgresql.max.client',

packages/node/src/integrations/tracing/postgres/vendored/enums/SpanNames.ts

@@ -6,7 +6,6 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-pg
  * - Upstream version: @opentelemetry/instrumentation-pg@0.70.0
  */
-/* eslint-disable */
 
 // Contains span names produced by instrumentation
 export enum SpanNames {

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-connect-error.mjs

@@ -0,0 +1,22 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+// Nothing is listening on this port, so `connect()` fails and the connect span
+// must be recorded with an errored status.
+const client = new Client({ port: 5499, user: 'test', password: 'test', database: 'tests' });
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ await client.connect().catch(() => {
+ // expected: connection refused
+ });
+ },
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-connect-then.mjs

@@ -0,0 +1,25 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ () =>
+ // Chain off `connect()` with `.then()` instead of awaiting it: the query
+ // issued from the continuation must still be parented to the active
+ // transaction, proving the trace context survives the connect promise.
+ new Promise((resolve, reject) => {
+ const client = new Client({ port: 5494, user: 'test', password: 'test', database: 'tests' });
+ client
+ .connect()
+ .then(() => client.query('SELECT 1 AS connect_then'))
+ .then(() => client.end())
+ .then(resolve, reject);
+ }),
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-no-parent.mjs

@@ -0,0 +1,26 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+const client = new Client({ port: 5494, user: 'test', password: 'test', database: 'tests' });
+
+async function run() {
+ // No active span here: `requireParentSpan` means the connect and this query
+ // must NOT produce spans.
+ await client.connect();
+ await client.query('SELECT 1 AS unparented');
+
+ // With an active span, the query is instrumented as a child span.
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ await client.query('SELECT 2 AS parented');
+ },
+ );
+
+ await client.end();
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-pool.mjs

@@ -0,0 +1,30 @@
+import * as Sentry from '@sentry/node';
+import pg from 'pg';
+
+const { Pool } = pg;
+
+// The connection string carries credentials so we can assert they are masked
+// out of the `db.connection_string` span attribute.
+const pool = new Pool({ connectionString: 'postgresql://test:test@localhost:5494/tests' });
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ try {
+ // Callback-style query exercises the callback-patching path (the
+ // promise-based scenarios never hit it).
+ await new Promise((resolve, reject) => {
+ pool.query('SELECT 1 AS foo', (err, res) => (err ? reject(err) : resolve(res)));
+ });
+ } finally {
+ await pool.end();
+ }
+ },
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario.mjs

@@ -23,6 +23,18 @@ async function run() {
 
  await client.query('INSERT INTO "User" ("email", "name") VALUES ($1, $2)', ['tim', 'tim@domain.com']);
  await client.query('SELECT * FROM "User"');
+
+ // A named (prepared) query records its name as the `db.postgresql.plan` attribute
+ await client.query({
+ name: 'select-user-by-email',
+ text: 'SELECT * FROM "User" WHERE "email" = $1',
+ values: ['tim'],
+ });
+
+ // A failing query should still produce an errored span
+ await client.query('SELECT * FROM "does_not_exist_table"').catch(() => {
+ // swallow: we only care about the span it produces
+ });
  } finally {
  await client.end();
  }

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

@@ -48,6 +48,33 @@ describe('postgres auto instrumentation', () => {
  status: 'ok',
  origin: 'auto.db.otel.postgres',
  }),
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT * FROM "User" WHERE "email" = $1',
+ 'db.postgresql.plan': 'select-user-by-email',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT * FROM "User" WHERE "email" = $1',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT * FROM "does_not_exist_table"',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT * FROM "does_not_exist_table"',
+ op: 'db',
+ status: 'internal_error',
+ origin: 'auto.db.otel.postgres',
+ }),
  ]),
  };
 
@@ -114,6 +141,161 @@ describe('postgres auto instrumentation', () => {
  });
  });
 
+ describe('pool', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ // Pool connect span: no origin is set on connect spans, so it defaults
+ // to 'manual', and the connection-string credentials are masked out.
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.connection_string': 'postgresql://localhost:5494/tests',
+ 'sentry.op': 'db',
+ }),
+ description: 'pg-pool.connect',
+ op: 'db',
+ status: 'ok',
+ origin: 'manual',
+ }),
+ // Callback-style query (no awaited promise returned to the caller).
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 1 AS foo',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 1 AS foo',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ };
+
+ createEsmAndCjsTests(__dirname, 'scenario-pool.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test(
+ 'auto-instruments `pg.Pool`, masks connection-string credentials, and handles callback-style queries',
+ { timeout: 90_000 },
+ async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({ transaction: EXPECTED_TRANSACTION })
+ .start()
+ .completed();
+ },
+ );
+ });
+ });
+
+ describe('connect error', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'sentry.op': 'db',
+ }),
+ description: 'pg.connect',
+ op: 'db',
+ status: 'internal_error',
+ origin: 'manual',
+ }),
+ ]),
+ };
+
+ // No DB needed: the scenario connects to a port where nothing is listening.
+ createEsmAndCjsTests(__dirname, 'scenario-connect-error.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('records an errored connect span when the connection fails', { timeout: 90_000 }, async () => {
+ await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+ });
+ });
+ });
+
+ // A query chained off `connect()` with `.then()` (rather than awaited) must still
+ // be parented to the active transaction. Since the instrumentation requires a
+ // parent span, the query only produces a span if the trace context survives the
+ // connect promise's continuation.
+ describe('connect promise continuation', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 1 AS connect_then',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 1 AS connect_then',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ };
+
+ createEsmAndCjsTests(__dirname, 'scenario-connect-then.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('parents a query chained off connect() to the active transaction', { timeout: 90_000 }, async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({ transaction: EXPECTED_TRANSACTION })
+ .start()
+ .completed();
+ });
+ });
+ });
+
+ describe('requireParentSpan', () => {
+ createEsmAndCjsTests(__dirname, 'scenario-no-parent.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('does not instrument queries or connects without an active parent span', { timeout: 90_000 }, async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({
+ transaction: txn => {
+ const descriptions = txn.spans?.map(span => span.description) ?? [];
+ // The unparented connect + query must not have produced spans
+ expect(descriptions).not.toContain('SELECT 1 AS unparented');
+ expect(descriptions.find(name => name?.includes('connect'))).toBeUndefined();
+ // Only the parented query is instrumented
+ expect(txn).toMatchObject({
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 2 AS parented',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 2 AS parented',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ });
+ },
+ })
+ .start()
+ .completed();
+ });
+ });
+ });
+
  conditionalTest({ max: 25 })('pg-native', () => {
  const EXPECTED_TRANSACTION = {
  transaction: 'Test Transaction',

packages/node/src/integrations/tracing/postgres/index.ts

@@ -1,7 +1,7 @@
 import { PgInstrumentation } from './vendored/instrumentation';
 import type { IntegrationFn } from '@sentry/core';
 import { defineIntegration } from '@sentry/core';
-import { addOriginToSpan, generateInstrumentOnce } from '@sentry/node-core';
+import { generateInstrumentOnce } from '@sentry/node-core';
 
 interface PostgresIntegrationOptions {
  ignoreConnectSpans?: boolean;
@@ -13,10 +13,6 @@ export const instrumentPostgres = generateInstrumentOnce(
  INTEGRATION_NAME,
  PgInstrumentation,
  (options?: PostgresIntegrationOptions) => ({
- requireParentSpan: true,
- requestHook(span) {
- addOriginToSpan(span, 'auto.db.otel.postgres');
- },
  ignoreConnectSpans: options?.ignoreConnectSpans ?? false,
  }),
 );

packages/node/src/integrations/tracing/postgres/vendored/enums/AttributeNames.ts

@@ -6,11 +6,9 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-pg
  * - Upstream version: @opentelemetry/instrumentation-pg@0.70.0
  */
-/* eslint-disable */
 
 // Postgresql specific attributes not covered by semantic conventions
 export enum AttributeNames {
- PG_VALUES = 'db.postgresql.values',
  PG_PLAN = 'db.postgresql.plan',
  IDLE_TIMEOUT_MILLIS = 'db.postgresql.idle.timeout.millis',
  MAX_CLIENT = 'db.postgresql.max.client',

packages/node/src/integrations/tracing/postgres/vendored/enums/SpanNames.ts

@@ -6,7 +6,6 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-pg
  * - Upstream version: @opentelemetry/instrumentation-pg@0.70.0
  */
-/* eslint-disable */
 
 // Contains span names produced by instrumentation
 export enum SpanNames {

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-connect-error.mjs

@@ -0,0 +1,22 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+// Nothing is listening on this port, so `connect()` fails and the connect span
+// must be recorded with an errored status.
+const client = new Client({ port: 5499, user: 'test', password: 'test', database: 'tests' });
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ await client.connect().catch(() => {
+ // expected: connection refused
+ });
+ },
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-connect-then.mjs

@@ -0,0 +1,25 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ () =>
+ // Chain off `connect()` with `.then()` instead of awaiting it: the query
+ // issued from the continuation must still be parented to the active
+ // transaction, proving the trace context survives the connect promise.
+ new Promise((resolve, reject) => {
+ const client = new Client({ port: 5494, user: 'test', password: 'test', database: 'tests' });
+ client
+ .connect()
+ .then(() => client.query('SELECT 1 AS connect_then'))
+ .then(() => client.end())
+ .then(resolve, reject);
+ }),
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-no-parent.mjs

@@ -0,0 +1,26 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+const client = new Client({ port: 5494, user: 'test', password: 'test', database: 'tests' });
+
+async function run() {
+ // No active span here: `requireParentSpan` means the connect and this query
+ // must NOT produce spans.
+ await client.connect();
+ await client.query('SELECT 1 AS unparented');
+
+ // With an active span, the query is instrumented as a child span.
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ await client.query('SELECT 2 AS parented');
+ },
+ );
+
+ await client.end();
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-pool.mjs

@@ -0,0 +1,30 @@
+import * as Sentry from '@sentry/node';
+import pg from 'pg';
+
+const { Pool } = pg;
+
+// The connection string carries credentials so we can assert they are masked
+// out of the `db.connection_string` span attribute.
+const pool = new Pool({ connectionString: 'postgresql://test:test@localhost:5494/tests' });
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ try {
+ // Callback-style query exercises the callback-patching path (the
+ // promise-based scenarios never hit it).
+ await new Promise((resolve, reject) => {
+ pool.query('SELECT 1 AS foo', (err, res) => (err ? reject(err) : resolve(res)));
+ });
+ } finally {
+ await pool.end();
+ }
+ },
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario.mjs

@@ -23,6 +23,18 @@ async function run() {
 
  await client.query('INSERT INTO "User" ("email", "name") VALUES ($1, $2)', ['tim', 'tim@domain.com']);
  await client.query('SELECT * FROM "User"');
+
+ // A named (prepared) query records its name as the `db.postgresql.plan` attribute
+ await client.query({
+ name: 'select-user-by-email',
+ text: 'SELECT * FROM "User" WHERE "email" = $1',
+ values: ['tim'],
+ });
+
+ // A failing query should still produce an errored span
+ await client.query('SELECT * FROM "does_not_exist_table"').catch(() => {
+ // swallow: we only care about the span it produces
+ });
  } finally {
  await client.end();
  }

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

@@ -48,6 +48,33 @@ describe('postgres auto instrumentation', () => {
  status: 'ok',
  origin: 'auto.db.otel.postgres',
  }),
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT * FROM "User" WHERE "email" = $1',
+ 'db.postgresql.plan': 'select-user-by-email',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT * FROM "User" WHERE "email" = $1',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT * FROM "does_not_exist_table"',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT * FROM "does_not_exist_table"',
+ op: 'db',
+ status: 'internal_error',
+ origin: 'auto.db.otel.postgres',
+ }),
  ]),
  };
 
@@ -114,6 +141,161 @@ describe('postgres auto instrumentation', () => {
  });
  });
 
+ describe('pool', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ // Pool connect span: no origin is set on connect spans, so it defaults
+ // to 'manual', and the connection-string credentials are masked out.
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.connection_string': 'postgresql://localhost:5494/tests',
+ 'sentry.op': 'db',
+ }),
+ description: 'pg-pool.connect',
+ op: 'db',
+ status: 'ok',
+ origin: 'manual',
+ }),
+ // Callback-style query (no awaited promise returned to the caller).
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 1 AS foo',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 1 AS foo',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ };
+
+ createEsmAndCjsTests(__dirname, 'scenario-pool.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test(
+ 'auto-instruments `pg.Pool`, masks connection-string credentials, and handles callback-style queries',
+ { timeout: 90_000 },
+ async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({ transaction: EXPECTED_TRANSACTION })
+ .start()
+ .completed();
+ },
+ );
+ });
+ });
+
+ describe('connect error', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'sentry.op': 'db',
+ }),
+ description: 'pg.connect',
+ op: 'db',
+ status: 'internal_error',
+ origin: 'manual',
+ }),
+ ]),
+ };
+
+ // No DB needed: the scenario connects to a port where nothing is listening.
+ createEsmAndCjsTests(__dirname, 'scenario-connect-error.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('records an errored connect span when the connection fails', { timeout: 90_000 }, async () => {
+ await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+ });
+ });
+ });
+
+ // A query chained off `connect()` with `.then()` (rather than awaited) must still
+ // be parented to the active transaction. Since the instrumentation requires a
+ // parent span, the query only produces a span if the trace context survives the
+ // connect promise's continuation.
+ describe('connect promise continuation', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 1 AS connect_then',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 1 AS connect_then',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ };
+
+ createEsmAndCjsTests(__dirname, 'scenario-connect-then.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('parents a query chained off connect() to the active transaction', { timeout: 90_000 }, async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({ transaction: EXPECTED_TRANSACTION })
+ .start()
+ .completed();
+ });
+ });
+ });
+
+ describe('requireParentSpan', () => {
+ createEsmAndCjsTests(__dirname, 'scenario-no-parent.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('does not instrument queries or connects without an active parent span', { timeout: 90_000 }, async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({
+ transaction: txn => {
+ const descriptions = txn.spans?.map(span => span.description) ?? [];
+ // The unparented connect + query must not have produced spans
+ expect(descriptions).not.toContain('SELECT 1 AS unparented');
+ expect(descriptions.find(name => name?.includes('connect'))).toBeUndefined();
+ // Only the parented query is instrumented
+ expect(txn).toMatchObject({
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 2 AS parented',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 2 AS parented',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ });
+ },
+ })
+ .start()
+ .completed();
+ });
+ });
+ });
+
  conditionalTest({ max: 25 })('pg-native', () => {
  const EXPECTED_TRANSACTION = {
  transaction: 'Test Transaction',

packages/node/src/integrations/tracing/postgres/index.ts

@@ -1,7 +1,7 @@
 import { PgInstrumentation } from './vendored/instrumentation';
 import type { IntegrationFn } from '@sentry/core';
 import { defineIntegration } from '@sentry/core';
-import { addOriginToSpan, generateInstrumentOnce } from '@sentry/node-core';
+import { generateInstrumentOnce } from '@sentry/node-core';
 
 interface PostgresIntegrationOptions {
  ignoreConnectSpans?: boolean;
@@ -13,10 +13,6 @@ export const instrumentPostgres = generateInstrumentOnce(
  INTEGRATION_NAME,
  PgInstrumentation,
  (options?: PostgresIntegrationOptions) => ({
- requireParentSpan: true,
- requestHook(span) {
- addOriginToSpan(span, 'auto.db.otel.postgres');
- },
  ignoreConnectSpans: options?.ignoreConnectSpans ?? false,
  }),
 );

packages/node/src/integrations/tracing/postgres/vendored/enums/AttributeNames.ts

@@ -6,11 +6,9 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-pg
  * - Upstream version: @opentelemetry/instrumentation-pg@0.70.0
  */
-/* eslint-disable */
 
 // Postgresql specific attributes not covered by semantic conventions
 export enum AttributeNames {
- PG_VALUES = 'db.postgresql.values',
  PG_PLAN = 'db.postgresql.plan',
  IDLE_TIMEOUT_MILLIS = 'db.postgresql.idle.timeout.millis',
  MAX_CLIENT = 'db.postgresql.max.client',

packages/node/src/integrations/tracing/postgres/vendored/enums/SpanNames.ts

@@ -6,7 +6,6 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-pg
  * - Upstream version: @opentelemetry/instrumentation-pg@0.70.0
  */
-/* eslint-disable */
 
 // Contains span names produced by instrumentation
 export enum SpanNames {

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-connect-error.mjs

@@ -0,0 +1,22 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+// Nothing is listening on this port, so `connect()` fails and the connect span
+// must be recorded with an errored status.
+const client = new Client({ port: 5499, user: 'test', password: 'test', database: 'tests' });
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ await client.connect().catch(() => {
+ // expected: connection refused
+ });
+ },
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-connect-then.mjs

@@ -0,0 +1,25 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ () =>
+ // Chain off `connect()` with `.then()` instead of awaiting it: the query
+ // issued from the continuation must still be parented to the active
+ // transaction, proving the trace context survives the connect promise.
+ new Promise((resolve, reject) => {
+ const client = new Client({ port: 5494, user: 'test', password: 'test', database: 'tests' });
+ client
+ .connect()
+ .then(() => client.query('SELECT 1 AS connect_then'))
+ .then(() => client.end())
+ .then(resolve, reject);
+ }),
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-no-parent.mjs

@@ -0,0 +1,26 @@
+import * as Sentry from '@sentry/node';
+import { Client } from 'pg';
+
+const client = new Client({ port: 5494, user: 'test', password: 'test', database: 'tests' });
+
+async function run() {
+ // No active span here: `requireParentSpan` means the connect and this query
+ // must NOT produce spans.
+ await client.connect();
+ await client.query('SELECT 1 AS unparented');
+
+ // With an active span, the query is instrumented as a child span.
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ await client.query('SELECT 2 AS parented');
+ },
+ );
+
+ await client.end();
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario-pool.mjs

@@ -0,0 +1,30 @@
+import * as Sentry from '@sentry/node';
+import pg from 'pg';
+
+const { Pool } = pg;
+
+// The connection string carries credentials so we can assert they are masked
+// out of the `db.connection_string` span attribute.
+const pool = new Pool({ connectionString: 'postgresql://test:test@localhost:5494/tests' });
+
+async function run() {
+ await Sentry.startSpan(
+ {
+ name: 'Test Transaction',
+ op: 'transaction',
+ },
+ async () => {
+ try {
+ // Callback-style query exercises the callback-patching path (the
+ // promise-based scenarios never hit it).
+ await new Promise((resolve, reject) => {
+ pool.query('SELECT 1 AS foo', (err, res) => (err ? reject(err) : resolve(res)));
+ });
+ } finally {
+ await pool.end();
+ }
+ },
+ );
+}
+
+run();

dev-packages/node-integration-tests/suites/tracing/postgres/scenario.mjs

@@ -23,6 +23,18 @@ async function run() {
 
  await client.query('INSERT INTO "User" ("email", "name") VALUES ($1, $2)', ['tim', 'tim@domain.com']);
  await client.query('SELECT * FROM "User"');
+
+ // A named (prepared) query records its name as the `db.postgresql.plan` attribute
+ await client.query({
+ name: 'select-user-by-email',
+ text: 'SELECT * FROM "User" WHERE "email" = $1',
+ values: ['tim'],
+ });
+
+ // A failing query should still produce an errored span
+ await client.query('SELECT * FROM "does_not_exist_table"').catch(() => {
+ // swallow: we only care about the span it produces
+ });
  } finally {
  await client.end();
  }

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

@@ -48,6 +48,33 @@ describe('postgres auto instrumentation', () => {
  status: 'ok',
  origin: 'auto.db.otel.postgres',
  }),
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT * FROM "User" WHERE "email" = $1',
+ 'db.postgresql.plan': 'select-user-by-email',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT * FROM "User" WHERE "email" = $1',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT * FROM "does_not_exist_table"',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT * FROM "does_not_exist_table"',
+ op: 'db',
+ status: 'internal_error',
+ origin: 'auto.db.otel.postgres',
+ }),
  ]),
  };
 
@@ -114,6 +141,161 @@ describe('postgres auto instrumentation', () => {
  });
  });
 
+ describe('pool', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ // Pool connect span: no origin is set on connect spans, so it defaults
+ // to 'manual', and the connection-string credentials are masked out.
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.connection_string': 'postgresql://localhost:5494/tests',
+ 'sentry.op': 'db',
+ }),
+ description: 'pg-pool.connect',
+ op: 'db',
+ status: 'ok',
+ origin: 'manual',
+ }),
+ // Callback-style query (no awaited promise returned to the caller).
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 1 AS foo',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 1 AS foo',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ };
+
+ createEsmAndCjsTests(__dirname, 'scenario-pool.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test(
+ 'auto-instruments `pg.Pool`, masks connection-string credentials, and handles callback-style queries',
+ { timeout: 90_000 },
+ async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({ transaction: EXPECTED_TRANSACTION })
+ .start()
+ .completed();
+ },
+ );
+ });
+ });
+
+ describe('connect error', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'sentry.op': 'db',
+ }),
+ description: 'pg.connect',
+ op: 'db',
+ status: 'internal_error',
+ origin: 'manual',
+ }),
+ ]),
+ };
+
+ // No DB needed: the scenario connects to a port where nothing is listening.
+ createEsmAndCjsTests(__dirname, 'scenario-connect-error.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('records an errored connect span when the connection fails', { timeout: 90_000 }, async () => {
+ await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+ });
+ });
+ });
+
+ // A query chained off `connect()` with `.then()` (rather than awaited) must still
+ // be parented to the active transaction. Since the instrumentation requires a
+ // parent span, the query only produces a span if the trace context survives the
+ // connect promise's continuation.
+ describe('connect promise continuation', () => {
+ const EXPECTED_TRANSACTION = {
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 1 AS connect_then',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 1 AS connect_then',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ };
+
+ createEsmAndCjsTests(__dirname, 'scenario-connect-then.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('parents a query chained off connect() to the active transaction', { timeout: 90_000 }, async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({ transaction: EXPECTED_TRANSACTION })
+ .start()
+ .completed();
+ });
+ });
+ });
+
+ describe('requireParentSpan', () => {
+ createEsmAndCjsTests(__dirname, 'scenario-no-parent.mjs', 'instrument.mjs', (createTestRunner, test) => {
+ test('does not instrument queries or connects without an active parent span', { timeout: 90_000 }, async () => {
+ await createTestRunner()
+ .withDockerCompose({
+ workingDirectory: [__dirname],
+ })
+ .expect({
+ transaction: txn => {
+ const descriptions = txn.spans?.map(span => span.description) ?? [];
+ // The unparented connect + query must not have produced spans
+ expect(descriptions).not.toContain('SELECT 1 AS unparented');
+ expect(descriptions.find(name => name?.includes('connect'))).toBeUndefined();
+ // Only the parented query is instrumented
+ expect(txn).toMatchObject({
+ transaction: 'Test Transaction',
+ spans: expect.arrayContaining([
+ expect.objectContaining({
+ data: expect.objectContaining({
+ 'db.system': 'postgresql',
+ 'db.name': 'tests',
+ 'db.statement': 'SELECT 2 AS parented',
+ 'sentry.origin': 'auto.db.otel.postgres',
+ 'sentry.op': 'db',
+ }),
+ description: 'SELECT 2 AS parented',
+ op: 'db',
+ status: 'ok',
+ origin: 'auto.db.otel.postgres',
+ }),
+ ]),
+ });
+ },
+ })
+ .start()
+ .completed();
+ });
+ });
+ });
+
  conditionalTest({ max: 25 })('pg-native', () => {
  const EXPECTED_TRANSACTION = {
  transaction: 'Test Transaction',

packages/node/src/integrations/tracing/postgres/index.ts

@@ -1,7 +1,7 @@
 import { PgInstrumentation } from './vendored/instrumentation';
 import type { IntegrationFn } from '@sentry/core';
 import { defineIntegration } from '@sentry/core';
-import { addOriginToSpan, generateInstrumentOnce } from '@sentry/node-core';
+import { generateInstrumentOnce } from '@sentry/node-core';
 
 interface PostgresIntegrationOptions {
  ignoreConnectSpans?: boolean;
@@ -13,10 +13,6 @@ export const instrumentPostgres = generateInstrumentOnce(
  INTEGRATION_NAME,
  PgInstrumentation,
  (options?: PostgresIntegrationOptions) => ({
- requireParentSpan: true,
- requestHook(span) {
- addOriginToSpan(span, 'auto.db.otel.postgres');
- },
  ignoreConnectSpans: options?.ignoreConnectSpans ?? false,
  }),
 );

packages/node/src/integrations/tracing/postgres/vendored/enums/AttributeNames.ts

@@ -6,11 +6,9 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-pg
  * - Upstream version: @opentelemetry/instrumentation-pg@0.70.0
  */
-/* eslint-disable */
 
 // Postgresql specific attributes not covered by semantic conventions
 export enum AttributeNames {
- PG_VALUES = 'db.postgresql.values',
  PG_PLAN = 'db.postgresql.plan',
  IDLE_TIMEOUT_MILLIS = 'db.postgresql.idle.timeout.millis',
  MAX_CLIENT = 'db.postgresql.max.client',

packages/node/src/integrations/tracing/postgres/vendored/enums/SpanNames.ts

@@ -6,7 +6,6 @@
  * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-pg
  * - Upstream version: @opentelemetry/instrumentation-pg@0.70.0
  */
-/* eslint-disable */
 
 // Contains span names produced by instrumentation
 export enum SpanNames {