@depup/sentry__server-utils 10.67.0-depup.0

package/build/cjs/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":["DEBUG_BUILD","debug","CHANNELS","waitForTracingChannelBinding","bindTracingChannelToSpan","defineIntegration"],"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,MAAAA,sBAAA,IAAeC,UAAA,CAAM,GAAA,CAAI,CAAA,mDAAA,EAAsDC,iBAAA,CAAS,iBAAiB,CAAA,CAAA,CAAG,CAAA;AAE5G,MAAAC,iCAAA,CAA6B,MAAM;AACjC,QAAAC,uCAAA;AAAA,UACE,kBAAA,CAAmB,cAAA,CAAuCF,iBAAA,CAAS,iBAAiB,CAAA;AAAA;AAAA,UAEpF,MAAM;AAAA,SACR;AAAA,MACF,CAAC,CAAA;AAAA,IACH;AAAA,GACF;AACF,CAAA,CAAA;AAQO,MAAM,6BAAA,GAAgCG,uBAAkB,8BAA8B;;;;"}

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

@@ -0,0 +1,104 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const diagnosticsChannel = require('node:diagnostics_channel');
+const core = require('@sentry/core');
+const mongodbSpan = require('../../mongodb/mongodb-span.js');
+const channels = require('../../orchestrion/channels.js');
+const tracingChannel = require('../../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;
+      }
+      core.waitForTracingChannelBinding(() => {
+        subscribeV4Command();
+        subscribeV4Checkout();
+        subscribeV3Wireprotocol();
+      });
+    }
+  };
+});
+function subscribeV4Command() {
+  tracingChannel.bindTracingChannelToSpan(
+    diagnosticsChannel.tracingChannel(channels.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 mongodbSpan.startMongoSpan(mongodbSpan.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() {
+  tracingChannel.bindTracingChannelToSpan(diagnosticsChannel.tracingChannel(channels.CHANNELS.MONGODB_CHECKOUT), () => void 0);
+}
+function subscribeV3Wireprotocol() {
+  for (const operation of ["insert", "update", "remove"]) {
+    const channel = operation === "insert" ? channels.CHANNELS.MONGODB_V3_INSERT : operation === "update" ? channels.CHANNELS.MONGODB_V3_UPDATE : channels.CHANNELS.MONGODB_V3_REMOVE;
+    bindV3(channel, (args) => ({
+      topology: args[0],
+      ns: args[1],
+      command: args[2]?.[0],
+      operation
+    }));
+  }
+  bindV3(channels.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 ? mongodbSpan.getV3CommandOperation(command) : void 0
+    };
+  });
+  bindV3(channels.CHANNELS.MONGODB_V3_QUERY, (args) => ({
+    topology: args[0],
+    ns: args[1],
+    command: args[2],
+    operation: "find"
+  }));
+  bindV3(channels.CHANNELS.MONGODB_V3_GET_MORE, (args) => ({
+    topology: args[0],
+    ns: args[1],
+    command: args[2]?.cmd,
+    operation: "getMore"
+  }));
+}
+function bindV3(channelName, extract) {
+  tracingChannel.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 mongodbSpan.startMongoSpan(mongodbSpan.getV3SpanAttributes(info.ns, info.topology, info.command, info.operation, ORIGIN));
+    },
+    { requiresParentSpan: true }
+  );
+}
+const mongodbChannelIntegration = core.defineIntegration(_mongodbChannelIntegration);
+
+exports.mongodbChannelIntegration = mongodbChannelIntegration;
+//# sourceMappingURL=mongodb.js.map

package/build/cjs/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":["waitForTracingChannelBinding","bindTracingChannelToSpan","CHANNELS","startMongoSpan","getV4SpanAttributes","getV3CommandOperation","getV3SpanAttributes","defineIntegration"],"mappings":"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"}

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

