@depup/sentry__server-utils 10.67.0-depup.0

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

@@ -0,0 +1,99 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const diagnosticsChannel = require('node:diagnostics_channel');
+const attributes = require('@sentry/conventions/attributes');
+const core = require('@sentry/core');
+const debugBuild = require('../../debug-build.js');
+const channels = require('../../orchestrion/channels.js');
+const redisStatementSerializer = require('../../redis/redis-statement-serializer.js');
+const tracingChannel = require('../../tracing-channel.js');
+
+const INTEGRATION_NAME = "IORedis";
+const ORIGIN = "auto.db.orchestrion.redis";
+const ATTR_DB_CONNECTION_STRING = "db.connection_string";
+function getConnectionOptions(self) {
+  return { host: self?.options?.host, port: self?.options?.port };
+}
+function connectionAttributes(host, port) {
+  return {
+    [attributes.DB_SYSTEM]: "redis",
+    [ATTR_DB_CONNECTION_STRING]: `redis://${host}:${port}`,
+    [attributes.NET_PEER_NAME]: host,
+    [attributes.NET_PEER_PORT]: port,
+    [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN
+  };
+}
+const tracedCommands = /* @__PURE__ */ new WeakSet();
+function startIORedisCommandSpan(data) {
+  const command = data.arguments?.[0];
+  if (!command || typeof command !== "object") {
+    return void 0;
+  }
+  if (tracedCommands.has(command)) {
+    return void 0;
+  }
+  tracedCommands.add(command);
+  const { host, port } = getConnectionOptions(data.self);
+  const statement = redisStatementSerializer.defaultDbStatementSerializer(command.name, command.args ?? []);
+  return core.startInactiveSpan({
+    name: statement,
+    op: "db",
+    attributes: { ...connectionAttributes(host, port), [attributes.DB_STATEMENT]: statement }
+  });
+}
+const _ioredisChannelIntegration = ((options = {}) => {
+  const responseHook = options.responseHook;
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      if (!diagnosticsChannel.tracingChannel) {
+        return;
+      }
+      debugBuild.DEBUG_BUILD && core.debug.log(`[orchestrion:ioredis] subscribing to "${channels.CHANNELS.IOREDIS_COMMAND}"/"${channels.CHANNELS.IOREDIS_CONNECT}"`);
+      const commandChannel = diagnosticsChannel.tracingChannel(
+        channels.CHANNELS.IOREDIS_COMMAND
+      );
+      const connectChannel = diagnosticsChannel.tracingChannel(
+        channels.CHANNELS.IOREDIS_CONNECT
+      );
+      core.waitForTracingChannelBinding(() => {
+        tracingChannel.bindTracingChannelToSpan(commandChannel, startIORedisCommandSpan, {
+          // ioredis' `requireParentSpan` default: only create a span under an active span.
+          requiresParentSpan: true,
+          beforeSpanEnd(span, data) {
+            if ("error" in data || !responseHook) {
+              return;
+            }
+            const command = data.arguments?.[0];
+            if (command) {
+              runResponseHook(responseHook, span, command, data.result);
+            }
+          }
+        });
+        tracingChannel.bindTracingChannelToSpan(
+          connectChannel,
+          (data) => {
+            const { host, port } = getConnectionOptions(data.self);
+            return core.startInactiveSpan({
+              name: "connect",
+              op: "db",
+              attributes: { ...connectionAttributes(host, port), [attributes.DB_STATEMENT]: "connect" }
+            });
+          },
+          { requiresParentSpan: true }
+        );
+      });
+    }
+  };
+});
+function runResponseHook(hook, span, command, result) {
+  try {
+    hook(span, command.name, command.args, result);
+  } catch {
+  }
+}
+const ioredisChannelIntegration = core.defineIntegration(_ioredisChannelIntegration);
+
+exports.ioredisChannelIntegration = ioredisChannelIntegration;
+exports.startIORedisCommandSpan = startIORedisCommandSpan;
+//# sourceMappingURL=ioredis.js.map

