@depup/sentry__server-utils 10.67.0-depup.0

package/build/esm/integrations/tracing-channel/mysql2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mysql2.js","sources":["../../../../src/integrations/tracing-channel/mysql2.ts"],"sourcesContent":["import * as diagnosticsChannel from 'node:diagnostics_channel';\nimport type { IntegrationFn, SpanAttributes } from '@sentry/core';\nimport {\n  defineIntegration,\n  isObjectLike,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  SPAN_KIND,\n  startInactiveSpan,\n  waitForTracingChannelBinding,\n} from '@sentry/core';\nimport { subscribeMysql2DiagnosticChannels } from '../../mysql2/mysql2-dc-subscriber';\nimport type { ChannelName } from '../../orchestrion/channels';\nimport { CHANNELS } from '../../orchestrion/channels';\nimport { bindTracingChannelToSpan } from '../../tracing-channel';\nimport {\n  DB_NAME,\n  DB_STATEMENT,\n  DB_SYSTEM,\n  DB_USER,\n  NET_PEER_NAME,\n  NET_PEER_PORT,\n} from '@sentry/conventions/attributes';\n\nconst INTEGRATION_NAME = 'Mysql2' as const;\nconst ORIGIN = 'auto.db.orchestrion.mysql2';\nconst DB_SYSTEM_VALUE_MYSQL = 'mysql';\n\n/**\n * The shape orchestrion's transform attaches to the tracing-channel `context` object. Documented here\n * rather than imported because orchestrion's runtime doesn't export it.\n */\ninterface Mysql2QueryChannelContext {\n  // The live args array passed to the wrapped `query`/`execute` call: `arguments[0]` is the SQL (a\n  // string, `Query`, or `{ sql, values }`), `arguments[1]` is the values array or a callback.\n  arguments: unknown[];\n  self?: Mysql2Connection;\n  result?: unknown;\n  error?: unknown;\n}\n\ninterface Mysql2ConnectionConfig {\n  host?: string;\n  port?: number | string;\n  database?: string;\n  user?: string;\n  // Pool connections nest the real config one level deeper.\n  connectionConfig?: Mysql2ConnectionConfig;\n}\n\ninterface Mysql2Connection {\n  config?: Mysql2ConnectionConfig;\n}\n\n/**\n * Orchestrion-driven mysql2 integration.\n *\n * Subscribes to:\n *   - the `orchestrion:mysql2:query`/`:execute` channels the code transform injects into mysql2's\n *     `query`/`execute` (mysql2 `< 3.20.0`), and\n *   - mysql2's native `node:diagnostics_channel` tracing channels (mysql2 `>= 3.20.0`), which the\n *     transform intentionally leaves alone.\n *\n * The two version ranges never overlap, so no query is double-counted. Requires the orchestrion\n * runtime hook or bundler plugin to be active — wire that up via\n * `experimentalUseDiagnosticsChannelInjection`.\n */\nfunction instrumentMysql2(): void {\n  // mysql2 >= 3.20.0: native diagnostics_channel path (inert on older versions, which never publish).\n  subscribeMysql2DiagnosticChannels(diagnosticsChannel.tracingChannel);\n\n  // mysql2 < 3.20.0: orchestrion-injected channels (inert on >= 3.20.0, which we don't transform).\n  subscribeQueryChannel(CHANNELS.MYSQL2_QUERY);\n  subscribeQueryChannel(CHANNELS.MYSQL2_EXECUTE);\n}\n\nfunction subscribeQueryChannel(channelName: ChannelName): void {\n  bindTracingChannelToSpan(\n    diagnosticsChannel.tracingChannel<Mysql2QueryChannelContext>(channelName),\n    data => {\n      const statement = getQueryText(data.arguments);\n\n      return startInactiveSpan({\n        name: statement ?? 'mysql2.query',\n        kind: SPAN_KIND.CLIENT,\n        attributes: {\n          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN,\n          [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'db',\n          // oxlint-disable-next-line typescript/no-deprecated\n          [DB_SYSTEM]: DB_SYSTEM_VALUE_MYSQL,\n          ...getConnectionAttributes(data.self?.config),\n          // oxlint-disable-next-line typescript/no-deprecated\n          [DB_STATEMENT]: statement || undefined,\n        },\n      });\n    },\n    { requiresParentSpan: true },\n  );\n}\n\n/**\n * Render the `db.statement` from the wrapped call's first argument.\n */\nfunction getQueryText(args: unknown[]): string | undefined {\n  return extractSql(args[0]);\n}\n\nfunction extractSql(firstArg: unknown): string | undefined {\n  if (typeof firstArg === 'string') {\n    return firstArg;\n  }\n  if (isObjectLike(firstArg) && 'sql' in firstArg) {\n    const sql = (firstArg as { sql?: unknown }).sql;\n    return typeof sql === 'string' ? sql : undefined;\n  }\n  return undefined;\n}\n\nfunction getConnectionAttributes(config: Mysql2ConnectionConfig | undefined): SpanAttributes {\n  // Pool connections nest the real config under `.connectionConfig`; single connections expose it\n  // directly. Matches `@opentelemetry/instrumentation-mysql2`.\n  const { host, port, database, user } = config?.connectionConfig ?? config ?? {};\n  const portNumber = typeof port === 'string' ? parseInt(port, 10) : port;\n  const portIsNumber = typeof portNumber === 'number' && !isNaN(portNumber);\n\n  return {\n    // oxlint-disable-next-line typescript/no-deprecated\n    [DB_NAME]: database || undefined,\n    [DB_USER]: user || undefined,\n    // oxlint-disable-next-line typescript/no-deprecated\n    [NET_PEER_NAME]: host || undefined,\n    // oxlint-disable-next-line typescript/no-deprecated\n    [NET_PEER_PORT]: portIsNumber ? portNumber : undefined,\n  };\n}\n\nconst _mysql2ChannelIntegration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      // `tracingChannel` is unavailable before Node 18.19 so do nothing in that case.\n      if (!diagnosticsChannel.tracingChannel) {\n        return;\n      }\n\n      waitForTracingChannelBinding(() => {\n        instrumentMysql2();\n      });\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Orchestrion-driven mysql2 integration.\n *\n * Adds Sentry tracing instrumentation for the [mysql2](https://www.npmjs.com/package/mysql2) library\n * via diagnostics-channel injection. See {@link instrumentMysql2} for how the two mysql2 version\n * ranges are covered.\n *\n * Known limitation vs. the OTel integration it replaces: the callback-less streaming form\n * (`connection.query(sql).on('result', ...)`) is not traced — see the `mysql2` orchestrion config for\n * why. The callback and promise forms (the common case) are fully instrumented.\n */\nexport const mysql2ChannelIntegration = defineIntegration(_mysql2ChannelIntegration);\n"],"names":[],"mappings":";;;;;;;AAwBA,MAAM,gBAAA,GAAmB,QAAA;AACzB,MAAM,MAAA,GAAS,4BAAA;AACf,MAAM,qBAAA,GAAwB,OAAA;AAyC9B,SAAS,gBAAA,GAAyB;AAEhC,EAAA,iCAAA,CAAkC,mBAAmB,cAAc,CAAA;AAGnE,EAAA,qBAAA,CAAsB,SAAS,YAAY,CAAA;AAC3C,EAAA,qBAAA,CAAsB,SAAS,cAAc,CAAA;AAC/C;AAEA,SAAS,sBAAsB,WAAA,EAAgC;AAC7D,EAAA,wBAAA;AAAA,IACE,kBAAA,CAAmB,eAA0C,WAAW,CAAA;AAAA,IACxE,CAAA,IAAA,KAAQ;AACN,MAAA,MAAM,SAAA,GAAY,YAAA,CAAa,IAAA,CAAK,SAAS,CAAA;AAE7C,MAAA,OAAO,iBAAA,CAAkB;AAAA,QACvB,MAAM,SAAA,IAAa,cAAA;AAAA,QACnB,MAAM,SAAA,CAAU,MAAA;AAAA,QAChB,UAAA,EAAY;AAAA,UACV,CAAC,gCAAgC,GAAG,MAAA;AAAA,UACpC,CAAC,4BAA4B,GAAG,IAAA;AAAA;AAAA,UAEhC,CAAC,SAAS,GAAG,qBAAA;AAAA,UACb,GAAG,uBAAA,CAAwB,IAAA,CAAK,IAAA,EAAM,MAAM,CAAA;AAAA;AAAA,UAE5C,CAAC,YAAY,GAAG,SAAA,IAAa;AAAA;AAC/B,OACD,CAAA;AAAA,IACH,CAAA;AAAA,IACA,EAAE,oBAAoB,IAAA;AAAK,GAC7B;AACF;AAKA,SAAS,aAAa,IAAA,EAAqC;AACzD,EAAA,OAAO,UAAA,CAAW,IAAA,CAAK,CAAC,CAAC,CAAA;AAC3B;AAEA,SAAS,WAAW,QAAA,EAAuC;AACzD,EAAA,IAAI,OAAO,aAAa,QAAA,EAAU;AAChC,IAAA,OAAO,QAAA;AAAA,EACT;AACA,EAAA,IAAI,YAAA,CAAa,QAAQ,CAAA,IAAK,KAAA,IAAS,QAAA,EAAU;AAC/C,IAAA,MAAM,MAAO,QAAA,CAA+B,GAAA;AAC5C,IAAA,OAAO,OAAO,GAAA,KAAQ,QAAA,GAAW,GAAA,GAAM,MAAA;AAAA,EACzC;AACA,EAAA,OAAO,MAAA;AACT;AAEA,SAAS,wBAAwB,MAAA,EAA4D;AAG3F,EAAA,MAAM,EAAE,MAAM,IAAA,EAAM,QAAA,EAAU,MAAK,GAAI,MAAA,EAAQ,gBAAA,IAAoB,MAAA,IAAU,EAAC;AAC9E,EAAA,MAAM,aAAa,OAAO,IAAA,KAAS,WAAW,QAAA,CAAS,IAAA,EAAM,EAAE,CAAA,GAAI,IAAA;AACnE,EAAA,MAAM,eAAe,OAAO,UAAA,KAAe,QAAA,IAAY,CAAC,MAAM,UAAU,CAAA;AAExE,EAAA,OAAO;AAAA;AAAA,IAEL,CAAC,OAAO,GAAG,QAAA,IAAY,MAAA;AAAA,IACvB,CAAC,OAAO,GAAG,IAAA,IAAQ,MAAA;AAAA;AAAA,IAEnB,CAAC,aAAa,GAAG,IAAA,IAAQ,MAAA;AAAA;AAAA,IAEzB,CAAC,aAAa,GAAG,YAAA,GAAe,UAAA,GAAa;AAAA,GAC/C;AACF;AAEA,MAAM,6BAA6B,MAAM;AACvC,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,SAAA,GAAY;AAEV,MAAA,IAAI,CAAC,mBAAmB,cAAA,EAAgB;AACtC,QAAA;AAAA,MACF;AAEA,MAAA,4BAAA,CAA6B,MAAM;AACjC,QAAA,gBAAA,EAAiB;AAAA,MACnB,CAAC,CAAA;AAAA,IACH;AAAA,GACF;AACF,CAAA,CAAA;AAaO,MAAM,wBAAA,GAA2B,kBAAkB,yBAAyB;;;;"}

package/build/esm/integrations/tracing-channel/openai.js

@@ -0,0 +1,79 @@
+import * as diagnosticsChannel from 'node:diagnostics_channel';
+import { defineIntegration, waitForTracingChannelBinding, debug, addOpenAiResponseAttributes, resolveAIRecordingOptions, instrumentOpenAiStream, _INTERNAL_shouldSkipAiProviderWrapping, shouldEnableTruncation, extractOpenAiRequestAttributes, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, startInactiveSpan, addOpenAiRequestAttributes } from '@sentry/core';
+import { DEBUG_BUILD } from '../../debug-build.js';
+import { CHANNELS } from '../../orchestrion/channels.js';
+import { bindTracingChannelToSpan } from '../../tracing-channel.js';
+
+const INTEGRATION_NAME = "OpenAI";
+const ORIGIN = "auto.ai.orchestrion.openai";
+const INSTRUMENTED_CHANNELS = [
+  { channel: CHANNELS.OPENAI_CHAT, operation: "chat" },
+  { channel: CHANNELS.OPENAI_EMBEDDINGS, operation: "embeddings" }
+];
+let subscribed = false;
+const _openaiChannelIntegration = ((options = {}) => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      if (!diagnosticsChannel.tracingChannel || subscribed) {
+        return;
+      }
+      subscribed = true;
+      waitForTracingChannelBinding(() => {
+        for (const { channel, operation } of INSTRUMENTED_CHANNELS) {
+          DEBUG_BUILD && debug.log(`[orchestrion:openai] subscribing to channel "${channel}"`);
+          bindTracingChannelToSpan(
+            diagnosticsChannel.tracingChannel(channel),
+            (data) => createGenAiSpan(data, operation, options),
+            {
+              beforeSpanEnd: (span, data) => {
+                addOpenAiResponseAttributes(span, data.result, resolveAIRecordingOptions(options).recordOutputs);
+              },
+              // Streaming: the result is a `Stream` consumed later, so instrument it and let it end the span.
+              deferSpanEnd: ({ span, data }) => wrapStreamResult(span, data, options)
+            }
+          );
+        }
+      });
+    }
+  };
+});
+function createGenAiSpan(data, operation, options) {
+  if (_INTERNAL_shouldSkipAiProviderWrapping(INTEGRATION_NAME)) {
+    return void 0;
+  }
+  const args = data.arguments ?? [];
+  const params = args[0];
+  const { recordInputs } = resolveAIRecordingOptions(options);
+  const enableTruncation = shouldEnableTruncation(options.enableTruncation);
+  const attributes = extractOpenAiRequestAttributes(args, operation);
+  attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] = ORIGIN;
+  const model = params?.model || "unknown";
+  const span = startInactiveSpan({
+    name: `${operation} ${model}`,
+    op: `gen_ai.${operation}`,
+    attributes
+  });
+  if (recordInputs && params) {
+    addOpenAiRequestAttributes(span, params, operation, enableTruncation);
+  }
+  return span;
+}
+function isAsyncIterable(value) {
+  return !!value && typeof value[Symbol.asyncIterator] === "function";
+}
+function wrapStreamResult(span, data, options) {
+  const result = data.result;
+  if (!isAsyncIterable(result)) {
+    return false;
+  }
+  const { recordOutputs } = resolveAIRecordingOptions(options);
+  const iterate = result[Symbol.asyncIterator].bind(result);
+  const instrumented = instrumentOpenAiStream({ [Symbol.asyncIterator]: iterate }, span, recordOutputs ?? false);
+  result[Symbol.asyncIterator] = () => instrumented;
+  return true;
+}
+const openaiChannelIntegration = defineIntegration(_openaiChannelIntegration);
+
+export { openaiChannelIntegration };
+//# sourceMappingURL=openai.js.map

