@depup/sentry__server-utils 10.67.0-depup.0

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

@@ -0,0 +1,98 @@
+import * as diagnosticsChannel from 'node:diagnostics_channel';
+import { defineIntegration, LANGGRAPH_INTEGRATION_NAME, resolveAIRecordingOptions, createLangChainCallbackHandler, waitForTracingChannelBinding, debug, startInactiveSpan, _INTERNAL_getLangGraphCreateAgentSpanOptions, wrapToolsWithSpans, extractAgentNameFromParams, extractLLMFromParams, instrumentCompiledGraphInvoke } 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 = LANGGRAPH_INTEGRATION_NAME;
+let subscribed = false;
+let insideCreateReactAgent = false;
+const _langGraphChannelIntegration = ((options = {}) => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      if (!diagnosticsChannel.tracingChannel || subscribed) {
+        return;
+      }
+      subscribed = true;
+      const resolvedOptions = resolveAIRecordingOptions(options);
+      const sentryHandler = createLangChainCallbackHandler(resolvedOptions);
+      waitForTracingChannelBinding(() => {
+        DEBUG_BUILD && debug.log(`[orchestrion:langgraph] subscribing to channel "${CHANNELS.LANGGRAPH_STATE_GRAPH_COMPILE}"`);
+        bindTracingChannelToSpan(
+          diagnosticsChannel.tracingChannel(CHANNELS.LANGGRAPH_STATE_GRAPH_COMPILE),
+          (data) => {
+            if (insideCreateReactAgent) {
+              return void 0;
+            }
+            const compileOptions = getFirstArgObject(data.arguments);
+            const name = typeof compileOptions?.name === "string" ? compileOptions.name : void 0;
+            return startInactiveSpan(_INTERNAL_getLangGraphCreateAgentSpanOptions(name));
+          },
+          {
+            beforeSpanEnd: (_span, data) => {
+              wrapCompiledGraphInvoke(
+                data.result,
+                getFirstArgObject(data.arguments) ?? {},
+                resolvedOptions,
+                null,
+                sentryHandler
+              );
+            }
+          }
+        );
+        DEBUG_BUILD && debug.log(`[orchestrion:langgraph] subscribing to channel "${CHANNELS.LANGGRAPH_CREATE_REACT_AGENT}"`);
+        const reactAgentChannel = diagnosticsChannel.tracingChannel(
+          CHANNELS.LANGGRAPH_CREATE_REACT_AGENT
+        );
+        reactAgentChannel.start.subscribe((message) => {
+          insideCreateReactAgent = true;
+          try {
+            const { arguments: args } = message;
+            const params = getFirstArgObject(args);
+            if (params && Array.isArray(params.tools) && params.tools.length > 0) {
+              wrapToolsWithSpans(params.tools, resolvedOptions, extractAgentNameFromParams(args) ?? void 0);
+            }
+          } catch (error) {
+            DEBUG_BUILD && debug.error("[orchestrion:langgraph] failed to wrap createReactAgent tools", error);
+          }
+        });
+        reactAgentChannel.end.subscribe((message) => {
+          insideCreateReactAgent = false;
+          const { arguments: args, result } = message;
+          const agentName = extractAgentNameFromParams(args) ?? void 0;
+          const compileOptions = agentName ? { name: agentName } : {};
+          wrapCompiledGraphInvoke(result, compileOptions, resolvedOptions, extractLLMFromParams(args), sentryHandler);
+        });
+        reactAgentChannel.error.subscribe(() => {
+          insideCreateReactAgent = false;
+        });
+      });
+    }
+  };
+});
+function getFirstArgObject(args) {
+  const first = (args ?? [])[0];
+  return typeof first === "object" && first !== null ? first : void 0;
+}
+function wrapCompiledGraphInvoke(graph, compileOptions, options, llm, sentryHandler) {
+  if (!graph || typeof graph !== "object") {
+    return;
+  }
+  const compiledGraph = graph;
+  const originalInvoke = compiledGraph.invoke;
+  if (typeof originalInvoke === "function") {
+    compiledGraph.invoke = instrumentCompiledGraphInvoke(
+      originalInvoke.bind(compiledGraph),
+      compiledGraph,
+      compileOptions,
+      options,
+      llm,
+      sentryHandler
+    );
+  }
+}
+const langGraphChannelIntegration = defineIntegration(_langGraphChannelIntegration);
+
+export { langGraphChannelIntegration };
+//# sourceMappingURL=langgraph.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"langgraph.js","sources":["../../../../src/integrations/tracing-channel/langgraph.ts"],"sourcesContent":["import * as diagnosticsChannel from 'node:diagnostics_channel';\nimport type { CompiledGraph, IntegrationFn, LangGraphOptions } from '@sentry/core';\nimport {\n  _INTERNAL_getLangGraphCreateAgentSpanOptions,\n  createLangChainCallbackHandler,\n  debug,\n  defineIntegration,\n  extractAgentNameFromParams,\n  extractLLMFromParams,\n  instrumentCompiledGraphInvoke,\n  LANGGRAPH_INTEGRATION_NAME,\n  resolveAIRecordingOptions,\n  startInactiveSpan,\n  waitForTracingChannelBinding,\n  wrapToolsWithSpans,\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 'LangGraph' integration is\n// dropped from the default set (see the Node opt-in loader).\nconst INTEGRATION_NAME = LANGGRAPH_INTEGRATION_NAME;\n\ninterface CompileChannelContext {\n  arguments: unknown[];\n  result?: unknown;\n}\n\ninterface CreateReactAgentChannelContext {\n  arguments: unknown[];\n  result?: unknown;\n}\n\nlet subscribed = false;\n\n// `createReactAgent` compiles a `StateGraph` internally; suppress the `create_agent` span for that\n// nested compile so a react agent gets a single `invoke_agent` span, matching the OTel path.\nlet insideCreateReactAgent = false;\n\nconst _langGraphChannelIntegration = ((options: LangGraphOptions = {}) => {\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      const resolvedOptions = resolveAIRecordingOptions(options);\n      const sentryHandler = createLangChainCallbackHandler(resolvedOptions);\n\n      // `bindTracingChannelToSpan` needs the async-context binding that `initOpenTelemetry()` registers\n      // after `setupOnce` runs, so wait for it before subscribing.\n      waitForTracingChannelBinding(() => {\n        // StateGraph.compile → `create_agent` span, then wrap the returned graph's `invoke`.\n        DEBUG_BUILD &&\n          debug.log(`[orchestrion:langgraph] subscribing to channel \"${CHANNELS.LANGGRAPH_STATE_GRAPH_COMPILE}\"`);\n        bindTracingChannelToSpan(\n          diagnosticsChannel.tracingChannel<CompileChannelContext>(CHANNELS.LANGGRAPH_STATE_GRAPH_COMPILE),\n          data => {\n            if (insideCreateReactAgent) {\n              return undefined;\n            }\n            const compileOptions = getFirstArgObject(data.arguments);\n            const name = typeof compileOptions?.name === 'string' ? compileOptions.name : undefined;\n\n            return startInactiveSpan(_INTERNAL_getLangGraphCreateAgentSpanOptions(name));\n          },\n          {\n            beforeSpanEnd: (_span, data) => {\n              wrapCompiledGraphInvoke(\n                data.result,\n                getFirstArgObject(data.arguments) ?? {},\n                resolvedOptions,\n                null,\n                sentryHandler,\n              );\n            },\n          },\n        );\n\n        // createReactAgent has no `create_agent` span of its own; it only wraps tools and the returned\n        // graph's `invoke`. Tools are wrapped at `start` (before the agent runs), invoke at `end`.\n        DEBUG_BUILD &&\n          debug.log(`[orchestrion:langgraph] subscribing to channel \"${CHANNELS.LANGGRAPH_CREATE_REACT_AGENT}\"`);\n        const reactAgentChannel = diagnosticsChannel.tracingChannel<CreateReactAgentChannelContext>(\n          CHANNELS.LANGGRAPH_CREATE_REACT_AGENT,\n        );\n        reactAgentChannel.start.subscribe(message => {\n          // `createReactAgent` runs synchronously and compiles a `StateGraph` internally, so the flag\n          // must be on for the duration and off by `end`. It's set here (never in a branch that can\n          // throw) and cleared in both `end` and `error`, so it can neither stick on across calls nor\n          // stay off during this call's nested compile. Tool wrapping is guarded for the same reason.\n          insideCreateReactAgent = true;\n          try {\n            const { arguments: args } = message as CreateReactAgentChannelContext;\n            const params = getFirstArgObject(args);\n            if (params && Array.isArray(params.tools) && params.tools.length > 0) {\n              wrapToolsWithSpans(params.tools, resolvedOptions, extractAgentNameFromParams(args) ?? undefined);\n            }\n          } catch (error) {\n            DEBUG_BUILD && debug.error('[orchestrion:langgraph] failed to wrap createReactAgent tools', error);\n          }\n        });\n        reactAgentChannel.end.subscribe(message => {\n          insideCreateReactAgent = false;\n          const { arguments: args, result } = message as CreateReactAgentChannelContext;\n          const agentName = extractAgentNameFromParams(args) ?? undefined;\n          const compileOptions = agentName ? { name: agentName } : {};\n          wrapCompiledGraphInvoke(result, compileOptions, resolvedOptions, extractLLMFromParams(args), sentryHandler);\n        });\n        // Make sure a thrown `createReactAgent` doesn't leave the suppression flag stuck on.\n        reactAgentChannel.error.subscribe(() => {\n          insideCreateReactAgent = false;\n        });\n      });\n    },\n  };\n}) satisfies IntegrationFn;\n\nfunction getFirstArgObject(args: unknown[] | undefined): Record<string, unknown> | undefined {\n  const first = (args ?? [])[0];\n\n  return typeof first === 'object' && first !== null ? (first as Record<string, unknown>) : undefined;\n}\n\n/**\n * Wrap the compiled graph's `invoke` with the shared `invoke_agent` instrumentation, exactly as the\n * OTel path does on the returned graph.\n */\nfunction wrapCompiledGraphInvoke(\n  graph: unknown,\n  compileOptions: Record<string, unknown>,\n  options: LangGraphOptions,\n  llm: ReturnType<typeof extractLLMFromParams>,\n  sentryHandler: unknown,\n): void {\n  if (!graph || typeof graph !== 'object') {\n    return;\n  }\n\n  const compiledGraph = graph as CompiledGraph;\n  const originalInvoke = compiledGraph.invoke;\n  if (typeof originalInvoke === 'function') {\n    compiledGraph.invoke = instrumentCompiledGraphInvoke(\n      originalInvoke.bind(compiledGraph),\n      compiledGraph,\n      compileOptions,\n      options,\n      llm,\n      sentryHandler,\n    );\n  }\n}\n\n/**\n * EXPERIMENTAL — orchestrion-driven LangGraph integration. Subscribes to the diagnostics_channels\n * injected into `@langchain/langgraph`'s `StateGraph.compile` and `createReactAgent`, so it requires\n * the orchestrion runtime hook or bundler plugin.\n */\nexport const langGraphChannelIntegration = defineIntegration(_langGraphChannelIntegration);\n"],"names":[],"mappings":"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"}