package/build/cjs/integrations/tracing-channel/ioredis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ioredis.js","sources":["../../../../src/integrations/tracing-channel/ioredis.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-deprecated -- we intentionally emit the OLD db/net semconv\n   to match `@opentelemetry/instrumentation-ioredis` (and Sentry's `inferDbSpanData`, which keys off\n   `db.statement`). TODO(v11): switch to the non-deprecated `db.system.name`/`db.query.text`/\n   `server.address`/`server.port` conventions and drop this disable. */\nimport * as diagnosticsChannel from 'node:diagnostics_channel';\nimport { DB_STATEMENT, DB_SYSTEM, NET_PEER_NAME, NET_PEER_PORT } from '@sentry/conventions/attributes';\nimport type { IntegrationFn, Span } from '@sentry/core';\nimport {\n  debug,\n  defineIntegration,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  startInactiveSpan,\n  waitForTracingChannelBinding,\n} from '@sentry/core';\nimport { DEBUG_BUILD } from '../../debug-build';\nimport { CHANNELS } from '../../orchestrion/channels';\nimport { defaultDbStatementSerializer } from '../../redis/redis-statement-serializer';\nimport { bindTracingChannelToSpan } from '../../tracing-channel';\n\n// Distinct from the OTel `Redis` integration, which is composite (node-redis +\n// ioredis + the >=5.11.0 diagnostics_channel subscriber) and stays in the set;\n// only its ioredis monkey-patch is gated off in the node SDK when this is active.\nconst INTEGRATION_NAME = 'IORedis' as const;\n\nconst ORIGIN = 'auto.db.orchestrion.redis';\n\n// todo(v11): Let's drop this as this is already covered with host and port\nconst ATTR_DB_CONNECTION_STRING = 'db.connection_string';\n\n/** Mirrors `@opentelemetry/instrumentation-ioredis`' response hook. Not called for failed commands. */\nexport type IORedisResponseHook = (span: Span, command: string, args: Array<string | Buffer>, result: unknown) => void;\n\nexport interface IORedisChannelIntegrationOptions {\n  responseHook?: IORedisResponseHook;\n}\n\n/** Structural type for the command object ioredis passes to `sendCommand`. */\ninterface RedisCommand {\n  name: string;\n  args: Array<string | Buffer>;\n}\n\ninterface RedisClientLike {\n  options?: { host?: string; port?: number };\n}\n\ninterface IORedisCommandContext {\n  arguments?: unknown[];\n  self?: RedisClientLike;\n  result?: unknown;\n  error?: unknown;\n}\n\ntype IORedisConnectContext = Omit<IORedisCommandContext, 'arguments'>;\n\nfunction getConnectionOptions(self: RedisClientLike | undefined): { host?: string; port?: number } {\n  return { host: self?.options?.host, port: self?.options?.port };\n}\n\nfunction connectionAttributes(host: string | undefined, port: number | undefined): Record<string, unknown> {\n  return {\n    [DB_SYSTEM]: 'redis',\n    [ATTR_DB_CONNECTION_STRING]: `redis://${host}:${port}`,\n    [NET_PEER_NAME]: host,\n    [NET_PEER_PORT]: port,\n    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN,\n  };\n}\n\n// ioredis re-enters `sendCommand` with the same command object when it drains\n// the offline queue on connect which leads to duplicate spans.\n// Track commands we've already traced so each logical command produces one span.\nconst tracedCommands = new WeakSet<object>();\n\n/**\n * Builds the db span for an `orchestrion:ioredis:command` payload, or returns `undefined` to skip\n * it: for a non-command payload, or the offline-queue re-send of an already-traced command.\n *\n * Exported for unit testing.\n */\nexport function startIORedisCommandSpan(data: IORedisCommandContext): Span | undefined {\n  const command = data.arguments?.[0] as RedisCommand | undefined;\n  if (!command || typeof command !== 'object') {\n    return undefined;\n  }\n  // guard against duplicate spans\n  if (tracedCommands.has(command)) {\n    return undefined;\n  }\n  tracedCommands.add(command);\n  const { host, port } = getConnectionOptions(data.self);\n  const statement = defaultDbStatementSerializer(command.name, command.args ?? []);\n  return startInactiveSpan({\n    name: statement,\n    op: 'db',\n    attributes: { ...connectionAttributes(host, port), [DB_STATEMENT]: statement },\n  });\n}\n\nconst _ioredisChannelIntegration = ((options: IORedisChannelIntegrationOptions = {}) => {\n  const responseHook = options.responseHook;\n\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      // `tracingChannel` is unavailable before Node 18.19.\n      if (!diagnosticsChannel.tracingChannel) {\n        return;\n      }\n\n      DEBUG_BUILD &&\n        debug.log(`[orchestrion:ioredis] subscribing to \"${CHANNELS.IOREDIS_COMMAND}\"/\"${CHANNELS.IOREDIS_CONNECT}\"`);\n\n      const commandChannel = diagnosticsChannel.tracingChannel<IORedisCommandContext, IORedisCommandContext>(\n        CHANNELS.IOREDIS_COMMAND,\n      );\n      const connectChannel = diagnosticsChannel.tracingChannel<IORedisConnectContext, IORedisConnectContext>(\n        CHANNELS.IOREDIS_CONNECT,\n      );\n\n      // `bindTracingChannelToSpan` uses `bindStore`, which needs the async-context\n      // binding that `initOpenTelemetry()` registers after integration `setupOnce` —\n      // defer until it's available (matches the native redis diagnostics-channel subscriber).\n      waitForTracingChannelBinding(() => {\n        bindTracingChannelToSpan(commandChannel, startIORedisCommandSpan, {\n          // ioredis' `requireParentSpan` default: only create a span under an active span.\n          requiresParentSpan: true,\n          beforeSpanEnd(span, data) {\n            if ('error' in data || !responseHook) {\n              return;\n            }\n            const command = data.arguments?.[0] as RedisCommand | undefined;\n            if (command) {\n              runResponseHook(responseHook, span, command, data.result);\n            }\n          },\n        });\n\n        bindTracingChannelToSpan(\n          connectChannel,\n          data => {\n            const { host, port } = getConnectionOptions(data.self);\n            return startInactiveSpan({\n              name: 'connect',\n              op: 'db',\n              attributes: { ...connectionAttributes(host, port), [DB_STATEMENT]: 'connect' },\n            });\n          },\n          { requiresParentSpan: true },\n        );\n      });\n    },\n  };\n}) satisfies IntegrationFn;\n\nfunction runResponseHook(hook: IORedisResponseHook, span: Span, command: RedisCommand, result: unknown): void {\n  try {\n    hook(span, command.name, command.args, result);\n  } catch {\n    // never let a user-provided response hook break instrumentation\n  }\n}\n\n/**\n * EXPERIMENTAL — orchestrion-driven ioredis integration. Subscribes to\n * `orchestrion:ioredis:command` / `:connect` (injected into ioredis' `<5.11.0`\n * `sendCommand`/`connect`) and creates db spans matching\n * `@opentelemetry/instrumentation-ioredis`. Requires the orchestrion runtime hook\n * or bundler plugin.\n */\nexport const ioredisChannelIntegration = defineIntegration(_ioredisChannelIntegration);\n"],"names":["DB_SYSTEM","NET_PEER_NAME","NET_PEER_PORT","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN","defaultDbStatementSerializer","startInactiveSpan","DB_STATEMENT","DEBUG_BUILD","debug","CHANNELS","waitForTracingChannelBinding","bindTracingChannelToSpan","defineIntegration"],"mappings":"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"}

package/build/cjs/integrations/tracing-channel/kafkajs/consumer.js

@@ -0,0 +1,71 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const attributes = require('@sentry/conventions/attributes');
+const core = require('@sentry/core');
+const semconv = require('./semconv.js');
+const spans = require('./spans.js');
+
+const consumerCallbackWrapped = /* @__PURE__ */ Symbol("sentry-kafkajs-consumer-callback-wrapped");
+function isWrappedConsumerCallback(fn) {
+  return typeof fn === "function" && fn[consumerCallbackWrapped] === true;
+}
+function wrapEachMessage(original) {
+  const wrapped = function eachMessage(payload) {
+    const sentryTrace = spans.getHeaderAsString(payload.message.headers, "sentry-trace");
+    const baggage = spans.getHeaderAsString(payload.message.headers, "baggage");
+    return core.continueTrace({ sentryTrace, baggage }, () => {
+      const span = spans.startConsumerSpan({
+        topic: payload.topic,
+        message: payload.message,
+        operationType: semconv.MESSAGING_OPERATION_TYPE_VALUE_PROCESS,
+        attributes: {
+          [semconv.ATTR_MESSAGING_DESTINATION_PARTITION_ID]: String(payload.partition)
+        }
+      });
+      const promise = core.withActiveSpan(span, () => original.call(this, payload));
+      return spans.endSpansOnPromise([span], promise);
+    });
+  };
+  wrapped[consumerCallbackWrapped] = true;
+  return wrapped;
+}
+function wrapEachBatch(original) {
+  const wrapped = function eachBatch(payload) {
+    const receivingSpan = core.startNewTrace(
+      () => spans.startConsumerSpan({
+        topic: payload.batch.topic,
+        message: void 0,
+        operationType: semconv.MESSAGING_OPERATION_TYPE_VALUE_RECEIVE,
+        attributes: {
+          [attributes.MESSAGING_BATCH_MESSAGE_COUNT]: payload.batch.messages.length,
+          [semconv.ATTR_MESSAGING_DESTINATION_PARTITION_ID]: String(payload.batch.partition)
+        }
+      })
+    );
+    return core.withActiveSpan(receivingSpan, () => {
+      const spans$1 = [receivingSpan];
+      payload.batch.messages.forEach((message) => {
+        spans$1.push(
+          spans.startConsumerSpan({
+            topic: payload.batch.topic,
+            message,
+            operationType: semconv.MESSAGING_OPERATION_TYPE_VALUE_PROCESS,
+            links: spans.getLinksFromHeaders(message.headers),
+            attributes: {
+              [semconv.ATTR_MESSAGING_DESTINATION_PARTITION_ID]: String(payload.batch.partition)
+            }
+          })
+        );
+      });
+      const promise = original.call(this, payload);
+      return spans.endSpansOnPromise(spans$1, promise);
+    });
+  };
+  wrapped[consumerCallbackWrapped] = true;
+  return wrapped;
+}
+
+exports.isWrappedConsumerCallback = isWrappedConsumerCallback;
+exports.wrapEachBatch = wrapEachBatch;
+exports.wrapEachMessage = wrapEachMessage;
+//# sourceMappingURL=consumer.js.map

package/build/cjs/integrations/tracing-channel/kafkajs/consumer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumer.js","sources":["../../../../../src/integrations/tracing-channel/kafkajs/consumer.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors, Aspecto\n * SPDX-License-Identifier: Apache-2.0\n *\n * NOTICE from the Sentry authors:\n * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-kafkajs\n * - Upstream version: @opentelemetry/instrumentation-kafkajs@0.27.0\n * - Span-creating wrappers for the consumer callbacks (`_getConsumerEachMessagePatch`/\n *   `_getConsumerEachBatchPatch`), migrated to the `@sentry/core` span API. The `run` channel's `start`\n *   subscriber swaps the user's `eachMessage`/`eachBatch` for these before the original runs.\n */\n\nimport { MESSAGING_BATCH_MESSAGE_COUNT } from '@sentry/conventions/attributes';\nimport type { Span } from '@sentry/core';\nimport { continueTrace, startNewTrace, withActiveSpan } from '@sentry/core';\nimport {\n  ATTR_MESSAGING_DESTINATION_PARTITION_ID,\n  MESSAGING_OPERATION_TYPE_VALUE_PROCESS,\n  MESSAGING_OPERATION_TYPE_VALUE_RECEIVE,\n} from './semconv';\nimport { endSpansOnPromise, getHeaderAsString, getLinksFromHeaders, startConsumerSpan } from './spans';\nimport type { EachBatchHandler, EachMessageHandler, KafkaMessage } from './types';\n\n// Marks a callback we've already wrapped. A user can reuse one config object across multiple\n// `consumer.run(config)` calls (e.g. a second consumer); without this guard the second `start` would\n// wrap the wrapper and emit duplicate spans per message.\nconst consumerCallbackWrapped: unique symbol = Symbol('sentry-kafkajs-consumer-callback-wrapped');\n\ntype MaybeWrapped = { [consumerCallbackWrapped]?: true };\n\n/** Whether `fn` is a callback this module already wrapped, so callers skip re-wrapping it. */\nexport function isWrappedConsumerCallback(fn: unknown): boolean {\n  return typeof fn === 'function' && (fn as MaybeWrapped)[consumerCallbackWrapped] === true;\n}\n\n/** Wraps `eachMessage` so each processed message becomes a consumer span parented to the message's producer. */\nexport function wrapEachMessage(original: EachMessageHandler): EachMessageHandler {\n  const wrapped: EachMessageHandler & MaybeWrapped = function eachMessage(this: unknown, payload) {\n    const sentryTrace = getHeaderAsString(payload.message.headers, 'sentry-trace');\n    const baggage = getHeaderAsString(payload.message.headers, 'baggage');\n\n    // Continue the producer's trace so the consumer span is parented to the message's producer.\n    return continueTrace({ sentryTrace, baggage }, () => {\n      const span = startConsumerSpan({\n        topic: payload.topic,\n        message: payload.message,\n        operationType: MESSAGING_OPERATION_TYPE_VALUE_PROCESS,\n        attributes: {\n          [ATTR_MESSAGING_DESTINATION_PARTITION_ID]: String(payload.partition),\n        },\n      });\n\n      const promise = withActiveSpan(span, () => original.call(this, payload));\n      return endSpansOnPromise([span], promise);\n    });\n  };\n  wrapped[consumerCallbackWrapped] = true;\n  return wrapped;\n}\n\n/** Wraps `eachBatch` so the batch pull becomes a fresh-root receiving span with a process span per message. */\nexport function wrapEachBatch(original: EachBatchHandler): EachBatchHandler {\n  const wrapped: EachBatchHandler & MaybeWrapped = function eachBatch(this: unknown, payload) {\n    // A batch pull aggregates messages from many producers, so the receiving span is a fresh root\n    // trace and each processed message links back to its own producer span. Mirrors the OTel messaging\n    // semantic conventions for a topic with multiple consumers.\n    const receivingSpan = startNewTrace(() =>\n      startConsumerSpan({\n        topic: payload.batch.topic,\n        message: undefined,\n        operationType: MESSAGING_OPERATION_TYPE_VALUE_RECEIVE,\n        attributes: {\n          [MESSAGING_BATCH_MESSAGE_COUNT]: payload.batch.messages.length,\n          [ATTR_MESSAGING_DESTINATION_PARTITION_ID]: String(payload.batch.partition),\n        },\n      }),\n    );\n\n    return withActiveSpan(receivingSpan, () => {\n      const spans: Span[] = [receivingSpan];\n      payload.batch.messages.forEach((message: KafkaMessage) => {\n        spans.push(\n          startConsumerSpan({\n            topic: payload.batch.topic,\n            message,\n            operationType: MESSAGING_OPERATION_TYPE_VALUE_PROCESS,\n            links: getLinksFromHeaders(message.headers),\n            attributes: {\n              [ATTR_MESSAGING_DESTINATION_PARTITION_ID]: String(payload.batch.partition),\n            },\n          }),\n        );\n      });\n      const promise = original.call(this, payload);\n      return endSpansOnPromise(spans, promise);\n    });\n  };\n  wrapped[consumerCallbackWrapped] = true;\n  return wrapped;\n}\n"],"names":["getHeaderAsString","continueTrace","startConsumerSpan","MESSAGING_OPERATION_TYPE_VALUE_PROCESS","ATTR_MESSAGING_DESTINATION_PARTITION_ID","withActiveSpan","endSpansOnPromise","startNewTrace","MESSAGING_OPERATION_TYPE_VALUE_RECEIVE","MESSAGING_BATCH_MESSAGE_COUNT","spans","getLinksFromHeaders"],"mappings":";;;;;;;AA0BA,MAAM,uBAAA,0BAAgD,0CAA0C,CAAA;AAKzF,SAAS,0BAA0B,EAAA,EAAsB;AAC9D,EAAA,OAAO,OAAO,EAAA,KAAO,UAAA,IAAe,EAAA,CAAoB,uBAAuB,CAAA,KAAM,IAAA;AACvF;AAGO,SAAS,gBAAgB,QAAA,EAAkD;AAChF,EAAA,MAAM,OAAA,GAA6C,SAAS,WAAA,CAA2B,OAAA,EAAS;AAC9F,IAAA,MAAM,WAAA,GAAcA,uBAAA,CAAkB,OAAA,CAAQ,OAAA,CAAQ,SAAS,cAAc,CAAA;AAC7E,IAAA,MAAM,OAAA,GAAUA,uBAAA,CAAkB,OAAA,CAAQ,OAAA,CAAQ,SAAS,SAAS,CAAA;AAGpE,IAAA,OAAOC,kBAAA,CAAc,EAAE,WAAA,EAAa,OAAA,IAAW,MAAM;AACnD,MAAA,MAAM,OAAOC,uBAAA,CAAkB;AAAA,QAC7B,OAAO,OAAA,CAAQ,KAAA;AAAA,QACf,SAAS,OAAA,CAAQ,OAAA;AAAA,QACjB,aAAA,EAAeC,8CAAA;AAAA,QACf,UAAA,EAAY;AAAA,UACV,CAACC,+CAAuC,GAAG,MAAA,CAAO,QAAQ,SAAS;AAAA;AACrE,OACD,CAAA;AAED,MAAA,MAAM,OAAA,GAAUC,oBAAe,IAAA,EAAM,MAAM,SAAS,IAAA,CAAK,IAAA,EAAM,OAAO,CAAC,CAAA;AACvE,MAAA,OAAOC,uBAAA,CAAkB,CAAC,IAAI,CAAA,EAAG,OAAO,CAAA;AAAA,IAC1C,CAAC,CAAA;AAAA,EACH,CAAA;AACA,EAAA,OAAA,CAAQ,uBAAuB,CAAA,GAAI,IAAA;AACnC,EAAA,OAAO,OAAA;AACT;AAGO,SAAS,cAAc,QAAA,EAA8C;AAC1E,EAAA,MAAM,OAAA,GAA2C,SAAS,SAAA,CAAyB,OAAA,EAAS;AAI1F,IAAA,MAAM,aAAA,GAAgBC,kBAAA;AAAA,MAAc,MAClCL,uBAAA,CAAkB;AAAA,QAChB,KAAA,EAAO,QAAQ,KAAA,CAAM,KAAA;AAAA,QACrB,OAAA,EAAS,MAAA;AAAA,QACT,aAAA,EAAeM,8CAAA;AAAA,QACf,UAAA,EAAY;AAAA,UACV,CAACC,wCAA6B,GAAG,OAAA,CAAQ,MAAM,QAAA,CAAS,MAAA;AAAA,UACxD,CAACL,+CAAuC,GAAG,MAAA,CAAO,OAAA,CAAQ,MAAM,SAAS;AAAA;AAC3E,OACD;AAAA,KACH;AAEA,IAAA,OAAOC,mBAAA,CAAe,eAAe,MAAM;AACzC,MAAA,MAAMK,OAAA,GAAgB,CAAC,aAAa,CAAA;AACpC,MAAA,OAAA,CAAQ,KAAA,CAAM,QAAA,CAAS,OAAA,CAAQ,CAAC,OAAA,KAA0B;AACxD,QAAAA,OAAA,CAAM,IAAA;AAAA,UACJR,uBAAA,CAAkB;AAAA,YAChB,KAAA,EAAO,QAAQ,KAAA,CAAM,KAAA;AAAA,YACrB,OAAA;AAAA,YACA,aAAA,EAAeC,8CAAA;AAAA,YACf,KAAA,EAAOQ,yBAAA,CAAoB,OAAA,CAAQ,OAAO,CAAA;AAAA,YAC1C,UAAA,EAAY;AAAA,cACV,CAACP,+CAAuC,GAAG,MAAA,CAAO,OAAA,CAAQ,MAAM,SAAS;AAAA;AAC3E,WACD;AAAA,SACH;AAAA,MACF,CAAC,CAAA;AACD,MAAA,MAAM,OAAA,GAAU,QAAA,CAAS,IAAA,CAAK,IAAA,EAAM,OAAO,CAAA;AAC3C,MAAA,OAAOE,uBAAA,CAAkBI,SAAO,OAAO,CAAA;AAAA,IACzC,CAAC,CAAA;AAAA,EACH,CAAA;AACA,EAAA,OAAA,CAAQ,uBAAuB,CAAA,GAAI,IAAA;AACnC,EAAA,OAAO,OAAA;AACT;;;;;;"}

package/build/cjs/integrations/tracing-channel/kafkajs/index.js

@@ -0,0 +1,70 @@
+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 consumer = require('./consumer.js');
+const spans = require('./spans.js');
+
+const INTEGRATION_NAME = "Kafka";
+function subscribeToProducer() {
+  const channel = diagnosticsChannel.tracingChannel(channels.CHANNELS.KAFKAJS_SEND_BATCH);
+  const subscribers = {
+    start(ctx) {
+      const spans$1 = [];
+      (ctx.arguments[0]?.topicMessages ?? []).forEach((topicMessage) => {
+        topicMessage.messages.forEach((message) => {
+          spans$1.push(spans.startProducerSpan(topicMessage.topic, message));
+        });
+      });
+      ctx._sentrySpans = spans$1;
+    },
+    error(ctx) {
+      if (ctx._sentrySpans) {
+        spans.applyErrorToSpans(ctx._sentrySpans, ctx.error);
+      }
+    },
+    asyncEnd(ctx) {
+      ctx._sentrySpans?.forEach((span) => span.end());
+    }
+  };
+  channel.subscribe(subscribers);
+}
+function subscribeToConsumer() {
+  const channel = diagnosticsChannel.tracingChannel(channels.CHANNELS.KAFKAJS_CONSUMER_RUN);
+  const subscribers = {
+    start(ctx) {
+      const config = ctx.arguments[0];
+      if (!config || typeof config !== "object") {
+        return;
+      }
+      if (typeof config.eachMessage === "function" && !consumer.isWrappedConsumerCallback(config.eachMessage)) {
+        config.eachMessage = consumer.wrapEachMessage(config.eachMessage);
+      }
+      if (typeof config.eachBatch === "function" && !consumer.isWrappedConsumerCallback(config.eachBatch)) {
+        config.eachBatch = consumer.wrapEachBatch(config.eachBatch);
+      }
+    }
+  };
+  channel.subscribe(subscribers);
+}
+const _kafkajsChannelIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      if (!diagnosticsChannel.tracingChannel) {
+        return;
+      }
+      debugBuild.DEBUG_BUILD && core.debug.log(
+        `[orchestrion:kafkajs] subscribing to channels "${channels.CHANNELS.KAFKAJS_SEND_BATCH}", "${channels.CHANNELS.KAFKAJS_CONSUMER_RUN}"`
+      );
+      subscribeToProducer();
+      subscribeToConsumer();
+    }
+  };
+});
+const kafkajsChannelIntegration = core.defineIntegration(_kafkajsChannelIntegration);
+
+exports.kafkajsChannelIntegration = kafkajsChannelIntegration;
+//# sourceMappingURL=index.js.map