package/build/esm/integrations/tracing-channel/openai.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.js","sources":["../../../../src/integrations/tracing-channel/openai.ts"],"sourcesContent":["import * as diagnosticsChannel from 'node:diagnostics_channel';\nimport type { IntegrationFn, OpenAiOptions, Span, SpanAttributeValue } from '@sentry/core';\nimport {\n  _INTERNAL_shouldSkipAiProviderWrapping,\n  addOpenAiRequestAttributes,\n  addOpenAiResponseAttributes,\n  debug,\n  defineIntegration,\n  extractOpenAiRequestAttributes,\n  instrumentOpenAiStream,\n  resolveAIRecordingOptions,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  shouldEnableTruncation,\n  startInactiveSpan,\n  waitForTracingChannelBinding,\n} from '@sentry/core';\nimport { DEBUG_BUILD } from '../../debug-build';\nimport { CHANNELS } from '../../orchestrion/channels';\nimport { bindTracingChannelToSpan } from '../../tracing-channel';\n\n// Same name as the OTel integration by design: when enabled, the OTel 'OpenAI'\n// integration is dropped from the default set (see the Node opt-in loader).\nconst INTEGRATION_NAME = 'OpenAI' as const;\n\n// Distinct from the proxy's `auto.ai.openai` so spans from the orchestrion path\n// are attributable separately from the OTel/proxy one.\nconst ORIGIN = 'auto.ai.orchestrion.openai';\n\n// Each instrumented `create` method maps to the gen_ai operation its span reports.\nconst INSTRUMENTED_CHANNELS = [\n  { channel: CHANNELS.OPENAI_CHAT, operation: 'chat' },\n  { channel: CHANNELS.OPENAI_EMBEDDINGS, operation: 'embeddings' },\n] as const;\n\n/**\n * The context object orchestrion shares across the tracing-channel lifecycle hooks: `arguments` is the\n * live args array passed to `Completions.create(body, options)`, and Node's `tracingChannel` attaches\n * `result` when the returned promise settles.\n */\ninterface OpenAiChatChannelContext {\n  arguments: unknown[];\n  result?: unknown;\n}\n\nlet subscribed = false;\n\nconst _openaiChannelIntegration = ((options: OpenAiOptions = {}) => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      // `tracingChannel` is unavailable before Node 18.19, and a second `init()` would double-subscribe.\n      if (!diagnosticsChannel.tracingChannel || subscribed) {\n        return;\n      }\n      subscribed = true;\n\n      // `bindTracingChannelToSpan` needs the async-context binding that `initOpenTelemetry()` registers\n      // after `setupOnce` runs, so wait for it before subscribing.\n      waitForTracingChannelBinding(() => {\n        for (const { channel, operation } of INSTRUMENTED_CHANNELS) {\n          DEBUG_BUILD && debug.log(`[orchestrion:openai] subscribing to channel \"${channel}\"`);\n          bindTracingChannelToSpan(\n            diagnosticsChannel.tracingChannel<OpenAiChatChannelContext>(channel),\n            data => createGenAiSpan(data, operation, options),\n            {\n              beforeSpanEnd: (span, data) => {\n                addOpenAiResponseAttributes(span, data.result, resolveAIRecordingOptions(options).recordOutputs);\n              },\n              // Streaming: the result is a `Stream` consumed later, so instrument it and let it end the span.\n              deferSpanEnd: ({ span, data }) => wrapStreamResult(span, data, options),\n            },\n          );\n        }\n      });\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Build the span for an instrumented `create` call.\n * Returning `undefined` opts the payload out so no span is opened.\n */\nfunction createGenAiSpan(data: OpenAiChatChannelContext, operation: string, options: OpenAiOptions): Span | undefined {\n  // When another provider (e.g. LangChain) is driving the SDK, it records the spans itself and marks this\n  // provider as skipped; skip here to avoid double spans.\n  if (_INTERNAL_shouldSkipAiProviderWrapping(INTEGRATION_NAME)) {\n    return undefined;\n  }\n\n  const args = data.arguments ?? [];\n  const params = args[0] as Record<string, unknown> | undefined;\n\n  const { recordInputs } = resolveAIRecordingOptions(options);\n  const enableTruncation = shouldEnableTruncation(options.enableTruncation);\n\n  const attributes = extractOpenAiRequestAttributes(args, operation);\n  attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] = ORIGIN;\n  const model = (params?.model as string) || 'unknown';\n\n  const span = startInactiveSpan({\n    name: `${operation} ${model}`,\n    op: `gen_ai.${operation}`,\n    attributes: attributes as Record<string, SpanAttributeValue>,\n  });\n\n  if (recordInputs && params) {\n    addOpenAiRequestAttributes(span, params, operation, enableTruncation);\n  }\n\n  return span;\n}\n\ntype AsyncIterableStream = { [Symbol.asyncIterator]: () => AsyncIterator<unknown> };\n\nfunction isAsyncIterable(value: unknown): value is AsyncIterableStream {\n  return !!value && typeof (value as AsyncIterableStream)[Symbol.asyncIterator] === 'function';\n}\n\n/**\n * For a streaming `create({ stream: true })` the result is a `Stream` the caller consumes later. We can't\n * swap what `create` returns, but the `Stream` in `data.result` is the same instance the caller holds and\n * `asyncEnd` fires before the caller iterates — so we patch its async iterator in place to run through\n * `instrumentOpenAiStream`, which accumulates the streamed attributes and ends the span when iteration finishes.\n * Only a streaming call resolves to an async-iterable, so that check alone distinguishes it. Returns `true`\n * to hand span-ending ownership to `instrumentOpenAiStream`; `false` for non-streaming/errored results, which end\n * via the normal `beforeSpanEnd` path.\n */\nfunction wrapStreamResult(span: Span, data: OpenAiChatChannelContext, options: OpenAiOptions): boolean {\n  const result = data.result;\n  if (!isAsyncIterable(result)) {\n    return false;\n  }\n\n  const { recordOutputs } = resolveAIRecordingOptions(options);\n  const iterate = result[Symbol.asyncIterator].bind(result);\n  const instrumented = instrumentOpenAiStream({ [Symbol.asyncIterator]: iterate }, span, recordOutputs ?? false);\n  result[Symbol.asyncIterator] = () => instrumented;\n\n  return true;\n}\n\n/**\n * EXPERIMENTAL — orchestrion-driven OpenAI integration. Subscribes to the `orchestrion:openai:*`\n * diagnostics_channels injected into `openai`'s `create` methods (chat completions, responses, embeddings,\n * conversations), so it requires the orchestrion runtime hook or bundler plugin.\n */\nexport const openaiChannelIntegration = defineIntegration(_openaiChannelIntegration);\n"],"names":[],"mappings":";;;;;;AAsBA,MAAM,gBAAA,GAAmB,QAAA;AAIzB,MAAM,MAAA,GAAS,4BAAA;AAGf,MAAM,qBAAA,GAAwB;AAAA,EAC5B,EAAE,OAAA,EAAS,QAAA,CAAS,WAAA,EAAa,WAAW,MAAA,EAAO;AAAA,EACnD,EAAE,OAAA,EAAS,QAAA,CAAS,iBAAA,EAAmB,WAAW,YAAA;AACpD,CAAA;AAYA,IAAI,UAAA,GAAa,KAAA;AAEjB,MAAM,yBAAA,IAA6B,CAAC,OAAA,GAAyB,EAAC,KAAM;AAClE,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,SAAA,GAAY;AAEV,MAAA,IAAI,CAAC,kBAAA,CAAmB,cAAA,IAAkB,UAAA,EAAY;AACpD,QAAA;AAAA,MACF;AACA,MAAA,UAAA,GAAa,IAAA;AAIb,MAAA,4BAAA,CAA6B,MAAM;AACjC,QAAA,KAAA,MAAW,EAAE,OAAA,EAAS,SAAA,EAAU,IAAK,qBAAA,EAAuB;AAC1D,UAAA,WAAA,IAAe,KAAA,CAAM,GAAA,CAAI,CAAA,6CAAA,EAAgD,OAAO,CAAA,CAAA,CAAG,CAAA;AACnF,UAAA,wBAAA;AAAA,YACE,kBAAA,CAAmB,eAAyC,OAAO,CAAA;AAAA,YACnE,CAAA,IAAA,KAAQ,eAAA,CAAgB,IAAA,EAAM,SAAA,EAAW,OAAO,CAAA;AAAA,YAChD;AAAA,cACE,aAAA,EAAe,CAAC,IAAA,EAAM,IAAA,KAAS;AAC7B,gBAAA,2BAAA,CAA4B,MAAM,IAAA,CAAK,MAAA,EAAQ,yBAAA,CAA0B,OAAO,EAAE,aAAa,CAAA;AAAA,cACjG,CAAA;AAAA;AAAA,cAEA,YAAA,EAAc,CAAC,EAAE,IAAA,EAAM,MAAK,KAAM,gBAAA,CAAiB,IAAA,EAAM,IAAA,EAAM,OAAO;AAAA;AACxE,WACF;AAAA,QACF;AAAA,MACF,CAAC,CAAA;AAAA,IACH;AAAA,GACF;AACF,CAAA,CAAA;AAMA,SAAS,eAAA,CAAgB,IAAA,EAAgC,SAAA,EAAmB,OAAA,EAA0C;AAGpH,EAAA,IAAI,sCAAA,CAAuC,gBAAgB,CAAA,EAAG;AAC5D,IAAA,OAAO,MAAA;AAAA,EACT;AAEA,EAAA,MAAM,IAAA,GAAO,IAAA,CAAK,SAAA,IAAa,EAAC;AAChC,EAAA,MAAM,MAAA,GAAS,KAAK,CAAC,CAAA;AAErB,EAAA,MAAM,EAAE,YAAA,EAAa,GAAI,yBAAA,CAA0B,OAAO,CAAA;AAC1D,EAAA,MAAM,gBAAA,GAAmB,sBAAA,CAAuB,OAAA,CAAQ,gBAAgB,CAAA;AAExE,EAAA,MAAM,UAAA,GAAa,8BAAA,CAA+B,IAAA,EAAM,SAAS,CAAA;AACjE,EAAA,UAAA,CAAW,gCAAgC,CAAA,GAAI,MAAA;AAC/C,EAAA,MAAM,KAAA,GAAS,QAAQ,KAAA,IAAoB,SAAA;AAE3C,EAAA,MAAM,OAAO,iBAAA,CAAkB;AAAA,IAC7B,IAAA,EAAM,CAAA,EAAG,SAAS,CAAA,CAAA,EAAI,KAAK,CAAA,CAAA;AAAA,IAC3B,EAAA,EAAI,UAAU,SAAS,CAAA,CAAA;AAAA,IACvB;AAAA,GACD,CAAA;AAED,EAAA,IAAI,gBAAgB,MAAA,EAAQ;AAC1B,IAAA,0BAAA,CAA2B,IAAA,EAAM,MAAA,EAAQ,SAAA,EAAW,gBAAgB,CAAA;AAAA,EACtE;AAEA,EAAA,OAAO,IAAA;AACT;AAIA,SAAS,gBAAgB,KAAA,EAA8C;AACrE,EAAA,OAAO,CAAC,CAAC,KAAA,IAAS,OAAQ,KAAA,CAA8B,MAAA,CAAO,aAAa,CAAA,KAAM,UAAA;AACpF;AAWA,SAAS,gBAAA,CAAiB,IAAA,EAAY,IAAA,EAAgC,OAAA,EAAiC;AACrG,EAAA,MAAM,SAAS,IAAA,CAAK,MAAA;AACpB,EAAA,IAAI,CAAC,eAAA,CAAgB,MAAM,CAAA,EAAG;AAC5B,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,MAAM,EAAE,aAAA,EAAc,GAAI,yBAAA,CAA0B,OAAO,CAAA;AAC3D,EAAA,MAAM,UAAU,MAAA,CAAO,MAAA,CAAO,aAAa,CAAA,CAAE,KAAK,MAAM,CAAA;AACxD,EAAA,MAAM,YAAA,GAAe,sBAAA,CAAuB,EAAE,CAAC,MAAA,CAAO,aAAa,GAAG,OAAA,EAAQ,EAAG,IAAA,EAAM,aAAA,IAAiB,KAAK,CAAA;AAC7G,EAAA,MAAA,CAAO,MAAA,CAAO,aAAa,CAAA,GAAI,MAAM,YAAA;AAErC,EAAA,OAAO,IAAA;AACT;AAOO,MAAM,wBAAA,GAA2B,kBAAkB,yBAAyB;;;;"}