@@ -0,0 +1,110 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const diagnosticsChannel = require('node:diagnostics_channel');
+const core = require('@sentry/core');
+const mongooseDcSubscriber = require('../../mongoose/mongoose-dc-subscriber.js');
+const mongooseLegacySpan = require('../../mongoose/mongoose-legacy-span.js');
+const channels = require('../../orchestrion/channels.js');
+const mongoose = require('../../orchestrion/config/mongoose.js');
+const debugBuild = require('../../debug-build.js');
+const tracingChannel = require('../../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;
+      }
+      core.waitForTracingChannelBinding(() => {
+        mongooseDcSubscriber.subscribeMongooseDiagnosticChannels(diagnosticsChannel.tracingChannel);
+        subscribeOrchestrionMongooseChannels();
+      });
+    }
+  };
+});
+function subscribeOrchestrionMongooseChannels() {
+  if (orchestrionSubscribed) {
+    return;
+  }
+  orchestrionSubscribed = true;
+  debugBuild.DEBUG_BUILD && core.debug.log("[orchestrion:mongoose] subscribing to injected channels");
+  for (const channelName of mongoose.MONGOOSE_CONTEXT_CAPTURE_CHANNELS) {
+    channel(channelName).subscribe({
+      start(message) {
+        stashParentSpan(message.self);
+      }
+    });
+  }
+  channel(channels.CHANNELS.MONGOOSE_MODEL_AGGREGATE).subscribe({
+    end(message) {
+      const result = message.result;
+      if (result && typeof result === "object") {
+        stashParentSpan(result);
+      }
+    }
+  });
+  bindExecSpan(channels.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.CHANNELS.MONGOOSE_AGGREGATE_EXEC, (self) => {
+    const model = self._model;
+    return startSpan(model?.collection, model?.modelName, "aggregate", STORED_PARENT_SPAN.get(self));
+  });
+  bindExecSpan(channels.CHANNELS.MONGOOSE_MODEL_SAVE, (self) => {
+    const ctor = self.constructor;
+    return startSpan(ctor.collection, ctor.modelName, "save");
+  });
+  bindExecSpan(channels.CHANNELS.MONGOOSE_MODEL_REMOVE, (self) => {
+    const ctor = self.constructor;
+    return startSpan(ctor.collection, ctor.modelName, "remove");
+  });
+  bindExecSpan(channels.CHANNELS.MONGOOSE_MODEL_INSERT_MANY, (self) => {
+    const model = self;
+    return startSpan(model.collection, model.modelName, "insertMany");
+  });
+  bindExecSpan(channels.CHANNELS.MONGOOSE_MODEL_BULK_WRITE, (self) => {
+    const model = self;
+    return startSpan(model.collection, model.modelName, "bulkWrite");
+  });
+}
+function startSpan(collection, modelName, operation, parentSpan) {
+  return mongooseLegacySpan.startMongooseLegacySpan({ collection, modelName, operation, origin: ORIGIN, parentSpan });
+}
+function channel(channelName) {
+  return diagnosticsChannel.tracingChannel(
+    channelName
+  );
+}
+function bindExecSpan(channelName, getSpan) {
+  tracingChannel.bindTracingChannelToSpan(
+    diagnosticsChannel.tracingChannel(channelName),
+    (data) => {
+      const self = data.self;
+      if (!self) {
+        return void 0;
+      }
+      return getSpan(self);
+    }
+  );
+}
+function stashParentSpan(self) {
+  const active = core.getActiveSpan();
+  if (self && active) {
+    STORED_PARENT_SPAN.set(self, active);
+  }
+}
+const mongooseChannelIntegration = core.defineIntegration(_mongooseChannelIntegration);
+
+exports.mongooseChannelIntegration = mongooseChannelIntegration;
+//# sourceMappingURL=mongoose.js.map

package/build/cjs/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":["waitForTracingChannelBinding","subscribeMongooseDiagnosticChannels","DEBUG_BUILD","debug","MONGOOSE_CONTEXT_CAPTURE_CHANNELS","CHANNELS","startMongooseLegacySpan","bindTracingChannelToSpan","getActiveSpan","defineIntegration"],"mappings":"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"}

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