package/build/esm/integrations/tracing-channel/lru-memoizer.js

@@ -0,0 +1,29 @@
+import * as diagnosticsChannel from 'node:diagnostics_channel';
+import { defineIntegration, debug, waitForTracingChannelBinding } 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 = "LruMemoizer";
+const _lruMemoizerChannelIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      if (!diagnosticsChannel.tracingChannel) {
+        return;
+      }
+      DEBUG_BUILD && debug.log(`[orchestrion:lru-memoizer] subscribing to channel "${CHANNELS.LRU_MEMOIZER_LOAD}"`);
+      waitForTracingChannelBinding(() => {
+        bindTracingChannelToSpan(
+          diagnosticsChannel.tracingChannel(CHANNELS.LRU_MEMOIZER_LOAD),
+          // We only want the helper's caller-context restore for the callback lru-memoizer fires from a detached `setImmediate`.
+          () => void 0
+        );
+      });
+    }
+  };
+});
+const lruMemoizerChannelIntegration = defineIntegration(_lruMemoizerChannelIntegration);
+
+export { lruMemoizerChannelIntegration };
+//# sourceMappingURL=lru-memoizer.js.map

package/build/esm/integrations/tracing-channel/lru-memoizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lru-memoizer.js","sources":["../../../../src/integrations/tracing-channel/lru-memoizer.ts"],"sourcesContent":["import * as diagnosticsChannel from 'node:diagnostics_channel';\nimport type { IntegrationFn } from '@sentry/core';\nimport { debug, defineIntegration, waitForTracingChannelBinding } 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\n// 'LruMemoizer' integration is omitted from the default set.\nconst INTEGRATION_NAME = 'LruMemoizer' as const;\n\ninterface LruMemoizerLoadContext {\n  arguments: unknown[];\n}\n\nconst _lruMemoizerChannelIntegration = (() => {\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      DEBUG_BUILD && debug.log(`[orchestrion:lru-memoizer] subscribing to channel \"${CHANNELS.LRU_MEMOIZER_LOAD}\"`);\n\n      waitForTracingChannelBinding(() => {\n        bindTracingChannelToSpan(\n          diagnosticsChannel.tracingChannel<LruMemoizerLoadContext>(CHANNELS.LRU_MEMOIZER_LOAD),\n          // We only want the helper's caller-context restore for the callback lru-memoizer fires from a detached `setImmediate`.\n          () => undefined,\n        );\n      });\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * EXPERIMENTAL — orchestrion-driven lru-memoizer integration. Subscribes to\n * `orchestrion:lru-memoizer:load` (injected into `lru-memoizer/lib/async.js`'s\n * `memoizedFunction`). Creates no spans; only re-runs the memoized callback with the\n * caller's scope. Requires the orchestrion runtime hook or bundler plugin.\n */\nexport const lruMemoizerChannelIntegration = defineIntegration(_lruMemoizerChannelIntegration);\n"],"names":[],"mappings":";;;;;;AASA,MAAM,gBAAA,GAAmB,aAAA;AAMzB,MAAM,kCAAkC,MAAM;AAC5C,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,mDAAA,EAAsD,QAAA,CAAS,iBAAiB,CAAA,CAAA,CAAG,CAAA;AAE5G,MAAA,4BAAA,CAA6B,MAAM;AACjC,QAAA,wBAAA;AAAA,UACE,kBAAA,CAAmB,cAAA,CAAuC,QAAA,CAAS,iBAAiB,CAAA;AAAA;AAAA,UAEpF,MAAM;AAAA,SACR;AAAA,MACF,CAAC,CAAA;AAAA,IACH;AAAA,GACF;AACF,CAAA,CAAA;AAQO,MAAM,6BAAA,GAAgC,kBAAkB,8BAA8B;;;;"}

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