package/build/esm/integrations/tracing-channel/postgres-js.js

@@ -0,0 +1,189 @@
+import * as diagnosticsChannel from 'node:diagnostics_channel';
+import { DB_QUERY_TEXT, DB_SYSTEM_NAME, ERROR_TYPE } from '@sentry/conventions/attributes';
+import { defineIntegration, debug, waitForTracingChannelBinding, _INTERNAL_reconstructPostgresQuery, _INTERNAL_sanitizeSqlQuery, startInactiveSpan, SPAN_KIND, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, _INTERNAL_buildPostgresConnectionContext, _INTERNAL_setPostgresOperationName, SPAN_STATUS_ERROR, _INTERNAL_setPostgresConnectionAttributes } from '@sentry/core';
+import { DEBUG_BUILD } from '../../debug-build.js';
+import { CHANNELS } from '../../orchestrion/channels.js';
+import { bindTracingChannelToSpan } from '../../tracing-channel.js';
+
+const INTEGRATION_NAME = "PostgresJs";
+const ORIGIN = "auto.db.orchestrion.postgresjs";
+const DB_RESPONSE_STATUS_CODE = "db.response.status_code";
+const NOOP = () => {
+};
+const QUERY_FROM_INSTRUMENTED_SQL = /* @__PURE__ */ Symbol.for("sentry.query.from.instrumented.sql");
+const QUERY_SPAN = /* @__PURE__ */ Symbol("sentryPostgresJsSpan");
+const CONNECTION_ATTRS_SET = /* @__PURE__ */ Symbol("sentryPostgresJsConnectionAttrsSet");
+const SPAN_ENDED = /* @__PURE__ */ Symbol("sentryPostgresJsSpanEnded");
+const connectionContexts = /* @__PURE__ */ new WeakMap();
+const endpointRegistry = [];
+function registerEndpoint(context) {
+  const alreadyKnown = endpointRegistry.some(
+    (e) => e.ATTR_SERVER_ADDRESS === context.ATTR_SERVER_ADDRESS && e.ATTR_SERVER_PORT === context.ATTR_SERVER_PORT && e.ATTR_DB_NAMESPACE === context.ATTR_DB_NAMESPACE
+  );
+  if (!alreadyKnown) {
+    endpointRegistry.push(context);
+  }
+}
+function resolveSingleEndpoint() {
+  return endpointRegistry.length === 1 ? endpointRegistry[0] : void 0;
+}
+function recordConnectionFromChannel(message) {
+  const connection = message.result;
+  const options = message.arguments?.[0];
+  if (!connection || typeof connection !== "object" || !options) {
+    return;
+  }
+  const context = _INTERNAL_buildPostgresConnectionContext(options);
+  connectionContexts.set(connection, context);
+  registerEndpoint(context);
+}
+function setConnectionAttributes(span, query, context) {
+  const queryRecord = query;
+  if (queryRecord[CONNECTION_ATTRS_SET]) {
+    return;
+  }
+  queryRecord[CONNECTION_ATTRS_SET] = true;
+  _INTERNAL_setPostgresConnectionAttributes(span, context);
+}
+function attachConnectionAttributesFromChannel(message) {
+  const connection = message.self;
+  const query = message.arguments?.[0];
+  if (!connection || !query) {
+    return;
+  }
+  const span = query[QUERY_SPAN];
+  const context = connectionContexts.get(connection);
+  if (span && context) {
+    setConnectionAttributes(span, query, context);
+  }
+}
+function wrapQuerySettlement(data, span, sanitizedSqlQuery) {
+  const query = data.self;
+  if (!query) {
+    return;
+  }
+  const markEnded = () => {
+    data[SPAN_ENDED] = true;
+  };
+  const originalResolve = query.resolve;
+  if (typeof originalResolve === "function") {
+    query.resolve = function(...resolveArgs) {
+      markEnded();
+      try {
+        const command = resolveArgs[0]?.command;
+        _INTERNAL_setPostgresOperationName(span, sanitizedSqlQuery, command);
+        span.end();
+      } catch (e) {
+        DEBUG_BUILD && debug.error("[orchestrion:postgresjs] error ending span in resolve:", e);
+      }
+      return originalResolve.apply(this, resolveArgs);
+    };
+  }
+  const originalReject = query.reject;
+  if (typeof originalReject === "function") {
+    query.reject = function(...rejectArgs) {
+      markEnded();
+      try {
+        const err = rejectArgs[0];
+        span.setStatus({ code: SPAN_STATUS_ERROR, message: err?.message || "unknown_error" });
+        span.setAttribute(DB_RESPONSE_STATUS_CODE, err?.code || "unknown");
+        span.setAttribute(ERROR_TYPE, err?.name || "unknown");
+        _INTERNAL_setPostgresOperationName(span, sanitizedSqlQuery);
+        span.end();
+      } catch (e) {
+        DEBUG_BUILD && debug.error("[orchestrion:postgresjs] error ending span in reject:", e);
+      }
+      return originalReject.apply(this, rejectArgs);
+    };
+  }
+}
+const _postgresJsChannelIntegration = ((options = {}) => {
+  const { requireParentSpan, requestHook } = options;
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      if (!diagnosticsChannel.tracingChannel) {
+        return;
+      }
+      DEBUG_BUILD && debug.log(`[orchestrion:postgresjs] subscribing to "${CHANNELS.POSTGRESJS_HANDLE}"`);
+      diagnosticsChannel.tracingChannel(CHANNELS.POSTGRESJS_CONNECTION).subscribe({
+        start: NOOP,
+        asyncStart: NOOP,
+        asyncEnd: NOOP,
+        error: NOOP,
+        end: recordConnectionFromChannel
+      });
+      diagnosticsChannel.tracingChannel(CHANNELS.POSTGRESJS_EXECUTE).subscribe({
+        end: NOOP,
+        asyncStart: NOOP,
+        asyncEnd: NOOP,
+        error: NOOP,
+        start: attachConnectionAttributesFromChannel
+      });
+      diagnosticsChannel.tracingChannel(CHANNELS.POSTGRESJS_CONNECT).subscribe({
+        end: NOOP,
+        asyncStart: NOOP,
+        asyncEnd: NOOP,
+        error: NOOP,
+        start: attachConnectionAttributesFromChannel
+      });
+      waitForTracingChannelBinding(() => {
+        bindTracingChannelToSpan(
+          diagnosticsChannel.tracingChannel(CHANNELS.POSTGRESJS_HANDLE),
+          (data) => {
+            const query = data.self;
+            if (!query) {
+              return void 0;
+            }
+            if (query.executed === true || query[QUERY_FROM_INSTRUMENTED_SQL]) {
+              return void 0;
+            }
+            const fullQuery = _INTERNAL_reconstructPostgresQuery(query.strings);
+            const sanitizedSqlQuery = _INTERNAL_sanitizeSqlQuery(fullQuery);
+            const span = startInactiveSpan({
+              name: sanitizedSqlQuery || "postgresjs.query",
+              op: "db",
+              kind: SPAN_KIND.CLIENT,
+              attributes: {
+                [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN,
+                [DB_SYSTEM_NAME]: "postgres",
+                [DB_QUERY_TEXT]: sanitizedSqlQuery
+              }
+            });
+            query[QUERY_SPAN] = span;
+            const context = resolveSingleEndpoint();
+            if (context) {
+              setConnectionAttributes(span, query, context);
+            }
+            if (requestHook) {
+              try {
+                requestHook(span, sanitizedSqlQuery, context);
+              } catch (e) {
+                span.setAttribute("sentry.hook.error", "requestHook failed");
+                DEBUG_BUILD && debug.error("[orchestrion:postgresjs] error in requestHook:", e);
+              }
+            }
+            wrapQuerySettlement(data, span, sanitizedSqlQuery);
+            return span;
+          },
+          {
+            requiresParentSpan: requireParentSpan !== false,
+            deferSpanEnd({ data }) {
+              if (data[SPAN_ENDED]) {
+                return true;
+              }
+              if ("error" in data) {
+                return false;
+              }
+              return true;
+            }
+          }
+        );
+      });
+    }
+  };
+});
+const postgresJsChannelIntegration = defineIntegration(_postgresJsChannelIntegration);
+
+export { postgresJsChannelIntegration };
+//# sourceMappingURL=postgres-js.js.map