@@ -0,0 +1,107 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const diagnosticsChannel = require('node:diagnostics_channel');
+const core = require('@sentry/core');
+const debugBuild = require('../../debug-build.js');
+const channels = require('../../orchestrion/channels.js');
+const tracingChannel = require('../../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;
+      }
+      debugBuild.DEBUG_BUILD && core.debug.log(`[orchestrion:mysql] subscribing to channel "${channels.CHANNELS.MYSQL_QUERY}"`);
+      core.waitForTracingChannelBinding(() => {
+        tracingChannel.bindTracingChannelToSpan(
+          diagnosticsChannel.tracingChannel(channels.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 = core.getCurrentScope();
+            return core.startInactiveSpan({
+              name: sql ?? "mysql.query",
+              kind: core.SPAN_KIND.CLIENT,
+              op: "db",
+              attributes: {
+                [ATTR_DB_SYSTEM]: "mysql",
+                [core.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) {
+                core.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 (core.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 = core.defineIntegration(_mysqlChannelIntegration);
+
+exports.mysqlChannelIntegration = mysqlChannelIntegration;
+//# sourceMappingURL=mysql.js.map

package/build/cjs/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":["DEBUG_BUILD","debug","CHANNELS","waitForTracingChannelBinding","bindTracingChannelToSpan","getCurrentScope","startInactiveSpan","SPAN_KIND","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN","bindScopeToEmitter","isObjectLike","defineIntegration"],"mappings":";;;;;;;;AAmBA,MAAM,gBAAA,GAAmB,OAAA;AAKzB,MAAM,cAAA,GAAiB,WAAA;AACvB,MAAM,yBAAA,GAA4B,sBAAA;AAClC,MAAM,YAAA,GAAe,SAAA;AACrB,MAAM,YAAA,GAAe,SAAA;AACrB,MAAM,iBAAA,GAAoB,cAAA;AAC1B,MAAM,kBAAA,GAAqB,eAAA;AAC3B,MAAM,kBAAA,GAAqB,eAAA;AA8B3B,MAAM,4BAA4B,MAAM;AACtC,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,SAAA,GAAY;AAEV,MAAA,IAAI,CAAC,mBAAmB,cAAA,EAAgB;AACtC,QAAA;AAAA,MACF;AAEA,MAAAA,sBAAA,IAAeC,UAAA,CAAM,GAAA,CAAI,CAAA,4CAAA,EAA+CC,iBAAA,CAAS,WAAW,CAAA,CAAA,CAAG,CAAA;AAE/F,MAAAC,iCAAA,CAA6B,MAAM;AACjC,QAAAC,uCAAA;AAAA,UACE,kBAAA,CAAmB,cAAA,CAAyCF,iBAAA,CAAS,WAAW,CAAA;AAAA,UAChF,CAAA,IAAA,KAAQ;AACN,YAAA,MAAM,GAAA,GAAM,UAAA,CAAW,IAAA,CAAK,SAAA,CAAU,CAAC,CAAC,CAAA;AACxC,YAAA,MAAM,EAAE,MAAM,IAAA,EAAM,QAAA,EAAU,MAAK,GAAI,mBAAA,CAAoB,KAAK,IAAI,CAAA;AACpE,YAAA,MAAM,aAAa,OAAO,IAAA,KAAS,WAAW,QAAA,CAAS,IAAA,EAAM,EAAE,CAAA,GAAI,IAAA;AACnE,YAAA,MAAM,eAAe,OAAO,UAAA,KAAe,QAAA,IAAY,CAAC,MAAM,UAAU,CAAA;AAIxE,YAAA,IAAA,CAAK,qBAAqBG,oBAAA,EAAgB;AAE1C,YAAA,OAAOC,sBAAA,CAAkB;AAAA,cACvB,MAAM,GAAA,IAAO,aAAA;AAAA,cACb,MAAMC,cAAA,CAAU,MAAA;AAAA,cAChB,EAAA,EAAI,IAAA;AAAA,cACJ,UAAA,EAAY;AAAA,gBACV,CAAC,cAAc,GAAG,OAAA;AAAA,gBAClB,CAACC,qCAAgC,GAAG,2BAAA;AAAA,gBACpC,CAAC,yBAAyB,GAAG,aAAA,CAAc,MAAM,YAAA,GAAe,UAAA,GAAa,QAAW,QAAQ,CAAA;AAAA,gBAChG,GAAI,WAAW,EAAE,CAAC,YAAY,GAAG,QAAA,KAAa,EAAC;AAAA,gBAC/C,GAAI,OAAO,EAAE,CAAC,YAAY,GAAG,IAAA,KAAS,EAAC;AAAA,gBACvC,GAAI,MAAM,EAAE,CAAC,iBAAiB,GAAG,GAAA,KAAQ,EAAC;AAAA,gBAC1C,GAAI,OAAO,EAAE,CAAC,kBAAkB,GAAG,IAAA,KAAS,EAAC;AAAA,gBAC7C,GAAI,eAAe,EAAE,CAAC,kBAAkB,GAAG,UAAA,KAAe;AAAC;AAC7D,aACD,CAAA;AAAA,UACH,CAAA;AAAA,UACA;AAAA;AAAA;AAAA,YAGE,YAAA,CAAa,EAAE,IAAA,EAAM,GAAA,EAAI,EAAG;AAC1B,cAAA,MAAM,SAAS,IAAA,CAAK,MAAA;AACpB,cAAA,IAAI,CAAC,UAAU,OAAO,MAAA,KAAW,YAAY,CAAC,WAAA,CAAY,MAAM,CAAA,EAAG;AACjE,gBAAA,OAAO,KAAA;AAAA,cACT;AAGA,cAAA,MAAM,cAAc,IAAA,CAAK,kBAAA;AACzB,cAAA,IAAI,WAAA,EAAa;AACf,gBAAAC,uBAAA,CAAmB,QAAQ,WAAW,CAAA;AAAA,cACxC;AAEA,cAAA,MAAA,CAAO,EAAA,CAAG,OAAA,EAAS,CAAA,GAAA,KAAO,GAAA,CAAI,GAAG,CAAC,CAAA;AAClC,cAAA,MAAA,CAAO,EAAA,CAAG,KAAA,EAAO,MAAM,GAAA,EAAK,CAAA;AAE5B,cAAA,OAAO,IAAA;AAAA,YACT;AAAA;AACF,SACF;AAAA,MACF,CAAC,CAAA;AAAA,IACH;AAAA,GACF;AACF,CAAA,CAAA;AAEA,SAAS,YAAY,GAAA,EAA2F;AAC9G,EAAA,OAAO,IAAA,IAAQ,GAAA,IAAO,OAAQ,GAAA,CAAyB,EAAA,KAAO,UAAA;AAChE;AAEA,SAAS,WAAW,QAAA,EAAuC;AACzD,EAAA,IAAI,OAAO,aAAa,QAAA,EAAU;AAChC,IAAA,OAAO,QAAA;AAAA,EACT;AACA,EAAA,IAAIC,iBAAA,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,oBAAoB,UAAA,EAK3B;AAGA,EAAA,MAAM,SAAS,UAAA,EAAY,MAAA,EAAQ,gBAAA,IAAoB,UAAA,EAAY,UAAU,EAAC;AAC9E,EAAA,OAAO;AAAA,IACL,MAAM,MAAA,CAAO,IAAA;AAAA,IACb,MAAM,MAAA,CAAO,IAAA;AAAA,IACb,UAAU,MAAA,CAAO,QAAA;AAAA,IACjB,MAAM,MAAA,CAAO;AAAA,GACf;AACF;AAEA,SAAS,aAAA,CAAc,IAAA,EAA0B,IAAA,EAA0B,QAAA,EAAsC;AAC/G,EAAA,IAAI,CAAA,GAAI,CAAA,aAAA,EAAgB,IAAA,IAAQ,WAAW,CAAA,CAAA;AAC3C,EAAA,IAAI,OAAO,SAAS,QAAA,EAAU;AAC5B,IAAA,CAAA,IAAK,IAAI,IAAI,CAAA,CAAA;AAAA,EACf;AACA,EAAA,IAAI,QAAA,EAAU;AACZ,IAAA,CAAA,IAAK,IAAI,QAAQ,CAAA,CAAA;AAAA,EACnB;AACA,EAAA,OAAO,CAAA;AACT;AAUO,MAAM,uBAAA,GAA0BC,uBAAkB,wBAAwB;;;;"}

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

@@ -0,0 +1,83 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const diagnosticsChannel = require('node:diagnostics_channel');
+const core = require('@sentry/core');
+const mysql2DcSubscriber = require('../../mysql2/mysql2-dc-subscriber.js');
+const channels = require('../../orchestrion/channels.js');
+const tracingChannel = require('../../tracing-channel.js');
+const attributes = require('@sentry/conventions/attributes');
+
+const INTEGRATION_NAME = "Mysql2";
+const ORIGIN = "auto.db.orchestrion.mysql2";
+const DB_SYSTEM_VALUE_MYSQL = "mysql";
+function instrumentMysql2() {
+  mysql2DcSubscriber.subscribeMysql2DiagnosticChannels(diagnosticsChannel.tracingChannel);
+  subscribeQueryChannel(channels.CHANNELS.MYSQL2_QUERY);
+  subscribeQueryChannel(channels.CHANNELS.MYSQL2_EXECUTE);
+}
+function subscribeQueryChannel(channelName) {
+  tracingChannel.bindTracingChannelToSpan(
+    diagnosticsChannel.tracingChannel(channelName),
+    (data) => {
+      const statement = getQueryText(data.arguments);
+      return core.startInactiveSpan({
+        name: statement ?? "mysql2.query",
+        kind: core.SPAN_KIND.CLIENT,
+        attributes: {
+          [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN,
+          [core.SEMANTIC_ATTRIBUTE_SENTRY_OP]: "db",
+          // oxlint-disable-next-line typescript/no-deprecated
+          [attributes.DB_SYSTEM]: DB_SYSTEM_VALUE_MYSQL,
+          ...getConnectionAttributes(data.self?.config),
+          // oxlint-disable-next-line typescript/no-deprecated
+          [attributes.DB_STATEMENT]: statement || void 0
+        }
+      });
+    },
+    { requiresParentSpan: true }
+  );
+}
+function getQueryText(args) {
+  return extractSql(args[0]);
+}
+function extractSql(firstArg) {
+  if (typeof firstArg === "string") {
+    return firstArg;
+  }
+  if (core.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
+    [attributes.DB_NAME]: database || void 0,
+    [attributes.DB_USER]: user || void 0,
+    // oxlint-disable-next-line typescript/no-deprecated
+    [attributes.NET_PEER_NAME]: host || void 0,
+    // oxlint-disable-next-line typescript/no-deprecated
+    [attributes.NET_PEER_PORT]: portIsNumber ? portNumber : void 0
+  };
+}
+const _mysql2ChannelIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      if (!diagnosticsChannel.tracingChannel) {
+        return;
+      }
+      core.waitForTracingChannelBinding(() => {
+        instrumentMysql2();
+      });
+    }
+  };
+});
+const mysql2ChannelIntegration = core.defineIntegration(_mysql2ChannelIntegration);
+
+exports.mysql2ChannelIntegration = mysql2ChannelIntegration;
+//# sourceMappingURL=mysql2.js.map

package/build/cjs/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":["subscribeMysql2DiagnosticChannels","CHANNELS","bindTracingChannelToSpan","startInactiveSpan","SPAN_KIND","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN","SEMANTIC_ATTRIBUTE_SENTRY_OP","DB_SYSTEM","DB_STATEMENT","isObjectLike","DB_NAME","DB_USER","NET_PEER_NAME","NET_PEER_PORT","waitForTracingChannelBinding","defineIntegration"],"mappings":";;;;;;;;;AAwBA,MAAM,gBAAA,GAAmB,QAAA;AACzB,MAAM,MAAA,GAAS,4BAAA;AACf,MAAM,qBAAA,GAAwB,OAAA;AAyC9B,SAAS,gBAAA,GAAyB;AAEhC,EAAAA,oDAAA,CAAkC,mBAAmB,cAAc,CAAA;AAGnE,EAAA,qBAAA,CAAsBC,kBAAS,YAAY,CAAA;AAC3C,EAAA,qBAAA,CAAsBA,kBAAS,cAAc,CAAA;AAC/C;AAEA,SAAS,sBAAsB,WAAA,EAAgC;AAC7D,EAAAC,uCAAA;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,OAAOC,sBAAA,CAAkB;AAAA,QACvB,MAAM,SAAA,IAAa,cAAA;AAAA,QACnB,MAAMC,cAAA,CAAU,MAAA;AAAA,QAChB,UAAA,EAAY;AAAA,UACV,CAACC,qCAAgC,GAAG,MAAA;AAAA,UACpC,CAACC,iCAA4B,GAAG,IAAA;AAAA;AAAA,UAEhC,CAACC,oBAAS,GAAG,qBAAA;AAAA,UACb,GAAG,uBAAA,CAAwB,IAAA,CAAK,IAAA,EAAM,MAAM,CAAA;AAAA;AAAA,UAE5C,CAACC,uBAAY,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,IAAIC,iBAAA,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,CAACC,kBAAO,GAAG,QAAA,IAAY,MAAA;AAAA,IACvB,CAACC,kBAAO,GAAG,IAAA,IAAQ,MAAA;AAAA;AAAA,IAEnB,CAACC,wBAAa,GAAG,IAAA,IAAQ,MAAA;AAAA;AAAA,IAEzB,CAACC,wBAAa,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,MAAAC,iCAAA,CAA6B,MAAM;AACjC,QAAA,gBAAA,EAAiB;AAAA,MACnB,CAAC,CAAA;AAAA,IACH;AAAA,GACF;AACF,CAAA,CAAA;AAaO,MAAM,wBAAA,GAA2BC,uBAAkB,yBAAyB;;;;"}

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

@@ -0,0 +1,81 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const diagnosticsChannel = require('node:diagnostics_channel');
+const core = require('@sentry/core');
+const debugBuild = require('../../debug-build.js');
+const channels = require('../../orchestrion/channels.js');
+const tracingChannel = require('../../tracing-channel.js');
+
+const INTEGRATION_NAME = "OpenAI";
+const ORIGIN = "auto.ai.orchestrion.openai";
+const INSTRUMENTED_CHANNELS = [
+  { channel: channels.CHANNELS.OPENAI_CHAT, operation: "chat" },
+  { channel: channels.CHANNELS.OPENAI_EMBEDDINGS, operation: "embeddings" }
+];
+let subscribed = false;
+const _openaiChannelIntegration = ((options = {}) => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      if (!diagnosticsChannel.tracingChannel || subscribed) {
+        return;
+      }
+      subscribed = true;
+      core.waitForTracingChannelBinding(() => {
+        for (const { channel, operation } of INSTRUMENTED_CHANNELS) {
+          debugBuild.DEBUG_BUILD && core.debug.log(`[orchestrion:openai] subscribing to channel "${channel}"`);
+          tracingChannel.bindTracingChannelToSpan(
+            diagnosticsChannel.tracingChannel(channel),
+            (data) => createGenAiSpan(data, operation, options),
+            {
+              beforeSpanEnd: (span, data) => {
+                core.addOpenAiResponseAttributes(span, data.result, core.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 (core._INTERNAL_shouldSkipAiProviderWrapping(INTEGRATION_NAME)) {
+    return void 0;
+  }
+  const args = data.arguments ?? [];
+  const params = args[0];
+  const { recordInputs } = core.resolveAIRecordingOptions(options);
+  const enableTruncation = core.shouldEnableTruncation(options.enableTruncation);
+  const attributes = core.extractOpenAiRequestAttributes(args, operation);
+  attributes[core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] = ORIGIN;
+  const model = params?.model || "unknown";
+  const span = core.startInactiveSpan({
+    name: `${operation} ${model}`,
+    op: `gen_ai.${operation}`,
+    attributes
+  });
+  if (recordInputs && params) {
+    core.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 } = core.resolveAIRecordingOptions(options);
+  const iterate = result[Symbol.asyncIterator].bind(result);
+  const instrumented = core.instrumentOpenAiStream({ [Symbol.asyncIterator]: iterate }, span, recordOutputs ?? false);
+  result[Symbol.asyncIterator] = () => instrumented;
+  return true;
+}
+const openaiChannelIntegration = core.defineIntegration(_openaiChannelIntegration);
+
+exports.openaiChannelIntegration = openaiChannelIntegration;
+//# sourceMappingURL=openai.js.map

package/build/cjs/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":["CHANNELS","waitForTracingChannelBinding","DEBUG_BUILD","debug","bindTracingChannelToSpan","addOpenAiResponseAttributes","resolveAIRecordingOptions","_INTERNAL_shouldSkipAiProviderWrapping","shouldEnableTruncation","extractOpenAiRequestAttributes","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN","startInactiveSpan","addOpenAiRequestAttributes","instrumentOpenAiStream","defineIntegration"],"mappings":"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"}