package/build/cjs/integrations/tracing-channel/kafkajs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../src/integrations/tracing-channel/kafkajs/index.ts"],"sourcesContent":["import * as diagnosticsChannel from 'node:diagnostics_channel';\nimport type { TracingChannelSubscribers } from 'node:diagnostics_channel';\nimport type { IntegrationFn, Span } from '@sentry/core';\nimport { debug, defineIntegration } from '@sentry/core';\nimport { DEBUG_BUILD } from '../../../debug-build';\nimport { CHANNELS } from '../../../orchestrion/channels';\nimport { isWrappedConsumerCallback, wrapEachBatch, wrapEachMessage } from './consumer';\nimport { applyErrorToSpans, startProducerSpan } from './spans';\nimport type { ConsumerRunConfig, ProducerBatch } from './types';\n\n// NOTE: this uses the same name as the OTel `Kafka` integration by design. When enabled, the OTel\n// integration is omitted from the default set (see `experimentalUseDiagnosticsChannelInjection`).\nconst INTEGRATION_NAME = 'Kafka' as const;\n\n/** The tracing-channel context the transform attaches around `messageProducer.js`'s `sendBatch`. */\ninterface SendBatchChannelContext {\n  // `arguments[0]` is the `{ topicMessages }` batch (kafkajs normalizes `send` into `sendBatch`).\n  arguments: [ProducerBatch?, ...unknown[]];\n  error?: unknown;\n  // The producer spans opened at `start`, ended on `asyncEnd` (and marked errored on `error`).\n  _sentrySpans?: Span[];\n}\n\n/** The tracing-channel context the transform attaches around `consumer/index.js`'s `run`. */\ninterface ConsumerRunChannelContext {\n  // `arguments[0]` is the `run(config)` config whose `eachMessage`/`eachBatch` we swap in place.\n  arguments: [ConsumerRunConfig?, ...unknown[]];\n}\n\nfunction subscribeToProducer(): void {\n  const channel = diagnosticsChannel.tracingChannel<SendBatchChannelContext>(CHANNELS.KAFKAJS_SEND_BATCH);\n  // Node types `subscribe` as requiring every lifecycle handler; runtime accepts a partial set, so we\n  // pass only the ones we use (matching `bindTracingChannelToSpan`'s handling in `tracing-channel.ts`).\n  const subscribers: Partial<TracingChannelSubscribers<SendBatchChannelContext>> = {\n    start(ctx) {\n      const spans: Span[] = [];\n      // `startProducerSpan` mutates each message's headers; doing it at `start` means the mutation\n      // reaches the real call, propagating the producer's trace to consumers.\n      (ctx.arguments[0]?.topicMessages ?? []).forEach(topicMessage => {\n        topicMessage.messages.forEach(message => {\n          spans.push(startProducerSpan(topicMessage.topic, message));\n        });\n      });\n      ctx._sentrySpans = spans;\n    },\n    error(ctx) {\n      if (ctx._sentrySpans) {\n        applyErrorToSpans(ctx._sentrySpans, ctx.error);\n      }\n    },\n    asyncEnd(ctx) {\n      // `asyncEnd` fires on both success and failure; `error` (above) has already set the status.\n      ctx._sentrySpans?.forEach(span => span.end());\n    },\n  };\n  channel.subscribe(subscribers as TracingChannelSubscribers<SendBatchChannelContext>);\n}\n\nfunction subscribeToConsumer(): void {\n  const channel = diagnosticsChannel.tracingChannel<ConsumerRunChannelContext>(CHANNELS.KAFKAJS_CONSUMER_RUN);\n  const subscribers: Partial<TracingChannelSubscribers<ConsumerRunChannelContext>> = {\n    start(ctx) {\n      const config = ctx.arguments[0];\n      if (!config || typeof config !== 'object') {\n        return;\n      }\n      // Swap the user callbacks for span-creating wrappers before `run` destructures its config. The\n      // `isWrappedConsumerCallback` guard keeps this idempotent: a config object reused across another\n      // `run` (or a second consumer) must not have its wrapper wrapped again, which would double spans.\n      if (typeof config.eachMessage === 'function' && !isWrappedConsumerCallback(config.eachMessage)) {\n        config.eachMessage = wrapEachMessage(config.eachMessage);\n      }\n      if (typeof config.eachBatch === 'function' && !isWrappedConsumerCallback(config.eachBatch)) {\n        config.eachBatch = wrapEachBatch(config.eachBatch);\n      }\n    },\n  };\n  channel.subscribe(subscribers as TracingChannelSubscribers<ConsumerRunChannelContext>);\n}\n\nconst _kafkajsChannelIntegration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      if (!diagnosticsChannel.tracingChannel) {\n        return;\n      }\n\n      DEBUG_BUILD &&\n        debug.log(\n          `[orchestrion:kafkajs] subscribing to channels \"${CHANNELS.KAFKAJS_SEND_BATCH}\", \"${CHANNELS.KAFKAJS_CONSUMER_RUN}\"`,\n        );\n\n      subscribeToProducer();\n      subscribeToConsumer();\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * EXPERIMENTAL — orchestrion-driven kafkajs integration.\n *\n * Subscribes to the `orchestrion:kafkajs:*` diagnostics_channels that the orchestrion code transform\n * injects into `kafkajs`'s `producer/messageProducer.js` (`sendBatch`) and `consumer/index.js` (`run`).\n * Requires the orchestrion runtime hook or bundler plugin to be active — wire that up via\n * `experimentalUseDiagnosticsChannelInjection`.\n *\n * Known limitation vs. the OTel integration it replaces: the wrapping producer-`transaction` span is\n * not emitted (the transformer can't replace `transaction()`'s return value to patch commit/abort).\n * Transactional `send`/`sendBatch` calls still produce producer spans, since they route through the\n * same instrumented `sendBatch`.\n */\nexport const kafkajsChannelIntegration = defineIntegration(_kafkajsChannelIntegration);\n"],"names":["CHANNELS","spans","startProducerSpan","applyErrorToSpans","isWrappedConsumerCallback","wrapEachMessage","wrapEachBatch","DEBUG_BUILD","debug","defineIntegration"],"mappings":";;;;;;;;;AAYA,MAAM,gBAAA,GAAmB,OAAA;AAiBzB,SAAS,mBAAA,GAA4B;AACnC,EAAA,MAAM,OAAA,GAAU,kBAAA,CAAmB,cAAA,CAAwCA,iBAAA,CAAS,kBAAkB,CAAA;AAGtG,EAAA,MAAM,WAAA,GAA2E;AAAA,IAC/E,MAAM,GAAA,EAAK;AACT,MAAA,MAAMC,UAAgB,EAAC;AAGvB,MAAA,CAAC,GAAA,CAAI,UAAU,CAAC,CAAA,EAAG,iBAAiB,EAAC,EAAG,QAAQ,CAAA,YAAA,KAAgB;AAC9D,QAAA,YAAA,CAAa,QAAA,CAAS,QAAQ,CAAA,OAAA,KAAW;AACvC,UAAAA,OAAA,CAAM,IAAA,CAAKC,uBAAA,CAAkB,YAAA,CAAa,KAAA,EAAO,OAAO,CAAC,CAAA;AAAA,QAC3D,CAAC,CAAA;AAAA,MACH,CAAC,CAAA;AACD,MAAA,GAAA,CAAI,YAAA,GAAeD,OAAA;AAAA,IACrB,CAAA;AAAA,IACA,MAAM,GAAA,EAAK;AACT,MAAA,IAAI,IAAI,YAAA,EAAc;AACpB,QAAAE,uBAAA,CAAkB,GAAA,CAAI,YAAA,EAAc,GAAA,CAAI,KAAK,CAAA;AAAA,MAC/C;AAAA,IACF,CAAA;AAAA,IACA,SAAS,GAAA,EAAK;AAEZ,MAAA,GAAA,CAAI,YAAA,EAAc,OAAA,CAAQ,CAAA,IAAA,KAAQ,IAAA,CAAK,KAAK,CAAA;AAAA,IAC9C;AAAA,GACF;AACA,EAAA,OAAA,CAAQ,UAAU,WAAiE,CAAA;AACrF;AAEA,SAAS,mBAAA,GAA4B;AACnC,EAAA,MAAM,OAAA,GAAU,kBAAA,CAAmB,cAAA,CAA0CH,iBAAA,CAAS,oBAAoB,CAAA;AAC1G,EAAA,MAAM,WAAA,GAA6E;AAAA,IACjF,MAAM,GAAA,EAAK;AACT,MAAA,MAAM,MAAA,GAAS,GAAA,CAAI,SAAA,CAAU,CAAC,CAAA;AAC9B,MAAA,IAAI,CAAC,MAAA,IAAU,OAAO,MAAA,KAAW,QAAA,EAAU;AACzC,QAAA;AAAA,MACF;AAIA,MAAA,IAAI,OAAO,OAAO,WAAA,KAAgB,UAAA,IAAc,CAACI,kCAAA,CAA0B,MAAA,CAAO,WAAW,CAAA,EAAG;AAC9F,QAAA,MAAA,CAAO,WAAA,GAAcC,wBAAA,CAAgB,MAAA,CAAO,WAAW,CAAA;AAAA,MACzD;AACA,MAAA,IAAI,OAAO,OAAO,SAAA,KAAc,UAAA,IAAc,CAACD,kCAAA,CAA0B,MAAA,CAAO,SAAS,CAAA,EAAG;AAC1F,QAAA,MAAA,CAAO,SAAA,GAAYE,sBAAA,CAAc,MAAA,CAAO,SAAS,CAAA;AAAA,MACnD;AAAA,IACF;AAAA,GACF;AACA,EAAA,OAAA,CAAQ,UAAU,WAAmE,CAAA;AACvF;AAEA,MAAM,8BAA8B,MAAM;AACxC,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,SAAA,GAAY;AACV,MAAA,IAAI,CAAC,mBAAmB,cAAA,EAAgB;AACtC,QAAA;AAAA,MACF;AAEA,MAAAC,sBAAA,IACEC,UAAA,CAAM,GAAA;AAAA,QACJ,CAAA,+CAAA,EAAkDR,iBAAA,CAAS,kBAAkB,CAAA,IAAA,EAAOA,kBAAS,oBAAoB,CAAA,CAAA;AAAA,OACnH;AAEF,MAAA,mBAAA,EAAoB;AACpB,MAAA,mBAAA,EAAoB;AAAA,IACtB;AAAA,GACF;AACF,CAAA,CAAA;AAeO,MAAM,yBAAA,GAA4BS,uBAAkB,0BAA0B;;;;"}