package/build/esm/integrations/tracing-channel/postgres-js.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-js.js","sources":["../../../../src/integrations/tracing-channel/postgres-js.ts"],"sourcesContent":["import * as diagnosticsChannel from 'node:diagnostics_channel';\nimport { DB_QUERY_TEXT, DB_SYSTEM_NAME, ERROR_TYPE } from '@sentry/conventions/attributes';\nimport type { IntegrationFn, PostgresConnectionContext, Span } from '@sentry/core';\nimport {\n  _INTERNAL_buildPostgresConnectionContext,\n  _INTERNAL_reconstructPostgresQuery,\n  _INTERNAL_sanitizeSqlQuery,\n  _INTERNAL_setPostgresConnectionAttributes,\n  _INTERNAL_setPostgresOperationName,\n  debug,\n  defineIntegration,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  SPAN_KIND,\n  SPAN_STATUS_ERROR,\n  startInactiveSpan,\n  waitForTracingChannelBinding,\n} from '@sentry/core';\nimport { DEBUG_BUILD } from '../../debug-build';\nimport { CHANNELS } from '../../orchestrion/channels';\nimport { bindTracingChannelToSpan } from '../../tracing-channel';\n\n// Same name as the OTel `PostgresJs` integration by design: when this is\n// enabled, the OTel integration of the same name is dropped from the default\n// set (see `experimentalUseDiagnosticsChannelInjection`).\nconst INTEGRATION_NAME = 'PostgresJs' as const;\n\nconst ORIGIN = 'auto.db.orchestrion.postgresjs';\n\n// Not part of `@sentry/conventions`, so we keep it inline (matches the OTel `PostgresJsInstrumentation`).\nconst DB_RESPONSE_STATUS_CODE = 'db.response.status_code';\n\nconst NOOP = (): void => {};\n\n// Same `Symbol.for()` marker the core `instrumentPostgresJsSql` wrapper sets on\n// queries it manually instruments, so we skip them there and never double-span.\nconst QUERY_FROM_INSTRUMENTED_SQL = Symbol.for('sentry.query.from.instrumented.sql');\n// The query span, stashed on the `Query` so the `execute`/`connect` channels can\n// attach connection attributes to it.\nconst QUERY_SPAN = Symbol('sentryPostgresJsSpan');\n// Set once connection attributes are on the span, so the fallback and the\n// `execute`/`connect` channels don't both write them.\nconst CONNECTION_ATTRS_SET = Symbol('sentryPostgresJsConnectionAttrsSet');\n// Set on the channel context once the resolve/reject wrappers have ended the\n// span, so `deferSpanEnd` knows the wrappers own the lifecycle.\nconst SPAN_ENDED = Symbol('sentryPostgresJsSpanEnded');\n\nexport interface PostgresJsChannelIntegrationOptions {\n  /**\n   * Only create spans when there's already an active parent span. Defaults to\n   * `true`, matching the OTel `postgresJsIntegration`.\n   */\n  requireParentSpan?: boolean;\n  /**\n   * Hook to modify the query span before the query runs. Receives the span, the\n   * sanitized SQL, and (when resolvable) the connection context.\n   */\n  requestHook?: (span: Span, sanitizedSqlQuery: string, postgresConnectionContext?: PostgresConnectionContext) => void;\n}\n\n/** The `Query` instance postgres.js passes as `self` to `Query.prototype.handle`. */\ninterface PostgresQuery {\n  strings?: string[];\n  executed?: boolean;\n  resolve?: (...args: unknown[]) => unknown;\n  reject?: (...args: unknown[]) => unknown;\n}\n\ninterface PostgresJsQueryContext {\n  arguments?: unknown[];\n  self?: PostgresQuery;\n  result?: unknown;\n  error?: unknown;\n}\n\n// A connection object -> its resolved context, populated on the `connection`\n// channel and read on the `execute`/`connect` channels (keyed by the same object).\nconst connectionContexts = new WeakMap<object, PostgresConnectionContext>();\n// Distinct endpoints seen so far (value-compared, so N connections to one DB\n// count once). When exactly one endpoint exists — the common case, and the only\n// one the tests exercise — every query resolves to it at handle-start.\nconst endpointRegistry: PostgresConnectionContext[] = [];\n\nfunction registerEndpoint(context: PostgresConnectionContext): void {\n  const alreadyKnown = endpointRegistry.some(\n    e =>\n      e.ATTR_SERVER_ADDRESS === context.ATTR_SERVER_ADDRESS &&\n      e.ATTR_SERVER_PORT === context.ATTR_SERVER_PORT &&\n      e.ATTR_DB_NAMESPACE === context.ATTR_DB_NAMESPACE,\n  );\n  if (!alreadyKnown) {\n    endpointRegistry.push(context);\n  }\n}\n\n/** The single known endpoint, or `undefined` when zero or multiple are known. */\nfunction resolveSingleEndpoint(): PostgresConnectionContext | undefined {\n  return endpointRegistry.length === 1 ? endpointRegistry[0] : undefined;\n}\n\n/**\n * Record a connection from the `connection` channel `end` (`result` is the\n * connection object, `arguments[0]` the parsed options), keying its resolved\n * context by the connection object and tracking its endpoint.\n */\nfunction recordConnectionFromChannel(message: PostgresJsQueryContext): void {\n  const connection = message.result;\n  const options = message.arguments?.[0] as { host?: string[]; port?: number[]; database?: string } | undefined;\n  if (!connection || typeof connection !== 'object' || !options) {\n    return;\n  }\n  const context = _INTERNAL_buildPostgresConnectionContext(options);\n  connectionContexts.set(connection, context);\n  registerEndpoint(context);\n}\n\nfunction setConnectionAttributes(span: Span, query: PostgresQuery, context: PostgresConnectionContext): void {\n  const queryRecord = query as Record<symbol, unknown>;\n  if (queryRecord[CONNECTION_ATTRS_SET]) {\n    return;\n  }\n  queryRecord[CONNECTION_ATTRS_SET] = true;\n  _INTERNAL_setPostgresConnectionAttributes(span, context);\n}\n\n/**\n * Backfill connection attributes onto a query's span from a channel whose `self`\n * is the connection object and `arguments[0]` the query. Shared by the `execute`\n * and `connect` channels; both carry that shape and both resolve the context via\n * the `connectionContexts` WeakMap. Idempotent (guarded inside `setConnectionAttributes`).\n */\nfunction attachConnectionAttributesFromChannel(message: PostgresJsQueryContext): void {\n  const connection = message.self as object | undefined;\n  const query = message.arguments?.[0] as PostgresQuery | undefined;\n  if (!connection || !query) {\n    return;\n  }\n  const span = (query as Record<symbol, unknown>)[QUERY_SPAN] as Span | undefined;\n  const context = connectionContexts.get(connection);\n  if (span && context) {\n    setConnectionAttributes(span, query, context);\n  }\n}\n\n/**\n * Wrap `query.resolve`/`query.reject` so the span ends when the query settles.\n *\n * `Query extends Promise` and `async handle()` only dispatches — its promise\n * resolves immediately, long before the query completes. postgres.js signals\n * completion by calling `this.resolve`/`this.reject`, so we own the span end\n * there. Wrapping happens at handle-start because `reject` can fire\n * synchronously during dispatch and `cursor()` reassigns both before executing.\n */\nfunction wrapQuerySettlement(data: PostgresJsQueryContext, span: Span, sanitizedSqlQuery: string): void {\n  const query = data.self;\n  if (!query) {\n    return;\n  }\n\n  // Claim ownership of ending the span up front, so `deferSpanEnd` defers to the\n  // wrapper even if `span.end()` below throws.\n  const markEnded = (): void => {\n    (data as Record<symbol, unknown>)[SPAN_ENDED] = true;\n  };\n\n  const originalResolve = query.resolve;\n  if (typeof originalResolve === 'function') {\n    query.resolve = function (this: unknown, ...resolveArgs: unknown[]): unknown {\n      markEnded();\n      try {\n        const command = (resolveArgs[0] as { command?: string } | undefined)?.command;\n        _INTERNAL_setPostgresOperationName(span, sanitizedSqlQuery, command);\n        span.end();\n      } catch (e) {\n        DEBUG_BUILD && debug.error('[orchestrion:postgresjs] error ending span in resolve:', e);\n      }\n      return originalResolve.apply(this, resolveArgs);\n    };\n  }\n\n  const originalReject = query.reject;\n  if (typeof originalReject === 'function') {\n    query.reject = function (this: unknown, ...rejectArgs: unknown[]): unknown {\n      markEnded();\n      try {\n        const err = rejectArgs[0] as { message?: string; code?: string; name?: string } | undefined;\n        span.setStatus({ code: SPAN_STATUS_ERROR, message: err?.message || 'unknown_error' });\n        span.setAttribute(DB_RESPONSE_STATUS_CODE, err?.code || 'unknown');\n        span.setAttribute(ERROR_TYPE, err?.name || 'unknown');\n        _INTERNAL_setPostgresOperationName(span, sanitizedSqlQuery);\n        span.end();\n      } catch (e) {\n        DEBUG_BUILD && debug.error('[orchestrion:postgresjs] error ending span in reject:', e);\n      }\n      return originalReject.apply(this, rejectArgs);\n    };\n  }\n}\n\nconst _postgresJsChannelIntegration = ((options: PostgresJsChannelIntegrationOptions = {}) => {\n  const { requireParentSpan, requestHook } = options;\n\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      // `tracingChannel` is unavailable before Node 18.19.\n      if (!diagnosticsChannel.tracingChannel) {\n        return;\n      }\n\n      DEBUG_BUILD && debug.log(`[orchestrion:postgresjs] subscribing to \"${CHANNELS.POSTGRESJS_HANDLE}\"`);\n\n      // Connection + execute are pure observers (no span, no async binding), so\n      // subscribe immediately — factory-time `Connection()` calls happen before\n      // `waitForTracingChannelBinding` resolves and must still be recorded.\n      diagnosticsChannel.tracingChannel<PostgresJsQueryContext>(CHANNELS.POSTGRESJS_CONNECTION).subscribe({\n        start: NOOP,\n        asyncStart: NOOP,\n        asyncEnd: NOOP,\n        error: NOOP,\n        end: recordConnectionFromChannel,\n      });\n\n      // Per-connection attributes for queries reusing an already-open connection\n      // (`c.execute(q)`, `self === c`). `execute` is also called bare\n      // (`self === undefined`) for the first query on each connection, `fetchState`\n      // and `retry`; those miss here (the `connect` channel below covers the first\n      // user query, and the single-endpoint fallback covers the common case).\n      diagnosticsChannel.tracingChannel<PostgresJsQueryContext>(CHANNELS.POSTGRESJS_EXECUTE).subscribe({\n        end: NOOP,\n        asyncStart: NOOP,\n        asyncEnd: NOOP,\n        error: NOOP,\n        start: attachConnectionAttributesFromChannel,\n      });\n\n      // The connection's `connect(query)` method (`self === c`, `arguments[0]` the\n      // query) fires when a fresh connection is opened for a query. That first query\n      // is later dispatched via a bare `execute` (no `self`), so this is where it\n      // gets its connection attributes in multi-endpoint apps.\n      diagnosticsChannel.tracingChannel<PostgresJsQueryContext>(CHANNELS.POSTGRESJS_CONNECT).subscribe({\n        end: NOOP,\n        asyncStart: NOOP,\n        asyncEnd: NOOP,\n        error: NOOP,\n        start: attachConnectionAttributesFromChannel,\n      });\n\n      // The span-creating `handle` subscription needs the async-context binding\n      // that `initOpenTelemetry()` registers after integration setup.\n      waitForTracingChannelBinding(() => {\n        bindTracingChannelToSpan<PostgresJsQueryContext>(\n          diagnosticsChannel.tracingChannel<PostgresJsQueryContext>(CHANNELS.POSTGRESJS_HANDLE),\n          data => {\n            const query = data.self;\n            if (!query) {\n              return undefined;\n            }\n\n            // Opt out of re-entrant `handle()` calls (then/catch/finally re-invoke it, guarded by\n            // `executed`) and queries already wrapped by the portable `instrumentPostgresJsSql`. The\n            // parent-span requirement is applied via `requiresParentSpan` below.\n            if (query.executed === true || (query as Record<symbol, unknown>)[QUERY_FROM_INSTRUMENTED_SQL]) {\n              return undefined;\n            }\n\n            const fullQuery = _INTERNAL_reconstructPostgresQuery(query.strings);\n            const sanitizedSqlQuery = _INTERNAL_sanitizeSqlQuery(fullQuery);\n\n            // `kind: CLIENT` matches the mysql/pg channel subscribers.\n            const span = startInactiveSpan({\n              name: sanitizedSqlQuery || 'postgresjs.query',\n              op: 'db',\n              kind: SPAN_KIND.CLIENT,\n              attributes: {\n                [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN,\n                [DB_SYSTEM_NAME]: 'postgres',\n                [DB_QUERY_TEXT]: sanitizedSqlQuery,\n              },\n            });\n\n            // Stash for the `execute`/`connect` channels to attach per-connection attributes.\n            (query as Record<symbol, unknown>)[QUERY_SPAN] = span;\n\n            // Single-endpoint fallback: resolve context now so `requestHook` has it\n            // and the first-query-per-connection (bare `execute`) path still gets attrs.\n            const context = resolveSingleEndpoint();\n            if (context) {\n              setConnectionAttributes(span, query, context);\n            }\n\n            if (requestHook) {\n              try {\n                requestHook(span, sanitizedSqlQuery, context);\n              } catch (e) {\n                span.setAttribute('sentry.hook.error', 'requestHook failed');\n                DEBUG_BUILD && debug.error('[orchestrion:postgresjs] error in requestHook:', e);\n              }\n            }\n\n            wrapQuerySettlement(data, span, sanitizedSqlQuery);\n\n            return span;\n          },\n          {\n            requiresParentSpan: requireParentSpan !== false,\n            deferSpanEnd({ data }) {\n              // `handle` is async: its promise settles on dispatch (asyncEnd), long\n              // before the query does. The resolve/reject wrappers own the ending.\n              if ((data as Record<symbol, unknown>)[SPAN_ENDED]) {\n                return true; // wrappers already ended it\n              }\n              if ('error' in data) {\n                return false; // `handle()` itself threw; the error subscriber annotated the span, let the helper end it\n              }\n              // NOTE: for a cursor consumed as an async iterator, only the first batch\n              // reaches `handle` (the `executed` guard blocks the rest), so the span\n              // ends on the first batch — a pre-existing flaw kept for parity.\n              return true; // query in flight; the wrappers will end the span when it settles\n            },\n          },\n        );\n      });\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * EXPERIMENTAL — orchestrion-driven postgres.js (`postgres` v3.x) integration.\n *\n * Subscribes to the `orchestrion:postgres:handle` / `:connection` / `:execute` /\n * `:connect` diagnostics channels injected into postgres.js' `Query.prototype.handle`\n * and `Connection`/`execute`/`connect` (in `src/*` and `cjs/src/*`) and creates db\n * spans matching the OTel `postgresJsIntegration`. Requires the orchestrion runtime\n * hook or bundler plugin.\n */\nexport const postgresJsChannelIntegration = defineIntegration(_postgresJsChannelIntegration);\n"],"names":[],"mappings":";;;;;;;AAwBA,MAAM,gBAAA,GAAmB,YAAA;AAEzB,MAAM,MAAA,GAAS,gCAAA;AAGf,MAAM,uBAAA,GAA0B,yBAAA;AAEhC,MAAM,OAAO,MAAY;AAAC,CAAA;AAI1B,MAAM,2BAAA,mBAA8B,MAAA,CAAO,GAAA,CAAI,oCAAoC,CAAA;AAGnF,MAAM,UAAA,0BAAoB,sBAAsB,CAAA;AAGhD,MAAM,oBAAA,0BAA8B,oCAAoC,CAAA;AAGxE,MAAM,UAAA,0BAAoB,2BAA2B,CAAA;AAgCrD,MAAM,kBAAA,uBAAyB,OAAA,EAA2C;AAI1E,MAAM,mBAAgD,EAAC;AAEvD,SAAS,iBAAiB,OAAA,EAA0C;AAClE,EAAA,MAAM,eAAe,gBAAA,CAAiB,IAAA;AAAA,IACpC,CAAA,CAAA,KACE,CAAA,CAAE,mBAAA,KAAwB,OAAA,CAAQ,mBAAA,IAClC,CAAA,CAAE,gBAAA,KAAqB,OAAA,CAAQ,gBAAA,IAC/B,CAAA,CAAE,iBAAA,KAAsB,OAAA,CAAQ;AAAA,GACpC;AACA,EAAA,IAAI,CAAC,YAAA,EAAc;AACjB,IAAA,gBAAA,CAAiB,KAAK,OAAO,CAAA;AAAA,EAC/B;AACF;AAGA,SAAS,qBAAA,GAA+D;AACtE,EAAA,OAAO,gBAAA,CAAiB,MAAA,KAAW,CAAA,GAAI,gBAAA,CAAiB,CAAC,CAAA,GAAI,MAAA;AAC/D;AAOA,SAAS,4BAA4B,OAAA,EAAuC;AAC1E,EAAA,MAAM,aAAa,OAAA,CAAQ,MAAA;AAC3B,EAAA,MAAM,OAAA,GAAU,OAAA,CAAQ,SAAA,GAAY,CAAC,CAAA;AACrC,EAAA,IAAI,CAAC,UAAA,IAAc,OAAO,UAAA,KAAe,QAAA,IAAY,CAAC,OAAA,EAAS;AAC7D,IAAA;AAAA,EACF;AACA,EAAA,MAAM,OAAA,GAAU,yCAAyC,OAAO,CAAA;AAChE,EAAA,kBAAA,CAAmB,GAAA,CAAI,YAAY,OAAO,CAAA;AAC1C,EAAA,gBAAA,CAAiB,OAAO,CAAA;AAC1B;AAEA,SAAS,uBAAA,CAAwB,IAAA,EAAY,KAAA,EAAsB,OAAA,EAA0C;AAC3G,EAAA,MAAM,WAAA,GAAc,KAAA;AACpB,EAAA,IAAI,WAAA,CAAY,oBAAoB,CAAA,EAAG;AACrC,IAAA;AAAA,EACF;AACA,EAAA,WAAA,CAAY,oBAAoB,CAAA,GAAI,IAAA;AACpC,EAAA,yCAAA,CAA0C,MAAM,OAAO,CAAA;AACzD;AAQA,SAAS,sCAAsC,OAAA,EAAuC;AACpF,EAAA,MAAM,aAAa,OAAA,CAAQ,IAAA;AAC3B,EAAA,MAAM,KAAA,GAAQ,OAAA,CAAQ,SAAA,GAAY,CAAC,CAAA;AACnC,EAAA,IAAI,CAAC,UAAA,IAAc,CAAC,KAAA,EAAO;AACzB,IAAA;AAAA,EACF;AACA,EAAA,MAAM,IAAA,GAAQ,MAAkC,UAAU,CAAA;AAC1D,EAAA,MAAM,OAAA,GAAU,kBAAA,CAAmB,GAAA,CAAI,UAAU,CAAA;AACjD,EAAA,IAAI,QAAQ,OAAA,EAAS;AACnB,IAAA,uBAAA,CAAwB,IAAA,EAAM,OAAO,OAAO,CAAA;AAAA,EAC9C;AACF;AAWA,SAAS,mBAAA,CAAoB,IAAA,EAA8B,IAAA,EAAY,iBAAA,EAAiC;AACtG,EAAA,MAAM,QAAQ,IAAA,CAAK,IAAA;AACnB,EAAA,IAAI,CAAC,KAAA,EAAO;AACV,IAAA;AAAA,EACF;AAIA,EAAA,MAAM,YAAY,MAAY;AAC5B,IAAC,IAAA,CAAiC,UAAU,CAAA,GAAI,IAAA;AAAA,EAClD,CAAA;AAEA,EAAA,MAAM,kBAAkB,KAAA,CAAM,OAAA;AAC9B,EAAA,IAAI,OAAO,oBAAoB,UAAA,EAAY;AACzC,IAAA,KAAA,CAAM,OAAA,GAAU,YAA4B,WAAA,EAAiC;AAC3E,MAAA,SAAA,EAAU;AACV,MAAA,IAAI;AACF,QAAA,MAAM,OAAA,GAAW,WAAA,CAAY,CAAC,CAAA,EAAwC,OAAA;AACtE,QAAA,kCAAA,CAAmC,IAAA,EAAM,mBAAmB,OAAO,CAAA;AACnE,QAAA,IAAA,CAAK,GAAA,EAAI;AAAA,MACX,SAAS,CAAA,EAAG;AACV,QAAA,WAAA,IAAe,KAAA,CAAM,KAAA,CAAM,wDAAA,EAA0D,CAAC,CAAA;AAAA,MACxF;AACA,MAAA,OAAO,eAAA,CAAgB,KAAA,CAAM,IAAA,EAAM,WAAW,CAAA;AAAA,IAChD,CAAA;AAAA,EACF;AAEA,EAAA,MAAM,iBAAiB,KAAA,CAAM,MAAA;AAC7B,EAAA,IAAI,OAAO,mBAAmB,UAAA,EAAY;AACxC,IAAA,KAAA,CAAM,MAAA,GAAS,YAA4B,UAAA,EAAgC;AACzE,MAAA,SAAA,EAAU;AACV,MAAA,IAAI;AACF,QAAA,MAAM,GAAA,GAAM,WAAW,CAAC,CAAA;AACxB,QAAA,IAAA,CAAK,SAAA,CAAU,EAAE,IAAA,EAAM,iBAAA,EAAmB,SAAS,GAAA,EAAK,OAAA,IAAW,iBAAiB,CAAA;AACpF,QAAA,IAAA,CAAK,YAAA,CAAa,uBAAA,EAAyB,GAAA,EAAK,IAAA,IAAQ,SAAS,CAAA;AACjE,QAAA,IAAA,CAAK,YAAA,CAAa,UAAA,EAAY,GAAA,EAAK,IAAA,IAAQ,SAAS,CAAA;AACpD,QAAA,kCAAA,CAAmC,MAAM,iBAAiB,CAAA;AAC1D,QAAA,IAAA,CAAK,GAAA,EAAI;AAAA,MACX,SAAS,CAAA,EAAG;AACV,QAAA,WAAA,IAAe,KAAA,CAAM,KAAA,CAAM,uDAAA,EAAyD,CAAC,CAAA;AAAA,MACvF;AACA,MAAA,OAAO,cAAA,CAAe,KAAA,CAAM,IAAA,EAAM,UAAU,CAAA;AAAA,IAC9C,CAAA;AAAA,EACF;AACF;AAEA,MAAM,6BAAA,IAAiC,CAAC,OAAA,GAA+C,EAAC,KAAM;AAC5F,EAAA,MAAM,EAAE,iBAAA,EAAmB,WAAA,EAAY,GAAI,OAAA;AAE3C,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,SAAA,GAAY;AAEV,MAAA,IAAI,CAAC,mBAAmB,cAAA,EAAgB;AACtC,QAAA;AAAA,MACF;AAEA,MAAA,WAAA,IAAe,KAAA,CAAM,GAAA,CAAI,CAAA,yCAAA,EAA4C,QAAA,CAAS,iBAAiB,CAAA,CAAA,CAAG,CAAA;AAKlG,MAAA,kBAAA,CAAmB,cAAA,CAAuC,QAAA,CAAS,qBAAqB,CAAA,CAAE,SAAA,CAAU;AAAA,QAClG,KAAA,EAAO,IAAA;AAAA,QACP,UAAA,EAAY,IAAA;AAAA,QACZ,QAAA,EAAU,IAAA;AAAA,QACV,KAAA,EAAO,IAAA;AAAA,QACP,GAAA,EAAK;AAAA,OACN,CAAA;AAOD,MAAA,kBAAA,CAAmB,cAAA,CAAuC,QAAA,CAAS,kBAAkB,CAAA,CAAE,SAAA,CAAU;AAAA,QAC/F,GAAA,EAAK,IAAA;AAAA,QACL,UAAA,EAAY,IAAA;AAAA,QACZ,QAAA,EAAU,IAAA;AAAA,QACV,KAAA,EAAO,IAAA;AAAA,QACP,KAAA,EAAO;AAAA,OACR,CAAA;AAMD,MAAA,kBAAA,CAAmB,cAAA,CAAuC,QAAA,CAAS,kBAAkB,CAAA,CAAE,SAAA,CAAU;AAAA,QAC/F,GAAA,EAAK,IAAA;AAAA,QACL,UAAA,EAAY,IAAA;AAAA,QACZ,QAAA,EAAU,IAAA;AAAA,QACV,KAAA,EAAO,IAAA;AAAA,QACP,KAAA,EAAO;AAAA,OACR,CAAA;AAID,MAAA,4BAAA,CAA6B,MAAM;AACjC,QAAA,wBAAA;AAAA,UACE,kBAAA,CAAmB,cAAA,CAAuC,QAAA,CAAS,iBAAiB,CAAA;AAAA,UACpF,CAAA,IAAA,KAAQ;AACN,YAAA,MAAM,QAAQ,IAAA,CAAK,IAAA;AACnB,YAAA,IAAI,CAAC,KAAA,EAAO;AACV,cAAA,OAAO,MAAA;AAAA,YACT;AAKA,YAAA,IAAI,KAAA,CAAM,QAAA,KAAa,IAAA,IAAS,KAAA,CAAkC,2BAA2B,CAAA,EAAG;AAC9F,cAAA,OAAO,MAAA;AAAA,YACT;AAEA,YAAA,MAAM,SAAA,GAAY,kCAAA,CAAmC,KAAA,CAAM,OAAO,CAAA;AAClE,YAAA,MAAM,iBAAA,GAAoB,2BAA2B,SAAS,CAAA;AAG9D,YAAA,MAAM,OAAO,iBAAA,CAAkB;AAAA,cAC7B,MAAM,iBAAA,IAAqB,kBAAA;AAAA,cAC3B,EAAA,EAAI,IAAA;AAAA,cACJ,MAAM,SAAA,CAAU,MAAA;AAAA,cAChB,UAAA,EAAY;AAAA,gBACV,CAAC,gCAAgC,GAAG,MAAA;AAAA,gBACpC,CAAC,cAAc,GAAG,UAAA;AAAA,gBAClB,CAAC,aAAa,GAAG;AAAA;AACnB,aACD,CAAA;AAGD,YAAC,KAAA,CAAkC,UAAU,CAAA,GAAI,IAAA;AAIjD,YAAA,MAAM,UAAU,qBAAA,EAAsB;AACtC,YAAA,IAAI,OAAA,EAAS;AACX,cAAA,uBAAA,CAAwB,IAAA,EAAM,OAAO,OAAO,CAAA;AAAA,YAC9C;AAEA,YAAA,IAAI,WAAA,EAAa;AACf,cAAA,IAAI;AACF,gBAAA,WAAA,CAAY,IAAA,EAAM,mBAAmB,OAAO,CAAA;AAAA,cAC9C,SAAS,CAAA,EAAG;AACV,gBAAA,IAAA,CAAK,YAAA,CAAa,qBAAqB,oBAAoB,CAAA;AAC3D,gBAAA,WAAA,IAAe,KAAA,CAAM,KAAA,CAAM,gDAAA,EAAkD,CAAC,CAAA;AAAA,cAChF;AAAA,YACF;AAEA,YAAA,mBAAA,CAAoB,IAAA,EAAM,MAAM,iBAAiB,CAAA;AAEjD,YAAA,OAAO,IAAA;AAAA,UACT,CAAA;AAAA,UACA;AAAA,YACE,oBAAoB,iBAAA,KAAsB,KAAA;AAAA,YAC1C,YAAA,CAAa,EAAE,IAAA,EAAK,EAAG;AAGrB,cAAA,IAAK,IAAA,CAAiC,UAAU,CAAA,EAAG;AACjD,gBAAA,OAAO,IAAA;AAAA,cACT;AACA,cAAA,IAAI,WAAW,IAAA,EAAM;AACnB,gBAAA,OAAO,KAAA;AAAA,cACT;AAIA,cAAA,OAAO,IAAA;AAAA,YACT;AAAA;AACF,SACF;AAAA,MACF,CAAC,CAAA;AAAA,IACH;AAAA,GACF;AACF,CAAA,CAAA;AAWO,MAAM,4BAAA,GAA+B,kBAAkB,6BAA6B;;;;"}