@@ -0,0 +1,102 @@
+import * as diagnosticsChannel from 'node:diagnostics_channel';
+import { defineIntegration, waitForTracingChannelBinding } from '@sentry/core';
+import { startMongoSpan, getV4SpanAttributes, getV3SpanAttributes, getV3CommandOperation } from '../../mongodb/mongodb-span.js';
+import { CHANNELS } from '../../orchestrion/channels.js';
+import { bindTracingChannelToSpan } from '../../tracing-channel.js';
+
+const INTEGRATION_NAME = "Mongo";
+const ORIGIN = "auto.db.orchestrion.mongo";
+const V3_DEDICATED_COMMANDS = /* @__PURE__ */ new Set(["insert", "update", "delete", "find", "getMore", "killCursors"]);
+const _mongodbChannelIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      if (!diagnosticsChannel.tracingChannel) {
+        return;
+      }
+      waitForTracingChannelBinding(() => {
+        subscribeV4Command();
+        subscribeV4Checkout();
+        subscribeV3Wireprotocol();
+      });
+    }
+  };
+});
+function subscribeV4Command() {
+  bindTracingChannelToSpan(
+    diagnosticsChannel.tracingChannel(CHANNELS.MONGODB_COMMAND),
+    (data) => {
+      const args = data.arguments ?? [];
+      const ns = args[0];
+      const cmd = args[1];
+      if (!ns || !cmd || typeof cmd !== "object" || cmd.ismaster || cmd.hello) {
+        return void 0;
+      }
+      const operation = Object.keys(cmd)[0];
+      return startMongoSpan(getV4SpanAttributes(data.self, ns, cmd, operation, ORIGIN));
+    },
+    // Matches otel's `shouldSkipInstrumentation`: only trace when there is
+    // an active parent span, to avoid emitting orphaned mongodb spans.
+    { requiresParentSpan: true }
+  );
+}
+function subscribeV4Checkout() {
+  bindTracingChannelToSpan(diagnosticsChannel.tracingChannel(CHANNELS.MONGODB_CHECKOUT), () => void 0);
+}
+function subscribeV3Wireprotocol() {
+  for (const operation of ["insert", "update", "remove"]) {
+    const channel = operation === "insert" ? CHANNELS.MONGODB_V3_INSERT : operation === "update" ? CHANNELS.MONGODB_V3_UPDATE : CHANNELS.MONGODB_V3_REMOVE;
+    bindV3(channel, (args) => ({
+      topology: args[0],
+      ns: args[1],
+      command: args[2]?.[0],
+      operation
+    }));
+  }
+  bindV3(CHANNELS.MONGODB_V3_COMMAND, (args) => {
+    const command = args[2];
+    const type = command ? Object.keys(command)[0] : void 0;
+    if (type && V3_DEDICATED_COMMANDS.has(type)) {
+      return void 0;
+    }
+    return {
+      topology: args[0],
+      ns: args[1],
+      command,
+      operation: command ? getV3CommandOperation(command) : void 0
+    };
+  });
+  bindV3(CHANNELS.MONGODB_V3_QUERY, (args) => ({
+    topology: args[0],
+    ns: args[1],
+    command: args[2],
+    operation: "find"
+  }));
+  bindV3(CHANNELS.MONGODB_V3_GET_MORE, (args) => ({
+    topology: args[0],
+    ns: args[1],
+    command: args[2]?.cmd,
+    operation: "getMore"
+  }));
+}
+function bindV3(channelName, extract) {
+  bindTracingChannelToSpan(
+    diagnosticsChannel.tracingChannel(channelName),
+    (data) => {
+      const args = data.arguments;
+      if (!args) {
+        return void 0;
+      }
+      const info = extract(args);
+      if (!info || typeof info.ns !== "string") {
+        return void 0;
+      }
+      return startMongoSpan(getV3SpanAttributes(info.ns, info.topology, info.command, info.operation, ORIGIN));
+    },
+    { requiresParentSpan: true }
+  );
+}
+const mongodbChannelIntegration = defineIntegration(_mongodbChannelIntegration);
+
+export { mongodbChannelIntegration };
+//# sourceMappingURL=mongodb.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mongodb.js","sources":["../../../../src/integrations/tracing-channel/mongodb.ts"],"sourcesContent":["import * as diagnosticsChannel from 'node:diagnostics_channel';\nimport type { IntegrationFn } from '@sentry/core';\nimport { defineIntegration, waitForTracingChannelBinding } from '@sentry/core';\nimport type { MongodbNamespace, MongoV3Topology } from '../../mongodb/mongodb-span';\nimport {\n  getV3CommandOperation,\n  getV3SpanAttributes,\n  getV4SpanAttributes,\n  startMongoSpan,\n} from '../../mongodb/mongodb-span';\nimport { CHANNELS } from '../../orchestrion/channels';\nimport { bindTracingChannelToSpan } from '../../tracing-channel';\n\nconst INTEGRATION_NAME = 'Mongo' as const;\n\nconst ORIGIN = 'auto.db.orchestrion.mongo';\n\n/**\n * what orchestrion's transform attaches to a channel context:\n * `self` is the `this`, plus args.\n */\ninterface MongoChannelContext {\n  self?: { address?: string };\n  arguments?: unknown[];\n}\n\n// Details extracted from a v3 wireprotocol call's arguments to build its span.\ninterface V3CallInfo {\n  topology: MongoV3Topology | undefined;\n  ns: string;\n  command: Record<string, unknown> | undefined;\n  operation: string | undefined;\n}\n\n// Command doc first-keys whose span the `v3_command` channel must suppress.\n// The `insert`/`update`/`remove`/`query`/`getMore` functions call the shared\n// `command` function internally. Orchestrion transforms the `command` *source*\n// (unlike the vendored OTel patch, which wraps the module's exported reference\n// and misses internal calls), so `v3_command` would double-span the ones that\n// already have their own dedicated channel (`v3_insert`/`update`/`remove`/\n// `query`/`get_more`) without this guard.\n//\n// `killCursors` has no dedicated channel, but is suppressed too for OTel\n// parity: OTel wraps `wireprotocol/index.js`'s `command` property, which never\n// intercepts `kill_cursors.js`'s direct `require('./command')` call — so OTel\n// emits no killCursors span, and neither should we.\nconst V3_DEDICATED_COMMANDS = new Set(['insert', 'update', 'delete', 'find', 'getMore', 'killCursors']);\n\nconst _mongodbChannelIntegration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      if (!diagnosticsChannel.tracingChannel) {\n        return;\n      }\n\n      waitForTracingChannelBinding(() => {\n        subscribeV4Command();\n        subscribeV4Checkout();\n        subscribeV3Wireprotocol();\n      });\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * `Connection.prototype.command` (mongodb >=4.0) one span per command.\n * Handles both the >=6.4 promise form and the >=4.0 <6.4 callback form\n * (both publish to this channel).\n */\nfunction subscribeV4Command(): void {\n  bindTracingChannelToSpan(\n    diagnosticsChannel.tracingChannel<MongoChannelContext>(CHANNELS.MONGODB_COMMAND),\n    data => {\n      const args = data.arguments ?? [];\n      const ns = args[0] as MongodbNamespace | undefined;\n      const cmd = args[1] as Record<string, unknown> | undefined;\n      // Skip handshake/heartbeat commands (matches otel).\n      if (!ns || !cmd || typeof cmd !== 'object' || cmd.ismaster || cmd.hello) {\n        return undefined;\n      }\n      const operation = Object.keys(cmd)[0];\n      return startMongoSpan(getV4SpanAttributes(data.self, ns, cmd, operation, ORIGIN));\n    },\n    // Matches otel's `shouldSkipInstrumentation`: only trace when there is\n    // an active parent span, to avoid emitting orphaned mongodb spans.\n    { requiresParentSpan: true },\n  );\n}\n\n/**\n * `ConnectionPool.prototype.checkOut` (mongodb 4.0 - 6.3, callback form).\n * Creates no span (`getSpan` returns `undefined`) but the binding re-runs\n * the checkout callback under the caller's captured context, so the pooled\n * `command()` invoked inside it re-inherits the active span.\n */\nfunction subscribeV4Checkout(): void {\n  bindTracingChannelToSpan(diagnosticsChannel.tracingChannel(CHANNELS.MONGODB_CHECKOUT), () => undefined);\n}\n\n/**\n * mongodb >=3.3 <4 had no unified `command`; each operation is a separate\n * `lib/core/wireprotocol` function with its own argument layout, so each\n * channel extracts topology/namespace/command/op differently before building\n * the span.\n */\nfunction subscribeV3Wireprotocol(): void {\n  for (const operation of ['insert', 'update', 'remove'] as const) {\n    const channel =\n      operation === 'insert'\n        ? CHANNELS.MONGODB_V3_INSERT\n        : operation === 'update'\n          ? CHANNELS.MONGODB_V3_UPDATE\n          : CHANNELS.MONGODB_V3_REMOVE;\n    bindV3(channel, args => ({\n      topology: args[0] as MongoV3Topology | undefined,\n      ns: args[1] as string,\n      command: (args[2] as Record<string, unknown>[] | undefined)?.[0],\n      operation,\n    }));\n  }\n\n  // `command`(server, ns, cmd, options, callback) operation derived from the\n  // command doc. Skips commands that have a dedicated channel. See set above.\n  bindV3(CHANNELS.MONGODB_V3_COMMAND, args => {\n    const command = args[2] as Record<string, unknown> | undefined;\n    const type = command ? Object.keys(command)[0] : undefined;\n    if (type && V3_DEDICATED_COMMANDS.has(type)) {\n      return undefined;\n    }\n    return {\n      topology: args[0] as MongoV3Topology | undefined,\n      ns: args[1] as string,\n      command,\n      operation: command ? getV3CommandOperation(command) : undefined,\n    };\n  });\n\n  // `query`(server, ns, cmd, cursorState, options, callback). a find.\n  bindV3(CHANNELS.MONGODB_V3_QUERY, args => ({\n    topology: args[0] as MongoV3Topology | undefined,\n    ns: args[1] as string,\n    command: args[2] as Record<string, unknown> | undefined,\n    operation: 'find',\n  }));\n\n  // `getMore`(server, ns, cursorState, batchSize, options, callback)\n  // command doc is `cursorState.cmd`.\n  bindV3(CHANNELS.MONGODB_V3_GET_MORE, args => ({\n    topology: args[0] as MongoV3Topology | undefined,\n    ns: args[1] as string,\n    command: (args[2] as { cmd?: Record<string, unknown> } | undefined)?.cmd,\n    operation: 'getMore',\n  }));\n}\n\nfunction bindV3(channelName: string, extract: (args: unknown[]) => V3CallInfo | undefined): void {\n  bindTracingChannelToSpan(\n    diagnosticsChannel.tracingChannel<MongoChannelContext>(channelName),\n    data => {\n      const args = data.arguments;\n      if (!args) {\n        return undefined;\n      }\n      const info = extract(args);\n      if (!info || typeof info.ns !== 'string') {\n        return undefined;\n      }\n      return startMongoSpan(getV3SpanAttributes(info.ns, info.topology, info.command, info.operation, ORIGIN));\n    },\n    { requiresParentSpan: true },\n  );\n}\n\n/**\n * EXPERIMENTAL: orchestrion-driven mongodb integration.\n *\n * Reproduces the vendored `@opentelemetry/instrumentation-mongodb` span shape\n * (legacy db/net semantic conventions, `mongodb.<op>` names, scrubbed\n * `db.statement`) via the `orchestrion:mongodb:*` diagnostics_channels\n * injected by the orchestrion code transform.\n */\nexport const mongodbChannelIntegration = defineIntegration(_mongodbChannelIntegration);\n"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,108 @@
+import * as diagnosticsChannel from 'node:diagnostics_channel';
+import { defineIntegration, waitForTracingChannelBinding, debug, getActiveSpan } from '@sentry/core';
+import { subscribeMongooseDiagnosticChannels } from '../../mongoose/mongoose-dc-subscriber.js';
+import { startMongooseLegacySpan } from '../../mongoose/mongoose-legacy-span.js';
+import { CHANNELS } from '../../orchestrion/channels.js';
+import { MONGOOSE_CONTEXT_CAPTURE_CHANNELS } from '../../orchestrion/config/mongoose.js';
+import { DEBUG_BUILD } from '../../debug-build.js';
+import { bindTracingChannelToSpan } from '../../tracing-channel.js';
+
+const INTEGRATION_NAME = "Mongoose";
+const ORIGIN = "auto.db.orchestrion.mongoose";
+const STORED_PARENT_SPAN = /* @__PURE__ */ new WeakMap();
+let orchestrionSubscribed = false;
+const _mongooseChannelIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      if (!diagnosticsChannel.tracingChannel) {
+        return;
+      }
+      waitForTracingChannelBinding(() => {
+        subscribeMongooseDiagnosticChannels(diagnosticsChannel.tracingChannel);
+        subscribeOrchestrionMongooseChannels();
+      });
+    }
+  };
+});
+function subscribeOrchestrionMongooseChannels() {
+  if (orchestrionSubscribed) {
+    return;
+  }
+  orchestrionSubscribed = true;
+  DEBUG_BUILD && debug.log("[orchestrion:mongoose] subscribing to injected channels");
+  for (const channelName of MONGOOSE_CONTEXT_CAPTURE_CHANNELS) {
+    channel(channelName).subscribe({
+      start(message) {
+        stashParentSpan(message.self);
+      }
+    });
+  }
+  channel(CHANNELS.MONGOOSE_MODEL_AGGREGATE).subscribe({
+    end(message) {
+      const result = message.result;
+      if (result && typeof result === "object") {
+        stashParentSpan(result);
+      }
+    }
+  });
+  bindExecSpan(CHANNELS.MONGOOSE_QUERY_EXEC, (self) => {
+    const query = self;
+    return startSpan(
+      query.mongooseCollection,
+      query.model?.modelName,
+      query.op ?? "exec",
+      STORED_PARENT_SPAN.get(self)
+    );
+  });
+  bindExecSpan(CHANNELS.MONGOOSE_AGGREGATE_EXEC, (self) => {
+    const model = self._model;
+    return startSpan(model?.collection, model?.modelName, "aggregate", STORED_PARENT_SPAN.get(self));
+  });
+  bindExecSpan(CHANNELS.MONGOOSE_MODEL_SAVE, (self) => {
+    const ctor = self.constructor;
+    return startSpan(ctor.collection, ctor.modelName, "save");
+  });
+  bindExecSpan(CHANNELS.MONGOOSE_MODEL_REMOVE, (self) => {
+    const ctor = self.constructor;
+    return startSpan(ctor.collection, ctor.modelName, "remove");
+  });
+  bindExecSpan(CHANNELS.MONGOOSE_MODEL_INSERT_MANY, (self) => {
+    const model = self;
+    return startSpan(model.collection, model.modelName, "insertMany");
+  });
+  bindExecSpan(CHANNELS.MONGOOSE_MODEL_BULK_WRITE, (self) => {
+    const model = self;
+    return startSpan(model.collection, model.modelName, "bulkWrite");
+  });
+}
+function startSpan(collection, modelName, operation, parentSpan) {
+  return startMongooseLegacySpan({ collection, modelName, operation, origin: ORIGIN, parentSpan });
+}
+function channel(channelName) {
+  return diagnosticsChannel.tracingChannel(
+    channelName
+  );
+}
+function bindExecSpan(channelName, getSpan) {
+  bindTracingChannelToSpan(
+    diagnosticsChannel.tracingChannel(channelName),
+    (data) => {
+      const self = data.self;
+      if (!self) {
+        return void 0;
+      }
+      return getSpan(self);
+    }
+  );
+}
+function stashParentSpan(self) {
+  const active = getActiveSpan();
+  if (self && active) {
+    STORED_PARENT_SPAN.set(self, active);
+  }
+}
+const mongooseChannelIntegration = defineIntegration(_mongooseChannelIntegration);
+
+export { mongooseChannelIntegration };
+//# sourceMappingURL=mongoose.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mongoose.js","sources":["../../../../src/integrations/tracing-channel/mongoose.ts"],"sourcesContent":["import * as diagnosticsChannel from 'node:diagnostics_channel';\nimport type { IntegrationFn, Span } from '@sentry/core';\nimport { debug, defineIntegration, getActiveSpan, waitForTracingChannelBinding } from '@sentry/core';\nimport { subscribeMongooseDiagnosticChannels } from '../../mongoose/mongoose-dc-subscriber';\nimport type { MongooseLegacyCollection } from '../../mongoose/mongoose-legacy-span';\nimport { startMongooseLegacySpan } from '../../mongoose/mongoose-legacy-span';\nimport { CHANNELS } from '../../orchestrion/channels';\nimport { MONGOOSE_CONTEXT_CAPTURE_CHANNELS } from '../../orchestrion/config/mongoose';\nimport { DEBUG_BUILD } from '../../debug-build';\nimport type { SentryTracingChannel } from '../../tracing-channel';\nimport { bindTracingChannelToSpan } from '../../tracing-channel';\n\nconst INTEGRATION_NAME = 'Mongoose' as const;\n\n// Origin distinguishes the orchestrion path from the OTel/IITM path\n// (`auto.db.otel.mongoose`) and the native diagnostics_channel path\n// (`auto.db.mongoose.diagnostic_channel`).\nconst ORIGIN = 'auto.db.orchestrion.mongoose';\n\ninterface MongooseQuery {\n  mongooseCollection?: MongooseLegacyCollection;\n  model?: { modelName?: string };\n  op?: string;\n}\n\ninterface MongooseAggregate {\n  _model?: { collection?: MongooseLegacyCollection; modelName?: string };\n}\n\ninterface MongooseModelStatic {\n  collection?: MongooseLegacyCollection;\n  modelName?: string;\n}\n\ninterface MongooseDocument {\n  constructor: { collection?: MongooseLegacyCollection; modelName?: string };\n}\n\n/**\n * The shape orchestrion's transform attaches to the tracing-channel context\n * object. `self` is the `this` of the traced method\n */\ninterface MongooseChannelContext {\n  self?: object;\n  arguments?: unknown[];\n  result?: unknown;\n  error?: unknown;\n  moduleVersion?: string;\n}\n\n// The active span captured when a query/aggregate was *built*, keyed by the\n// query/aggregate object.\n//\n// Used as the parent for the span created at `exec()` so a query parents to\n// where it was built, not where it happens to be awaited. A WeakMap avoids\n// mutating mongoose's own objects.\nconst STORED_PARENT_SPAN = new WeakMap<object, Span>();\n\nlet orchestrionSubscribed = false;\n\nconst _mongooseChannelIntegration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      if (!diagnosticsChannel.tracingChannel) {\n        return;\n      }\n\n      waitForTracingChannelBinding(() => {\n        // mongoose >= 9.7 publishes via its own diagnostics_channel; reuse\n        // the shared native subscriber so this single integration covers all\n        // versions after it replaces the OTel one. Idempotent and inert on\n        // < 9.7 (those channels just never get published to)\n        subscribeMongooseDiagnosticChannels(diagnosticsChannel.tracingChannel);\n\n        // mongoose < 9.7 is covered by the orchestrion-injected channels.\n        subscribeOrchestrionMongooseChannels();\n      });\n    },\n  };\n}) satisfies IntegrationFn;\n\nfunction subscribeOrchestrionMongooseChannels(): void {\n  if (orchestrionSubscribed) {\n    return;\n  }\n  orchestrionSubscribed = true;\n\n  DEBUG_BUILD && debug.log('[orchestrion:mongoose] subscribing to injected channels');\n\n  // Context-capture builders: stash the active span at build time so `exec()`\n  // can parent to it.\n  for (const channelName of MONGOOSE_CONTEXT_CAPTURE_CHANNELS) {\n    channel(channelName).subscribe({\n      start(message) {\n        stashParentSpan(message.self);\n      },\n    });\n  }\n\n  // `Model.aggregate()` returns the aggregate it builds; stash the parent on\n  // the returned object.\n  channel(CHANNELS.MONGOOSE_MODEL_AGGREGATE).subscribe({\n    end(message) {\n      const result = message.result;\n      if (result && typeof result === 'object') {\n        stashParentSpan(result);\n      }\n    },\n  });\n\n  // Query execution.\n  bindExecSpan(CHANNELS.MONGOOSE_QUERY_EXEC, self => {\n    const query = self as MongooseQuery;\n    return startSpan(\n      query.mongooseCollection,\n      query.model?.modelName,\n      query.op ?? 'exec',\n      STORED_PARENT_SPAN.get(self),\n    );\n  });\n\n  // Aggregation execution.\n  bindExecSpan(CHANNELS.MONGOOSE_AGGREGATE_EXEC, self => {\n    const model = (self as MongooseAggregate)._model;\n    return startSpan(model?.collection, model?.modelName, 'aggregate', STORED_PARENT_SPAN.get(self));\n  });\n\n  // `doc.save()` (and the `$save` alias).\n  bindExecSpan(CHANNELS.MONGOOSE_MODEL_SAVE, self => {\n    const ctor = (self as MongooseDocument).constructor;\n    return startSpan(ctor.collection, ctor.modelName, 'save');\n  });\n\n  // `doc.remove()` (mongoose 5/6).\n  bindExecSpan(CHANNELS.MONGOOSE_MODEL_REMOVE, self => {\n    const ctor = (self as MongooseDocument).constructor;\n    return startSpan(ctor.collection, ctor.modelName, 'remove');\n  });\n\n  // Static batch operations. `self` is the Model.\n  bindExecSpan(CHANNELS.MONGOOSE_MODEL_INSERT_MANY, self => {\n    const model = self as MongooseModelStatic;\n    return startSpan(model.collection, model.modelName, 'insertMany');\n  });\n  bindExecSpan(CHANNELS.MONGOOSE_MODEL_BULK_WRITE, self => {\n    const model = self as MongooseModelStatic;\n    return startSpan(model.collection, model.modelName, 'bulkWrite');\n  });\n}\n\nfunction startSpan(\n  collection: MongooseLegacyCollection | undefined,\n  modelName: string | undefined,\n  operation: string,\n  parentSpan?: Span,\n): Span {\n  return startMongooseLegacySpan({ collection, modelName, operation, origin: ORIGIN, parentSpan });\n}\n\n// `SentryTracingChannel` relaxes Node's subscriber type to a `Partial`, so a\n// `start`-only (or `end`-only) subscriber for the context-capture channels\n// is accepted.\nfunction channel(channelName: string): SentryTracingChannel<MongooseChannelContext> {\n  return diagnosticsChannel.tracingChannel<MongooseChannelContext>(\n    channelName,\n  ) as unknown as SentryTracingChannel<MongooseChannelContext>;\n}\n\nfunction bindExecSpan(channelName: string, getSpan: (self: object) => Span): void {\n  bindTracingChannelToSpan<MongooseChannelContext>(\n    diagnosticsChannel.tracingChannel<MongooseChannelContext>(channelName),\n    data => {\n      const self = data.self;\n      if (!self) {\n        return undefined;\n      }\n      return getSpan(self);\n    },\n  );\n}\n\nfunction stashParentSpan(self: object | undefined): void {\n  const active = getActiveSpan();\n  if (self && active) {\n    STORED_PARENT_SPAN.set(self, active);\n  }\n}\n\n/**\n * EXPERIMENTAL: orchestrion-driven mongoose integration.\n *\n * Reproduces the vendored `@opentelemetry/instrumentation-mongoose` span\n * shape (legacy db/net semantic conventions, `mongoose.<Model>.<op>` names,\n * build-time span parenting) via the `orchestrion:mongoose:*`\n * diagnostics_channels injected into mongoose `< 9.7` by the orchestrion\n * code transform. For mongoose `>= 9.7` it also drives the native\n * diagnostics_channel subscription, so this single integration covers every\n * supported version once it replaces the OTel one.\n */\nexport const mongooseChannelIntegration = defineIntegration(_mongooseChannelIntegration);\n"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,105 @@
+import * as diagnosticsChannel from 'node:diagnostics_channel';
+import { defineIntegration, debug, waitForTracingChannelBinding, 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 = "Mysql";
+const ATTR_DB_SYSTEM = "db.system";
+const ATTR_DB_CONNECTION_STRING = "db.connection_string";
+const ATTR_DB_NAME = "db.name";
+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 _mysqlChannelIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      if (!diagnosticsChannel.tracingChannel) {
+        return;
+      }
+      DEBUG_BUILD && debug.log(`[orchestrion:mysql] subscribing to channel "${CHANNELS.MYSQL_QUERY}"`);
+      waitForTracingChannelBinding(() => {
+        bindTracingChannelToSpan(
+          diagnosticsChannel.tracingChannel(CHANNELS.MYSQL_QUERY),
+          (data) => {
+            const sql = extractSql(data.arguments[0]);
+            const { host, port, database, user } = getConnectionConfig(data.self);
+            const portNumber = typeof port === "string" ? parseInt(port, 10) : port;
+            const portIsNumber = typeof portNumber === "number" && !isNaN(portNumber);
+            data._sentryCallerScope = getCurrentScope();
+            return startInactiveSpan({
+              name: sql ?? "mysql.query",
+              kind: SPAN_KIND.CLIENT,
+              op: "db",
+              attributes: {
+                [ATTR_DB_SYSTEM]: "mysql",
+                [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.db.orchestrion.mysql",
+                [ATTR_DB_CONNECTION_STRING]: getJDBCString(host, portIsNumber ? portNumber : void 0, database),
+                ...database ? { [ATTR_DB_NAME]: database } : {},
+                ...user ? { [ATTR_DB_USER]: user } : {},
+                ...sql ? { [ATTR_DB_STATEMENT]: sql } : {},
+                ...host ? { [ATTR_NET_PEER_NAME]: host } : {},
+                ...portIsNumber ? { [ATTR_NET_PEER_PORT]: portNumber } : {}
+              }
+            });
+          },
+          {
+            // No-callback `query(sql)` returns a streamable `Query` emitter as `result`; it settles on the
+            // emitter's `'end'`/`'error'`, not the channel, so defer ending to those.
+            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;
+            }
+          }
+        );
+      });
+    }
+  };
+});
+function hasOnMethod(obj) {
+  return "on" in obj && typeof obj.on === "function";
+}
+function extractSql(firstArg) {
+  if (typeof firstArg === "string") {
+    return firstArg;
+  }
+  if (isObjectLike(firstArg) && "sql" in firstArg) {
+    const sql = firstArg.sql;
+    return typeof sql === "string" ? sql : void 0;
+  }
+  return void 0;
+}
+function getConnectionConfig(connection) {
+  const config = connection?.config?.connectionConfig ?? connection?.config ?? {};
+  return {
+    host: config.host,
+    port: config.port,
+    database: config.database,
+    user: config.user
+  };
+}
+function getJDBCString(host, port, database) {
+  let s = `jdbc:mysql://${host || "localhost"}`;
+  if (typeof port === "number") {
+    s += `:${port}`;
+  }
+  if (database) {
+    s += `/${database}`;
+  }
+  return s;
+}
+const mysqlChannelIntegration = defineIntegration(_mysqlChannelIntegration);
+
+export { mysqlChannelIntegration };
+//# sourceMappingURL=mysql.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mysql.js","sources":["../../../../src/integrations/tracing-channel/mysql.ts"],"sourcesContent":["import * as diagnosticsChannel from 'node:diagnostics_channel';\nimport type { IntegrationFn, Scope } 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, OTel 'Mysql' integration is omitted from the default set.\nconst INTEGRATION_NAME = 'Mysql' as const;\n\n// OTel \"OLD\" db/net semantic-conventions, inlined to keep this integration free of OTel deps. Matches\n// `@opentelemetry/instrumentation-mysql`'s default and the SDK's `inferDbSpanData` (which renames spans\n// off `db.statement`).\nconst ATTR_DB_SYSTEM = 'db.system';\nconst ATTR_DB_CONNECTION_STRING = 'db.connection_string';\nconst ATTR_DB_NAME = 'db.name';\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';\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 MysqlQueryChannelContext {\n  // The live args array passed to the wrapped `connection.query` call; `arguments[0]` is the SQL.\n  arguments: unknown[];\n  self?: MysqlConnection;\n  moduleVersion?: string;\n  result?: unknown;\n  error?: unknown;\n  // The caller's scope, captured at `start` and replayed onto the streamed `Query` emitter (see below).\n  _sentryCallerScope?: Scope;\n}\n\ninterface MysqlConnectionConfig {\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?: MysqlConnectionConfig;\n}\n\ninterface MysqlConnection {\n  config?: MysqlConnectionConfig;\n}\n\nconst _mysqlChannelIntegration = (() => {\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      DEBUG_BUILD && debug.log(`[orchestrion:mysql] subscribing to channel \"${CHANNELS.MYSQL_QUERY}\"`);\n\n      waitForTracingChannelBinding(() => {\n        bindTracingChannelToSpan(\n          diagnosticsChannel.tracingChannel<MysqlQueryChannelContext>(CHANNELS.MYSQL_QUERY),\n          data => {\n            const sql = extractSql(data.arguments[0]);\n            const { host, port, database, user } = getConnectionConfig(data.self);\n            const portNumber = typeof port === 'string' ? parseInt(port, 10) : port;\n            const portIsNumber = typeof portNumber === 'number' && !isNaN(portNumber);\n\n            // For the streamed path: mysql emits the `Query` emitter's events from its socket data\n            // handler with the caller's context lost. `deferSpanEnd` replays this scope onto the emitter.\n            data._sentryCallerScope = getCurrentScope();\n\n            return startInactiveSpan({\n              name: sql ?? 'mysql.query',\n              kind: SPAN_KIND.CLIENT,\n              op: 'db',\n              attributes: {\n                [ATTR_DB_SYSTEM]: 'mysql',\n                [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.db.orchestrion.mysql',\n                [ATTR_DB_CONNECTION_STRING]: getJDBCString(host, portIsNumber ? portNumber : undefined, database),\n                ...(database ? { [ATTR_DB_NAME]: database } : {}),\n                ...(user ? { [ATTR_DB_USER]: user } : {}),\n                ...(sql ? { [ATTR_DB_STATEMENT]: sql } : {}),\n                ...(host ? { [ATTR_NET_PEER_NAME]: host } : {}),\n                ...(portIsNumber ? { [ATTR_NET_PEER_PORT]: portNumber } : {}),\n              },\n            });\n          },\n          {\n            // No-callback `query(sql)` returns a streamable `Query` emitter as `result`; it settles on the\n            // emitter's `'end'`/`'error'`, not the channel, so defer ending to those.\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 so user listeners on the emitter nest under it, not a new 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        );\n      });\n    },\n  };\n}) satisfies IntegrationFn;\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\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 getConnectionConfig(connection: MysqlConnection | undefined): {\n  host?: string;\n  port?: number | string;\n  database?: string;\n  user?: string;\n} {\n  // Pool connections nest the real config under `.connectionConfig`; single\n  // connections expose it directly. Matches `@opentelemetry/instrumentation-mysql`.\n  const config = connection?.config?.connectionConfig ?? connection?.config ?? {};\n  return {\n    host: config.host,\n    port: config.port,\n    database: config.database,\n    user: config.user,\n  };\n}\n\nfunction getJDBCString(host: string | undefined, port: number | undefined, database: string | undefined): string {\n  let s = `jdbc:mysql://${host || 'localhost'}`;\n  if (typeof port === 'number') {\n    s += `:${port}`;\n  }\n  if (database) {\n    s += `/${database}`;\n  }\n  return s;\n}\n\n/**\n * EXPERIMENTAL — orchestrion-driven mysql integration.\n *\n * Subscribes to the `orchestrion:mysql:query` diagnostics_channel that the\n * orchestrion code transform injects into `mysql/lib/Connection.js`'s\n * `Connection.prototype.query`. Requires the orchestrion runtime hook or\n * bundler plugin to be active — wire that up via `_experimentalSetupOrchestrion`.\n */\nexport const mysqlChannelIntegration = defineIntegration(_mysqlChannelIntegration);\n"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,81 @@
+import * as diagnosticsChannel from 'node:diagnostics_channel';
+import { defineIntegration, waitForTracingChannelBinding, startInactiveSpan, SPAN_KIND, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, isObjectLike } from '@sentry/core';
+import { subscribeMysql2DiagnosticChannels } from '../../mysql2/mysql2-dc-subscriber.js';
+import { CHANNELS } from '../../orchestrion/channels.js';
+import { bindTracingChannelToSpan } from '../../tracing-channel.js';
+import { DB_STATEMENT, DB_SYSTEM, NET_PEER_PORT, NET_PEER_NAME, DB_USER, DB_NAME } from '@sentry/conventions/attributes';
+
+const INTEGRATION_NAME = "Mysql2";
+const ORIGIN = "auto.db.orchestrion.mysql2";
+const DB_SYSTEM_VALUE_MYSQL = "mysql";
+function instrumentMysql2() {
+  subscribeMysql2DiagnosticChannels(diagnosticsChannel.tracingChannel);
+  subscribeQueryChannel(CHANNELS.MYSQL2_QUERY);
+  subscribeQueryChannel(CHANNELS.MYSQL2_EXECUTE);
+}
+function subscribeQueryChannel(channelName) {
+  bindTracingChannelToSpan(
+    diagnosticsChannel.tracingChannel(channelName),
+    (data) => {
+      const statement = getQueryText(data.arguments);
+      return startInactiveSpan({
+        name: statement ?? "mysql2.query",
+        kind: SPAN_KIND.CLIENT,
+        attributes: {
+          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN,
+          [SEMANTIC_ATTRIBUTE_SENTRY_OP]: "db",
+          // oxlint-disable-next-line typescript/no-deprecated
+          [DB_SYSTEM]: DB_SYSTEM_VALUE_MYSQL,
+          ...getConnectionAttributes(data.self?.config),
+          // oxlint-disable-next-line typescript/no-deprecated
+          [DB_STATEMENT]: statement || void 0
+        }
+      });
+    },
+    { requiresParentSpan: true }
+  );
+}
+function getQueryText(args) {
+  return extractSql(args[0]);
+}
+function extractSql(firstArg) {
+  if (typeof firstArg === "string") {
+    return firstArg;
+  }
+  if (isObjectLike(firstArg) && "sql" in firstArg) {
+    const sql = firstArg.sql;
+    return typeof sql === "string" ? sql : void 0;
+  }
+  return void 0;
+}
+function getConnectionAttributes(config) {
+  const { host, port, database, user } = config?.connectionConfig ?? config ?? {};
+  const portNumber = typeof port === "string" ? parseInt(port, 10) : port;
+  const portIsNumber = typeof portNumber === "number" && !isNaN(portNumber);
+  return {
+    // oxlint-disable-next-line typescript/no-deprecated
+    [DB_NAME]: database || void 0,
+    [DB_USER]: user || void 0,
+    // oxlint-disable-next-line typescript/no-deprecated
+    [NET_PEER_NAME]: host || void 0,
+    // oxlint-disable-next-line typescript/no-deprecated
+    [NET_PEER_PORT]: portIsNumber ? portNumber : void 0
+  };
+}
+const _mysql2ChannelIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      if (!diagnosticsChannel.tracingChannel) {
+        return;
+      }
+      waitForTracingChannelBinding(() => {
+        instrumentMysql2();
+      });
+    }
+  };
+});
+const mysql2ChannelIntegration = defineIntegration(_mysql2ChannelIntegration);
+
+export { mysql2ChannelIntegration };
+//# sourceMappingURL=mysql2.js.map