package/build/cjs/integrations/tracing-channel/kafkajs/semconv.js

@@ -0,0 +1,22 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const ATTR_MESSAGING_DESTINATION_PARTITION_ID = "messaging.destination.partition.id";
+const ATTR_MESSAGING_KAFKA_MESSAGE_KEY = "messaging.kafka.message.key";
+const ATTR_MESSAGING_KAFKA_MESSAGE_TOMBSTONE = "messaging.kafka.message.tombstone";
+const ATTR_MESSAGING_KAFKA_OFFSET = "messaging.kafka.offset";
+const MESSAGING_OPERATION_TYPE_VALUE_PROCESS = "process";
+const MESSAGING_OPERATION_TYPE_VALUE_RECEIVE = "receive";
+const MESSAGING_OPERATION_TYPE_VALUE_SEND = "send";
+const MESSAGING_SYSTEM_VALUE_KAFKA = "kafka";
+const ERROR_TYPE_VALUE_OTHER = "_OTHER";
+
+exports.ATTR_MESSAGING_DESTINATION_PARTITION_ID = ATTR_MESSAGING_DESTINATION_PARTITION_ID;
+exports.ATTR_MESSAGING_KAFKA_MESSAGE_KEY = ATTR_MESSAGING_KAFKA_MESSAGE_KEY;
+exports.ATTR_MESSAGING_KAFKA_MESSAGE_TOMBSTONE = ATTR_MESSAGING_KAFKA_MESSAGE_TOMBSTONE;
+exports.ATTR_MESSAGING_KAFKA_OFFSET = ATTR_MESSAGING_KAFKA_OFFSET;
+exports.ERROR_TYPE_VALUE_OTHER = ERROR_TYPE_VALUE_OTHER;
+exports.MESSAGING_OPERATION_TYPE_VALUE_PROCESS = MESSAGING_OPERATION_TYPE_VALUE_PROCESS;
+exports.MESSAGING_OPERATION_TYPE_VALUE_RECEIVE = MESSAGING_OPERATION_TYPE_VALUE_RECEIVE;
+exports.MESSAGING_OPERATION_TYPE_VALUE_SEND = MESSAGING_OPERATION_TYPE_VALUE_SEND;
+exports.MESSAGING_SYSTEM_VALUE_KAFKA = MESSAGING_SYSTEM_VALUE_KAFKA;
+//# sourceMappingURL=semconv.js.map