package/build/esm/integrations/tracing-channel/postgres.js

@@ -0,0 +1,168 @@
+import * as diagnosticsChannel from 'node:diagnostics_channel';
+import { defineIntegration, waitForTracingChannelBinding, debug, bindScopeToEmitter, getCurrentScope, startInactiveSpan, SPAN_KIND, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, isObjectLike } from '@sentry/core';
+import { DEBUG_BUILD } from '../../debug-build.js';
+import { CHANNELS } from '../../orchestrion/channels.js';
+import { bindTracingChannelToSpan } from '../../tracing-channel.js';
+
+const INTEGRATION_NAME = "Postgres";
+const ORIGIN = "auto.db.orchestrion.postgres";
+const ATTR_DB_SYSTEM = "db.system";
+const ATTR_DB_NAME = "db.name";
+const ATTR_DB_CONNECTION_STRING = "db.connection_string";
+const ATTR_DB_USER = "db.user";
+const ATTR_DB_STATEMENT = "db.statement";
+const ATTR_NET_PEER_NAME = "net.peer.name";
+const ATTR_NET_PEER_PORT = "net.peer.port";
+const ATTR_PG_PLAN = "db.postgresql.plan";
+const ATTR_PG_IDLE_TIMEOUT = "db.postgresql.idle.timeout.millis";
+const ATTR_PG_MAX_CLIENT = "db.postgresql.max.client";
+const DB_SYSTEM_POSTGRESQL = "postgresql";
+const SPAN_QUERY_FALLBACK = "pg.query";
+const SPAN_CONNECT = "pg.connect";
+const SPAN_POOL_CONNECT = "pg-pool.connect";
+const _postgresChannelIntegration = ((options = {}) => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      if (!diagnosticsChannel.tracingChannel) {
+        return;
+      }
+      waitForTracingChannelBinding(() => {
+        subscribeQueryLikeChannel(CHANNELS.PG_QUERY, querySpanOptions, { deferStreamedResult: true });
+        if (!options.ignoreConnectSpans) {
+          subscribeQueryLikeChannel(CHANNELS.PG_CONNECT, connectSpanOptions);
+          subscribeQueryLikeChannel(CHANNELS.PGPOOL_CONNECT, poolConnectSpanOptions);
+        }
+      });
+    }
+  };
+});
+function subscribeQueryLikeChannel(channelName, getSpanOptions, { deferStreamedResult = false } = {}) {
+  DEBUG_BUILD && debug.log(`[orchestrion:pg] subscribing to channel "${channelName}"`);
+  bindTracingChannelToSpan(
+    diagnosticsChannel.tracingChannel(channelName),
+    (data) => {
+      data._sentryCallerScope = getCurrentScope();
+      return startInactiveSpan({ ...getSpanOptions(data), kind: SPAN_KIND.CLIENT });
+    },
+    // `connect`/`pool-connect` resolve with a persistent `Client` (itself an
+    // `EventEmitter`), which is NOT a streamed result. Deferring their span
+    // to that emitter's `'end'`/`'error'` would keep it open for the whole
+    // connection lifetime, so it never ends in time and is dropped. Only
+    // `query` can return a streamable `Submittable`, so only it defers.
+    deferStreamedResult ? {
+      // Only instrument under an active span, leaving the context untouched otherwise
+      // (e.g. connects issued during app startup).
+      requiresParentSpan: true,
+      // Streamable `Submittable` (e.g. `client.query(new Query())`)
+      // returns an emitter that orchestrion stores on `ctx.result` while
+      // firing no async events; the query isn't done until the emitter
+      // emits `'end'`/`'error'`. Defer ending to those events for that
+      // path; the callback, promise, and sync-throw paths carry no
+      // emitter, so the helper ends the span as usual.
+      deferSpanEnd({ data, end }) {
+        const result = data.result;
+        if (!result || typeof result !== "object" || !hasOnMethod(result)) {
+          return false;
+        }
+        const callerScope = data._sentryCallerScope;
+        if (callerScope) {
+          bindScopeToEmitter(result, callerScope);
+        }
+        result.on("error", (err) => end(err));
+        result.on("end", () => end());
+        return true;
+      }
+    } : { requiresParentSpan: true }
+  );
+}
+function querySpanOptions(ctx) {
+  const params = ctx.self?.connectionParameters ?? {};
+  const queryConfig = extractQueryConfig(ctx.arguments);
+  return {
+    // The description is the SQL statement
+    name: queryConfig?.text ?? SPAN_QUERY_FALLBACK,
+    op: "db",
+    attributes: {
+      ...getConnectionAttributes(params),
+      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN,
+      [ATTR_DB_STATEMENT]: queryConfig?.text || void 0,
+      [ATTR_PG_PLAN]: typeof queryConfig?.name === "string" ? queryConfig.name : void 0
+    }
+  };
+}
+function connectSpanOptions(ctx) {
+  const params = ctx.self?.connectionParameters ?? {};
+  return { name: SPAN_CONNECT, op: "db", attributes: getConnectionAttributes(params) };
+}
+function poolConnectSpanOptions(ctx) {
+  const opts = ctx.self?.options ?? {};
+  return { name: SPAN_POOL_CONNECT, op: "db", attributes: getPoolConnectionAttributes(opts) };
+}
+function hasOnMethod(obj) {
+  return "on" in obj && typeof obj.on === "function";
+}
+function extractQueryConfig(args) {
+  const arg0 = args[0];
+  if (typeof arg0 === "string") {
+    return { text: arg0 };
+  }
+  if (isObjectLike(arg0) && typeof arg0.text === "string") {
+    const obj = arg0;
+    return { text: obj.text, name: obj.name };
+  }
+  return void 0;
+}
+function getConnectionAttributes(params) {
+  return {
+    [ATTR_DB_SYSTEM]: DB_SYSTEM_POSTGRESQL,
+    [ATTR_DB_CONNECTION_STRING]: getConnectionString(params),
+    [ATTR_DB_NAME]: params.database,
+    [ATTR_DB_USER]: params.user,
+    [ATTR_NET_PEER_NAME]: params.host,
+    [ATTR_NET_PEER_PORT]: Number.isInteger(params.port) ? params.port : void 0
+  };
+}
+function getPoolConnectionAttributes(opts) {
+  let url;
+  try {
+    url = opts.connectionString ? new URL(opts.connectionString) : void 0;
+  } catch {
+    url = void 0;
+  }
+  const database = url?.pathname.slice(1) || opts.database;
+  const host = url?.hostname || opts.host;
+  const port = Number(url?.port) || (Number.isInteger(opts.port) ? opts.port : void 0);
+  const user = url?.username || opts.user;
+  return {
+    [ATTR_DB_SYSTEM]: DB_SYSTEM_POSTGRESQL,
+    [ATTR_DB_CONNECTION_STRING]: getConnectionString(opts),
+    [ATTR_PG_IDLE_TIMEOUT]: opts.idleTimeoutMillis,
+    [ATTR_PG_MAX_CLIENT]: opts.max,
+    [ATTR_DB_NAME]: database,
+    [ATTR_NET_PEER_PORT]: port,
+    // these two come from a url parse and slice, can be ''
+    [ATTR_NET_PEER_NAME]: host || void 0,
+    [ATTR_DB_USER]: user || void 0
+  };
+}
+function getConnectionString(params) {
+  if (params.connectionString) {
+    try {
+      const url = new URL(params.connectionString);
+      url.username = "";
+      url.password = "";
+      return url.toString();
+    } catch {
+      return "postgresql://localhost:5432/";
+    }
+  }
+  const host = params.host || "localhost";
+  const port = params.port || 5432;
+  const database = params.database || "";
+  return `postgresql://${host}:${port}/${database}`;
+}
+const postgresChannelIntegration = defineIntegration(_postgresChannelIntegration);
+
+export { postgresChannelIntegration };
+//# sourceMappingURL=postgres.js.map

package/build/esm/integrations/tracing-channel/postgres.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.js","sources":["../../../../src/integrations/tracing-channel/postgres.ts"],"sourcesContent":["import * as diagnosticsChannel from 'node:diagnostics_channel';\nimport type { IntegrationFn, Scope, SpanAttributes } from '@sentry/core';\nimport {\n  isObjectLike,\n  bindScopeToEmitter,\n  debug,\n  defineIntegration,\n  getCurrentScope,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  SPAN_KIND,\n  startInactiveSpan,\n  waitForTracingChannelBinding,\n} from '@sentry/core';\nimport { DEBUG_BUILD } from '../../debug-build';\nimport { CHANNELS } from '../../orchestrion/channels';\nimport { bindTracingChannelToSpan } from '../../tracing-channel';\n\n// NOTE: this uses the same name as the OTel integration by design.\n// When enabled, the OTel 'Postgres' integration is omitted from the default set.\nconst INTEGRATION_NAME = 'Postgres' as const;\n\n// Only the query span carries an origin (the connect/pool-connect spans don't,\n// so they default to 'manual').\nconst ORIGIN = 'auto.db.orchestrion.postgres';\n\n// OpenTelemetry \"OLD\" db/net semantic-conventions, inlined to keep this\n// integration free of `@opentelemetry/*` deps.\nconst ATTR_DB_SYSTEM = 'db.system';\nconst ATTR_DB_NAME = 'db.name';\nconst ATTR_DB_CONNECTION_STRING = 'db.connection_string';\nconst ATTR_DB_USER = 'db.user';\nconst ATTR_DB_STATEMENT = 'db.statement';\nconst ATTR_NET_PEER_NAME = 'net.peer.name';\nconst ATTR_NET_PEER_PORT = 'net.peer.port';\nconst ATTR_PG_PLAN = 'db.postgresql.plan';\nconst ATTR_PG_IDLE_TIMEOUT = 'db.postgresql.idle.timeout.millis';\nconst ATTR_PG_MAX_CLIENT = 'db.postgresql.max.client';\nconst DB_SYSTEM_POSTGRESQL = 'postgresql';\n\n// We set `op: 'db'` and the SQL description directly here (same as mysql\n// orchestrion) rather than relying on the OTel pipeline's `inferDbSpanData`\n// processor, which only runs in the node SDK, so setting them here is what\n// makes the spans correct on the other runtimes\n//\n// The user-visible span is identical to OTel: query spans are named after\n// `db.statement`; connect/pool-connect spans keep these names.\nconst SPAN_QUERY_FALLBACK = 'pg.query';\nconst SPAN_CONNECT = 'pg.connect';\nconst SPAN_POOL_CONNECT = 'pg-pool.connect';\n\n/**\n * The shape orchestrion's transform attaches to the tracing-channel `context`. Documented here rather\n * than imported because orchestrion's runtime doesn't export it.\n */\ninterface PgChannelContext {\n  // The live args array passed to the wrapped `query`/`connect` call.\n  arguments: unknown[];\n  self?: unknown;\n  result?: unknown;\n  error?: unknown;\n  // The caller's scope, captured at `start` and replayed onto a streamed `Submittable` emitter (see below).\n  _sentryCallerScope?: Scope;\n}\n\ninterface PgConnectionParams {\n  database?: string;\n  host?: string;\n  port?: number;\n  user?: string;\n  connectionString?: string;\n}\n\ninterface PgPoolOptions extends PgConnectionParams {\n  idleTimeoutMillis?: number;\n  // pg-pool stores the max pool size as `max` (defaulting it to 10 in its\n  // constructor). The OTel pg instrumentation reads a `maxClient` field that\n  // pg-pool never sets, so its `db.postgresql.max.client` attribute is always\n  // dropped; we read the real `max` so the attribute is actually populated.\n  max?: number;\n}\n\nconst _postgresChannelIntegration = ((options: { ignoreConnectSpans?: boolean } = {}) => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      // `tracingChannel` is unavailable before Node 18.19 so do nothing in that case.\n      if (!diagnosticsChannel.tracingChannel) {\n        return;\n      }\n\n      waitForTracingChannelBinding(() => {\n        // Query spans: `pg`/native `Client.prototype.query`. Only this channel can return a streamable\n        // `Submittable` result, so it's the only one that defers span-ending to the emitter (see below).\n        subscribeQueryLikeChannel(CHANNELS.PG_QUERY, querySpanOptions, { deferStreamedResult: true });\n\n        // Connect spans, gated by `ignoreConnectSpans` (same as OTel pg).\n        // `Client.prototype.connect` (pg + native)\n        // and `Pool.prototype.connect` (pg-pool).\n        if (!options.ignoreConnectSpans) {\n          subscribeQueryLikeChannel(CHANNELS.PG_CONNECT, connectSpanOptions);\n          subscribeQueryLikeChannel(CHANNELS.PGPOOL_CONNECT, poolConnectSpanOptions);\n        }\n      });\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Subscribe to a pg tracing-channel and manage a span across its lifecycle.\n * Shared by the query/connect/pool-connect channels. They differ only in how\n * the span's name + attributes are built (`getSpanOptions`), and whether the\n * result can be a streamable emitter (`deferStreamedResult`, query-only).\n */\nfunction subscribeQueryLikeChannel(\n  channelName: string,\n  getSpanOptions: (ctx: PgChannelContext) => { name: string; op: string; attributes: SpanAttributes },\n  { deferStreamedResult = false }: { deferStreamedResult?: boolean } = {},\n): void {\n  DEBUG_BUILD && debug.log(`[orchestrion:pg] subscribing to channel \"${channelName}\"`);\n\n  bindTracingChannelToSpan(\n    diagnosticsChannel.tracingChannel<PgChannelContext>(channelName),\n    data => {\n      // Capture the caller's scope while still synchronously inside the call, for the streamed path:\n      // pg dispatches a `Submittable` emitter's events outside the original async scope, so `deferSpanEnd`\n      // replays this scope onto that emitter.\n      data._sentryCallerScope = getCurrentScope();\n\n      // `kind: CLIENT` mirrors the OTel pg instrumentation, so the emitted\n      // `otel.kind` matches across the OTel and diagnostics-channel paths.\n      return startInactiveSpan({ ...getSpanOptions(data), kind: SPAN_KIND.CLIENT });\n    },\n    // `connect`/`pool-connect` resolve with a persistent `Client` (itself an\n    // `EventEmitter`), which is NOT a streamed result. Deferring their span\n    // to that emitter's `'end'`/`'error'` would keep it open for the whole\n    // connection lifetime, so it never ends in time and is dropped. Only\n    // `query` can return a streamable `Submittable`, so only it defers.\n    deferStreamedResult\n      ? {\n          // Only instrument under an active span, leaving the context untouched otherwise\n          // (e.g. connects issued during app startup).\n          requiresParentSpan: true,\n          // Streamable `Submittable` (e.g. `client.query(new Query())`)\n          // returns an emitter that orchestrion stores on `ctx.result` while\n          // firing no async events; the query isn't done until the emitter\n          // emits `'end'`/`'error'`. Defer ending to those events for that\n          // path; the callback, promise, and sync-throw paths carry no\n          // emitter, so the helper ends the span as usual.\n          deferSpanEnd({ data, end }) {\n            const result = data.result;\n            if (!result || typeof result !== 'object' || !hasOnMethod(result)) {\n              return false;\n            }\n\n            // Replay the caller's scope onto the emitter so listeners theu\n            // user attaches after the call returns (and any spans they start)\n            // nest under the caller, not a fresh root trace.\n            const callerScope = data._sentryCallerScope;\n            if (callerScope) {\n              bindScopeToEmitter(result, callerScope);\n            }\n\n            result.on('error', err => end(err));\n            result.on('end', () => end());\n\n            return true;\n          },\n        }\n      : { requiresParentSpan: true },\n  );\n}\n\nfunction querySpanOptions(ctx: PgChannelContext): { name: string; op: string; attributes: SpanAttributes } {\n  const params = (ctx.self as { connectionParameters?: PgConnectionParams } | undefined)?.connectionParameters ?? {};\n  const queryConfig = extractQueryConfig(ctx.arguments);\n  return {\n    // The description is the SQL statement\n    name: queryConfig?.text ?? SPAN_QUERY_FALLBACK,\n    op: 'db',\n    attributes: {\n      ...getConnectionAttributes(params),\n      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN,\n      [ATTR_DB_STATEMENT]: queryConfig?.text || undefined,\n      [ATTR_PG_PLAN]: typeof queryConfig?.name === 'string' ? queryConfig.name : undefined,\n    },\n  };\n}\n\nfunction connectSpanOptions(ctx: PgChannelContext): { name: string; op: string; attributes: SpanAttributes } {\n  const params = (ctx.self as { connectionParameters?: PgConnectionParams } | undefined)?.connectionParameters ?? {};\n  // No origin set -> defaults to 'manual'\n  return { name: SPAN_CONNECT, op: 'db', attributes: getConnectionAttributes(params) };\n}\n\nfunction poolConnectSpanOptions(ctx: PgChannelContext): { name: string; op: string; attributes: SpanAttributes } {\n  const opts = (ctx.self as { options?: PgPoolOptions } | undefined)?.options ?? {};\n  return { name: SPAN_POOL_CONNECT, op: 'db', attributes: getPoolConnectionAttributes(opts) };\n}\n\nfunction hasOnMethod(obj: object): obj is { on: (event: string, listener: (arg?: unknown) => void) => unknown } {\n  return 'on' in obj && typeof (obj as { on?: unknown }).on === 'function';\n}\n\n// `client.query(text, cb?)`, `client.query(text, values, cb?)`, and\n// `client.query(configObj, cb?)` are all valid; normalize to `{ text, name }`\n// (the only fields the span needs). Returns undefined for invalid args.\nfunction extractQueryConfig(args: unknown[]): { text: string; name?: unknown } | undefined {\n  const arg0 = args[0];\n  if (typeof arg0 === 'string') {\n    return { text: arg0 };\n  }\n  if (isObjectLike(arg0) && typeof (arg0 as { text?: unknown }).text === 'string') {\n    const obj = arg0 as { text: string; name?: unknown };\n    return { text: obj.text, name: obj.name };\n  }\n  return undefined;\n}\n\nfunction getConnectionAttributes(params: PgConnectionParams): SpanAttributes {\n  return {\n    [ATTR_DB_SYSTEM]: DB_SYSTEM_POSTGRESQL,\n    [ATTR_DB_CONNECTION_STRING]: getConnectionString(params),\n    [ATTR_DB_NAME]: params.database,\n    [ATTR_DB_USER]: params.user,\n    [ATTR_NET_PEER_NAME]: params.host,\n    [ATTR_NET_PEER_PORT]: Number.isInteger(params.port) ? params.port : undefined,\n  };\n}\n\nfunction getPoolConnectionAttributes(opts: PgPoolOptions): SpanAttributes {\n  let url: URL | undefined;\n  try {\n    url = opts.connectionString ? new URL(opts.connectionString) : undefined;\n  } catch {\n    url = undefined;\n  }\n  const database = url?.pathname.slice(1) || opts.database;\n  const host = url?.hostname || opts.host;\n  // Mirror OTel's `getSemanticAttributesFromPoolConnection`: prefer the URL's\n  // port, but fall back to an explicit `opts.port` when the connection string\n  // omits it (`Number('')` / `Number(undefined)` -> falsy).\n  const port = Number(url?.port) || (Number.isInteger(opts.port) ? opts.port : undefined);\n  const user = url?.username || opts.user;\n  return {\n    [ATTR_DB_SYSTEM]: DB_SYSTEM_POSTGRESQL,\n    [ATTR_DB_CONNECTION_STRING]: getConnectionString(opts),\n    [ATTR_PG_IDLE_TIMEOUT]: opts.idleTimeoutMillis,\n    [ATTR_PG_MAX_CLIENT]: opts.max,\n    [ATTR_DB_NAME]: database,\n    [ATTR_NET_PEER_PORT]: port,\n    // these two come from a url parse and slice, can be ''\n    [ATTR_NET_PEER_NAME]: host || undefined,\n    [ATTR_DB_USER]: user || undefined,\n  };\n}\n\n// Builds `postgresql://host:port/database`, masking credentials when a raw\n// connection string was provided.\nfunction getConnectionString(params: PgConnectionParams): string {\n  if (params.connectionString) {\n    try {\n      const url = new URL(params.connectionString);\n      url.username = '';\n      url.password = '';\n      return url.toString();\n    } catch {\n      return 'postgresql://localhost:5432/';\n    }\n  }\n  const host = params.host || 'localhost';\n  const port = params.port || 5432;\n  const database = params.database || '';\n  return `postgresql://${host}:${port}/${database}`;\n}\n\n/**\n * EXPERIMENTAL: orchestrion-driven `pg` (node-postgres) integration.\n *\n * Subscribes to the `orchestrion:pg:query`/`:connect` and\n * `orchestrion:pg-pool:connect` diagnostics_channels that the orchestrion code\n * transform injects into `pg`'s `Client.prototype.query`/`connect`\n * and `pg-pool`'s `Pool.prototype.connect`. Requires the orchestrion runtime\n * hook or bundler plugin to be active.\n */\nexport const postgresChannelIntegration = defineIntegration(_postgresChannelIntegration);\n"],"names":[],"mappings":"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"}