package/build/cjs/integrations/tracing-channel/kafkajs/semconv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"semconv.js","sources":["../../../../../src/integrations/tracing-channel/kafkajs/semconv.ts"],"sourcesContent":["/*\n * Unstable OTel semantic-convention keys/values without a `@sentry/conventions` constant, inlined to\n * keep this integration free of `@opentelemetry/*` deps. Values are byte-identical to the vendored OTel\n * instrumentation (`@sentry/node`'s `integrations/tracing/kafka/vendored/semconv.ts`) for span parity.\n */\n\nexport const ATTR_MESSAGING_DESTINATION_PARTITION_ID = 'messaging.destination.partition.id' as const;\nexport const ATTR_MESSAGING_KAFKA_MESSAGE_KEY = 'messaging.kafka.message.key' as const;\nexport const ATTR_MESSAGING_KAFKA_MESSAGE_TOMBSTONE = 'messaging.kafka.message.tombstone' as const;\nexport const ATTR_MESSAGING_KAFKA_OFFSET = 'messaging.kafka.offset' as const;\nexport const MESSAGING_OPERATION_TYPE_VALUE_PROCESS = 'process' as const;\nexport const MESSAGING_OPERATION_TYPE_VALUE_RECEIVE = 'receive' as const;\nexport const MESSAGING_OPERATION_TYPE_VALUE_SEND = 'send' as const;\nexport const MESSAGING_SYSTEM_VALUE_KAFKA = 'kafka' as const;\n\n// `_OTHER` is OTel's fallback bucket when no more specific `error.type` is known.\nexport const ERROR_TYPE_VALUE_OTHER = '_OTHER' as const;\n"],"names":[],"mappings":";;AAMO,MAAM,uCAAA,GAA0C;AAChD,MAAM,gCAAA,GAAmC;AACzC,MAAM,sCAAA,GAAyC;AAC/C,MAAM,2BAAA,GAA8B;AACpC,MAAM,sCAAA,GAAyC;AAC/C,MAAM,sCAAA,GAAyC;AAC/C,MAAM,mCAAA,GAAsC;AAC5C,MAAM,4BAAA,GAA+B;AAGrC,MAAM,sBAAA,GAAyB;;;;;;;;;;;;"}

package/build/cjs/integrations/tracing-channel/kafkajs/spans.js

@@ -0,0 +1,119 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const attributes = require('@sentry/conventions/attributes');
+const core = require('@sentry/core');
+const semconv = require('./semconv.js');
+
+const PRODUCER_ORIGIN = "auto.kafkajs.orchestrion.producer";
+const CONSUMER_ORIGIN = "auto.kafkajs.orchestrion.consumer";
+const TRACE_FLAG_SAMPLED = 1;
+const TRACE_FLAG_NONE = 0;
+function getHeaderAsString(headers, key) {
+  const value = headers?.[key];
+  if (value == null) {
+    return void 0;
+  }
+  return Array.isArray(value) ? value[0]?.toString() : value.toString();
+}
+function getLinksFromHeaders(headers) {
+  const sentryTrace = getHeaderAsString(headers, "sentry-trace");
+  if (!sentryTrace) {
+    return void 0;
+  }
+  const { traceId, parentSpanId, sampled } = core.propagationContextFromHeaders(
+    sentryTrace,
+    getHeaderAsString(headers, "baggage")
+  );
+  if (!parentSpanId) {
+    return void 0;
+  }
+  return [
+    {
+      context: {
+        traceId,
+        spanId: parentSpanId,
+        isRemote: true,
+        traceFlags: sampled ? TRACE_FLAG_SAMPLED : TRACE_FLAG_NONE
+      }
+    }
+  ];
+}
+function startConsumerSpan({ topic, message, operationType, links, attributes: attributes$1 }) {
+  const operationName = operationType === semconv.MESSAGING_OPERATION_TYPE_VALUE_RECEIVE ? "poll" : operationType;
+  return core.startInactiveSpan({
+    name: `${operationName} ${topic}`,
+    // todo(v11): Use https://getsentry.github.io/sentry-conventions/ops/#messaging
+    op: "message",
+    kind: operationType === semconv.MESSAGING_OPERATION_TYPE_VALUE_RECEIVE ? core.SPAN_KIND.CLIENT : core.SPAN_KIND.CONSUMER,
+    links,
+    attributes: {
+      ...attributes$1,
+      [attributes.MESSAGING_SYSTEM]: semconv.MESSAGING_SYSTEM_VALUE_KAFKA,
+      [attributes.MESSAGING_DESTINATION_NAME]: topic,
+      [attributes.MESSAGING_OPERATION_TYPE]: operationType,
+      [attributes.MESSAGING_OPERATION_NAME]: operationName,
+      [semconv.ATTR_MESSAGING_KAFKA_MESSAGE_KEY]: message?.key ? String(message.key) : void 0,
+      [semconv.ATTR_MESSAGING_KAFKA_MESSAGE_TOMBSTONE]: message?.key && message.value === null ? true : void 0,
+      [semconv.ATTR_MESSAGING_KAFKA_OFFSET]: message?.offset,
+      // Mirror the upstream behavior of only tagging per-message processing spans (not the batch
+      // receiving span, which carries no message) with the auto origin.
+      ...message ? { [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: CONSUMER_ORIGIN } : {}
+    }
+  });
+}
+function startProducerSpan(topic, message) {
+  const span = core.startInactiveSpan({
+    name: `send ${topic}`,
+    op: "message",
+    kind: core.SPAN_KIND.PRODUCER,
+    attributes: {
+      [attributes.MESSAGING_SYSTEM]: semconv.MESSAGING_SYSTEM_VALUE_KAFKA,
+      [attributes.MESSAGING_DESTINATION_NAME]: topic,
+      [semconv.ATTR_MESSAGING_KAFKA_MESSAGE_KEY]: message.key ? String(message.key) : void 0,
+      [semconv.ATTR_MESSAGING_KAFKA_MESSAGE_TOMBSTONE]: message.key && message.value === null ? true : void 0,
+      [semconv.ATTR_MESSAGING_DESTINATION_PARTITION_ID]: message.partition !== void 0 ? String(message.partition) : void 0,
+      [attributes.MESSAGING_OPERATION_NAME]: "send",
+      [attributes.MESSAGING_OPERATION_TYPE]: semconv.MESSAGING_OPERATION_TYPE_VALUE_SEND,
+      [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: PRODUCER_ORIGIN
+    }
+  });
+  message.headers = message.headers ?? {};
+  const traceData = core.getTraceData({ span });
+  if (traceData["sentry-trace"]) {
+    message.headers["sentry-trace"] = traceData["sentry-trace"];
+  }
+  if (traceData.baggage) {
+    message.headers["baggage"] = traceData.baggage;
+  }
+  return span;
+}
+function applyErrorToSpans(spans, reason) {
+  let errorMessage;
+  let errorType = semconv.ERROR_TYPE_VALUE_OTHER;
+  if (typeof reason === "string" || reason === void 0) {
+    errorMessage = reason;
+  } else if (typeof reason === "object" && reason !== null && Object.prototype.hasOwnProperty.call(reason, "message")) {
+    errorMessage = reason.message;
+    errorType = reason.constructor.name;
+  }
+  spans.forEach((span) => {
+    span.setAttribute(attributes.ERROR_TYPE, errorType);
+    span.setStatus({ code: core.SPAN_STATUS_ERROR, message: errorMessage });
+  });
+}
+function endSpansOnPromise(spans, promise) {
+  return Promise.resolve(promise).catch((reason) => {
+    applyErrorToSpans(spans, reason);
+    throw reason;
+  }).finally(() => {
+    spans.forEach((span) => span.end());
+  });
+}
+
+exports.applyErrorToSpans = applyErrorToSpans;
+exports.endSpansOnPromise = endSpansOnPromise;
+exports.getHeaderAsString = getHeaderAsString;
+exports.getLinksFromHeaders = getLinksFromHeaders;
+exports.startConsumerSpan = startConsumerSpan;
+exports.startProducerSpan = startProducerSpan;
+//# sourceMappingURL=spans.js.map

package/build/cjs/integrations/tracing-channel/kafkajs/spans.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spans.js","sources":["../../../../../src/integrations/tracing-channel/kafkajs/spans.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors, Aspecto\n * SPDX-License-Identifier: Apache-2.0\n *\n * NOTICE from the Sentry authors:\n * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-kafkajs\n * - Upstream version: @opentelemetry/instrumentation-kafkajs@0.27.0\n * - Span builders migrated to the `@sentry/core` span API. Kept byte-identical in span name/attributes\n *   for parity with the OTel integration this replaces; only the origin changes to\n *   `auto.kafkajs.orchestrion.*` to mark the injection path.\n */\n\nimport {\n  ERROR_TYPE,\n  MESSAGING_DESTINATION_NAME,\n  MESSAGING_OPERATION_NAME,\n  MESSAGING_OPERATION_TYPE,\n  MESSAGING_SYSTEM,\n} from '@sentry/conventions/attributes';\nimport type { Span, SpanAttributes, SpanLink } from '@sentry/core';\nimport {\n  getTraceData,\n  propagationContextFromHeaders,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  SPAN_KIND,\n  SPAN_STATUS_ERROR,\n  startInactiveSpan,\n} from '@sentry/core';\nimport type { KafkaMessage, Message } from './types';\nimport {\n  ATTR_MESSAGING_DESTINATION_PARTITION_ID,\n  ATTR_MESSAGING_KAFKA_MESSAGE_KEY,\n  ATTR_MESSAGING_KAFKA_MESSAGE_TOMBSTONE,\n  ATTR_MESSAGING_KAFKA_OFFSET,\n  ERROR_TYPE_VALUE_OTHER,\n  MESSAGING_OPERATION_TYPE_VALUE_RECEIVE,\n  MESSAGING_OPERATION_TYPE_VALUE_SEND,\n  MESSAGING_SYSTEM_VALUE_KAFKA,\n} from './semconv';\n\nconst PRODUCER_ORIGIN = 'auto.kafkajs.orchestrion.producer';\nconst CONSUMER_ORIGIN = 'auto.kafkajs.orchestrion.consumer';\n\n// `@opentelemetry/api` `TraceFlags`, inlined to avoid an OTel dep: SAMPLED = 0x1, NONE = 0x0.\nconst TRACE_FLAG_SAMPLED = 1;\nconst TRACE_FLAG_NONE = 0;\n\ninterface ConsumerSpanOptions {\n  topic: string;\n  message: KafkaMessage | undefined;\n  operationType: string;\n  attributes: SpanAttributes;\n  links?: SpanLink[];\n}\n\n/**\n * Reads a header value off a kafkajs message as a string. kafkajs delivers headers as `Buffer`s (or\n * arrays of them), so we normalize to a string before handing them to Sentry's trace helpers.\n */\nexport function getHeaderAsString(headers: KafkaMessage['headers'], key: string): string | undefined {\n  const value = headers?.[key];\n  if (value == null) {\n    return undefined;\n  }\n  return Array.isArray(value) ? value[0]?.toString() : value.toString();\n}\n\n/**\n * Builds a span link to the producer span carried in the message headers, mirroring the upstream\n * behavior of linking each batch-processed message to its originating producer span.\n */\nexport function getLinksFromHeaders(headers: KafkaMessage['headers']): SpanLink[] | undefined {\n  const sentryTrace = getHeaderAsString(headers, 'sentry-trace');\n  if (!sentryTrace) {\n    return undefined;\n  }\n\n  const { traceId, parentSpanId, sampled } = propagationContextFromHeaders(\n    sentryTrace,\n    getHeaderAsString(headers, 'baggage'),\n  );\n  if (!parentSpanId) {\n    return undefined;\n  }\n\n  return [\n    {\n      context: {\n        traceId,\n        spanId: parentSpanId,\n        isRemote: true,\n        traceFlags: sampled ? TRACE_FLAG_SAMPLED : TRACE_FLAG_NONE,\n      },\n    },\n  ];\n}\n\n/** Starts an inactive consumer (process/receive) span carrying the kafkajs messaging attributes. */\nexport function startConsumerSpan({ topic, message, operationType, links, attributes }: ConsumerSpanOptions): Span {\n  // The batch \"receive\" span is named `poll`; per-message spans use the operation type verbatim.\n  const operationName = operationType === MESSAGING_OPERATION_TYPE_VALUE_RECEIVE ? 'poll' : operationType;\n\n  return startInactiveSpan({\n    name: `${operationName} ${topic}`,\n    // todo(v11): Use https://getsentry.github.io/sentry-conventions/ops/#messaging\n    op: 'message',\n    kind: operationType === MESSAGING_OPERATION_TYPE_VALUE_RECEIVE ? SPAN_KIND.CLIENT : SPAN_KIND.CONSUMER,\n    links,\n    attributes: {\n      ...attributes,\n      [MESSAGING_SYSTEM]: MESSAGING_SYSTEM_VALUE_KAFKA,\n      [MESSAGING_DESTINATION_NAME]: topic,\n      [MESSAGING_OPERATION_TYPE]: operationType,\n      [MESSAGING_OPERATION_NAME]: operationName,\n      [ATTR_MESSAGING_KAFKA_MESSAGE_KEY]: message?.key ? String(message.key) : undefined,\n      [ATTR_MESSAGING_KAFKA_MESSAGE_TOMBSTONE]: message?.key && message.value === null ? true : undefined,\n      [ATTR_MESSAGING_KAFKA_OFFSET]: message?.offset as string | undefined,\n      // Mirror the upstream behavior of only tagging per-message processing spans (not the batch\n      // receiving span, which carries no message) with the auto origin.\n      ...(message ? { [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: CONSUMER_ORIGIN } : {}),\n    },\n  });\n}\n\n/** Starts an inactive producer span and propagates its trace into the message headers. */\nexport function startProducerSpan(topic: string, message: Message): Span {\n  const span = startInactiveSpan({\n    name: `send ${topic}`,\n    op: 'message',\n    kind: SPAN_KIND.PRODUCER,\n    attributes: {\n      [MESSAGING_SYSTEM]: MESSAGING_SYSTEM_VALUE_KAFKA,\n      [MESSAGING_DESTINATION_NAME]: topic,\n      [ATTR_MESSAGING_KAFKA_MESSAGE_KEY]: message.key ? String(message.key) : undefined,\n      [ATTR_MESSAGING_KAFKA_MESSAGE_TOMBSTONE]: message.key && message.value === null ? true : undefined,\n      [ATTR_MESSAGING_DESTINATION_PARTITION_ID]:\n        message.partition !== undefined ? String(message.partition) : undefined,\n      [MESSAGING_OPERATION_NAME]: 'send',\n      [MESSAGING_OPERATION_TYPE]: MESSAGING_OPERATION_TYPE_VALUE_SEND,\n      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: PRODUCER_ORIGIN,\n    },\n  });\n\n  // Propagate the producer span's trace to consumers via the message headers.\n  message.headers = message.headers ?? {};\n  const traceData = getTraceData({ span });\n  if (traceData['sentry-trace']) {\n    message.headers['sentry-trace'] = traceData['sentry-trace'];\n  }\n  if (traceData.baggage) {\n    message.headers['baggage'] = traceData.baggage;\n  }\n\n  return span;\n}\n\n/**\n * Marks all `spans` with the error status and `error.type` derived from a settle-time `reason`,\n * WITHOUT ending them. Mirrors the vendored `endSpansOnPromise` catch block. The producer path (which\n * receives discrete `error`/`asyncEnd` channel events) applies the error on `error` and ends on\n * `asyncEnd`; the consumer path folds this into `endSpansOnPromise`.\n */\nexport function applyErrorToSpans(spans: Span[], reason: unknown): void {\n  let errorMessage: string | undefined;\n  let errorType: string = ERROR_TYPE_VALUE_OTHER;\n  if (typeof reason === 'string' || reason === undefined) {\n    errorMessage = reason;\n  } else if (typeof reason === 'object' && reason !== null && Object.prototype.hasOwnProperty.call(reason, 'message')) {\n    errorMessage = (reason as { message?: string }).message;\n    errorType = (reason as { constructor: { name: string } }).constructor.name;\n  }\n\n  spans.forEach(span => {\n    span.setAttribute(ERROR_TYPE, errorType);\n    span.setStatus({ code: SPAN_STATUS_ERROR, message: errorMessage });\n  });\n}\n\n/**\n * Resolves once `promise` settles, applying the error status to all `spans` on failure and ending\n * them regardless. Used by the consumer path, which invokes the user callback directly (and so holds a\n * real promise). Verbatim from the vendored `endSpansOnPromise`.\n */\nexport function endSpansOnPromise<T>(spans: Span[], promise: Promise<T>): Promise<T> {\n  return Promise.resolve(promise)\n    .catch(reason => {\n      applyErrorToSpans(spans, reason);\n      throw reason;\n    })\n    .finally(() => {\n      spans.forEach(span => span.end());\n    });\n}\n"],"names":["propagationContextFromHeaders","attributes","MESSAGING_OPERATION_TYPE_VALUE_RECEIVE","startInactiveSpan","SPAN_KIND","MESSAGING_SYSTEM","MESSAGING_SYSTEM_VALUE_KAFKA","MESSAGING_DESTINATION_NAME","MESSAGING_OPERATION_TYPE","MESSAGING_OPERATION_NAME","ATTR_MESSAGING_KAFKA_MESSAGE_KEY","ATTR_MESSAGING_KAFKA_MESSAGE_TOMBSTONE","ATTR_MESSAGING_KAFKA_OFFSET","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN","ATTR_MESSAGING_DESTINATION_PARTITION_ID","MESSAGING_OPERATION_TYPE_VALUE_SEND","getTraceData","ERROR_TYPE_VALUE_OTHER","ERROR_TYPE","SPAN_STATUS_ERROR"],"mappings":"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"}