autotel-plugins 0.19.25 → 0.19.27

package/dist/kafka.cjs

@@ -14,7 +14,7 @@ function normalizeHeaders(headers) {
     if (value === void 0) {
       continue;
     }
-    normalized[key] = Buffer.isBuffer(value) ? value.toString("utf8") : value;
+    normalized[key] = Buffer.isBuffer(value) ? value.toString('utf8') : value;
   }
   return normalized;
 }
@@ -30,39 +30,48 @@ var caseInsensitiveGetter = {
   },
   keys(carrier) {
     return Object.keys(carrier);
-  }
+  },
 };
 function extractTraceContext(headers) {
-  return autotel.propagation.extract(autotel.ROOT_CONTEXT, headers, caseInsensitiveGetter);
+  return autotel.propagation.extract(
+    autotel.ROOT_CONTEXT,
+    headers,
+    caseInsensitiveGetter,
+  );
 }
 
 // src/common/constants.ts
-var SEMATTRS_MESSAGING_SYSTEM = "messaging.system";
-var SEMATTRS_MESSAGING_DESTINATION_NAME = "messaging.destination.name";
-var SEMATTRS_MESSAGING_OPERATION = "messaging.operation";
-var SEMATTRS_MESSAGING_KAFKA_CONSUMER_GROUP = "messaging.kafka.consumer.group";
-var SEMATTRS_MESSAGING_KAFKA_PARTITION = "messaging.kafka.partition";
-var SEMATTRS_MESSAGING_KAFKA_OFFSET = "messaging.kafka.offset";
-var SEMATTRS_MESSAGING_KAFKA_MESSAGE_KEY = "messaging.kafka.message.key";
-var SEMATTRS_LINKED_TRACE_ID_COUNT = "linked_trace_id_count";
-var SEMATTRS_LINKED_TRACE_ID_HASH = "linked_trace_id_hash";
-var CORRELATION_ID_HEADER = "x-correlation-id";
-var SEMATTRS_MESSAGING_BATCH_MESSAGE_COUNT = "messaging.batch.message_count";
-var SEMATTRS_MESSAGING_KAFKA_BATCH_FIRST_OFFSET = "messaging.kafka.batch.first_offset";
-var SEMATTRS_MESSAGING_KAFKA_BATCH_LAST_OFFSET = "messaging.kafka.batch.last_offset";
-var SEMATTRS_MESSAGING_KAFKA_BATCH_MESSAGES_PROCESSED = "messaging.kafka.batch.messages_processed";
-var SEMATTRS_MESSAGING_KAFKA_BATCH_MESSAGES_FAILED = "messaging.kafka.batch.messages_failed";
-var SEMATTRS_MESSAGING_KAFKA_BATCH_PROCESSING_TIME_MS = "messaging.kafka.batch.processing_time_ms";
+var SEMATTRS_MESSAGING_SYSTEM = 'messaging.system';
+var SEMATTRS_MESSAGING_DESTINATION_NAME = 'messaging.destination.name';
+var SEMATTRS_MESSAGING_OPERATION = 'messaging.operation';
+var SEMATTRS_MESSAGING_KAFKA_CONSUMER_GROUP = 'messaging.kafka.consumer.group';
+var SEMATTRS_MESSAGING_KAFKA_PARTITION = 'messaging.kafka.partition';
+var SEMATTRS_MESSAGING_KAFKA_OFFSET = 'messaging.kafka.offset';
+var SEMATTRS_MESSAGING_KAFKA_MESSAGE_KEY = 'messaging.kafka.message.key';
+var SEMATTRS_LINKED_TRACE_ID_COUNT = 'linked_trace_id_count';
+var SEMATTRS_LINKED_TRACE_ID_HASH = 'linked_trace_id_hash';
+var CORRELATION_ID_HEADER = 'x-correlation-id';
+var SEMATTRS_MESSAGING_BATCH_MESSAGE_COUNT = 'messaging.batch.message_count';
+var SEMATTRS_MESSAGING_KAFKA_BATCH_FIRST_OFFSET =
+  'messaging.kafka.batch.first_offset';
+var SEMATTRS_MESSAGING_KAFKA_BATCH_LAST_OFFSET =
+  'messaging.kafka.batch.last_offset';
+var SEMATTRS_MESSAGING_KAFKA_BATCH_MESSAGES_PROCESSED =
+  'messaging.kafka.batch.messages_processed';
+var SEMATTRS_MESSAGING_KAFKA_BATCH_MESSAGES_FAILED =
+  'messaging.kafka.batch.messages_failed';
+var SEMATTRS_MESSAGING_KAFKA_BATCH_PROCESSING_TIME_MS =
+  'messaging.kafka.batch.processing_time_ms';
 
 // src/kafka/correlation.ts
 var headerSetter = {
   set(carrier, key, value) {
     carrier[key] = value;
-  }
+  },
 };
 function deriveCorrelationId() {
   const activeBaggage = autotel.propagation.getActiveBaggage();
-  const baggageCorrelationId = activeBaggage?.getEntry("correlation-id");
+  const baggageCorrelationId = activeBaggage?.getEntry('correlation-id');
   if (baggageCorrelationId?.value) {
     return baggageCorrelationId.value;
   }
@@ -71,7 +80,7 @@ function deriveCorrelationId() {
     const spanContext = activeSpan.spanContext();
     return spanContext.traceId.slice(0, 16);
   }
-  return "";
+  return '';
 }
 function extractCorrelationId(headers) {
   const lowerKey = CORRELATION_ID_HEADER.toLowerCase();
@@ -94,21 +103,26 @@ function injectTraceHeaders(base = {}, options = {}) {
   }
   return carrier;
 }
-var DEFAULT_TRACER_NAME = "autotel-plugins/kafka";
+var DEFAULT_TRACER_NAME = 'autotel-plugins/kafka';
 function isValidSpanContext(spanContext) {
-  return !!(spanContext && spanContext.traceId && spanContext.spanId && autotel.otelTrace.isSpanContextValid(spanContext));
+  return !!(
+    spanContext &&
+    spanContext.traceId &&
+    spanContext.spanId &&
+    autotel.otelTrace.isSpanContextValid(spanContext)
+  );
 }
 async function withProcessingSpan(descriptor, fn) {
   const {
     name,
     headers,
-    contextMode = "inherit",
+    contextMode = 'inherit',
     links = [],
     topic,
     consumerGroup,
     partition,
     offset,
-    key
+    key,
   } = descriptor;
   const tracer = autotel.otelTrace.getTracer(DEFAULT_TRACER_NAME);
   const normalizedHeaders = normalizeHeaders(headers);
@@ -117,22 +131,22 @@ async function withProcessingSpan(descriptor, fn) {
   const { parentContext, spanLinks } = resolveContextAndLinks(
     contextMode,
     extractedSpanContext,
-    links
+    links,
   );
   const span = tracer.startSpan(
     name,
     {
       kind: autotel.SpanKind.CONSUMER,
-      links: spanLinks
+      links: spanLinks,
     },
-    parentContext
+    parentContext,
   );
   setMessagingAttributes(span, {
     topic,
     consumerGroup,
     partition,
     offset,
-    key
+    key,
   });
   const spanContext = autotel.otelTrace.setSpan(autotel.context.active(), span);
   try {
@@ -153,14 +167,18 @@ async function withProcessingSpan(descriptor, fn) {
     throw error;
   }
 }
-function resolveContextAndLinks(contextMode, extractedSpanContext, additionalLinks) {
+function resolveContextAndLinks(
+  contextMode,
+  extractedSpanContext,
+  additionalLinks,
+) {
   const activeSpan = autotel.otelTrace.getActiveSpan();
   const activeContext = autotel.context.active();
   const hasActiveSpan = activeSpan !== void 0;
   const hasValidExtracted = isValidSpanContext(extractedSpanContext);
   const spanLinks = [...additionalLinks];
   switch (contextMode) {
-    case "inherit": {
+    case 'inherit': {
       if (hasActiveSpan) {
         if (hasValidExtracted) {
           const activeSpanContext = activeSpan.spanContext();
@@ -173,20 +191,20 @@ function resolveContextAndLinks(contextMode, extractedSpanContext, additionalLin
         if (hasValidExtracted) {
           const extractedParentCtx = autotel.otelTrace.setSpanContext(
             activeContext,
-            extractedSpanContext
+            extractedSpanContext,
           );
           return { parentContext: extractedParentCtx, spanLinks };
         }
         return { parentContext: activeContext, spanLinks };
       }
     }
-    case "link": {
+    case 'link': {
       if (hasValidExtracted) {
         spanLinks.push({ context: extractedSpanContext });
       }
       return { parentContext: activeContext, spanLinks };
     }
-    case "none": {
+    case 'none': {
       return { parentContext: activeContext, spanLinks };
     }
     default: {
@@ -198,7 +216,7 @@ function resolveContextAndLinks(contextMode, extractedSpanContext, additionalLin
 function setMessagingAttributes(span, attrs) {
   const { topic, consumerGroup, partition, offset, key } = attrs;
   if (topic) {
-    span.setAttribute(SEMATTRS_MESSAGING_SYSTEM, "kafka");
+    span.setAttribute(SEMATTRS_MESSAGING_SYSTEM, 'kafka');
     span.setAttribute(SEMATTRS_MESSAGING_DESTINATION_NAME, topic);
   }
   if (consumerGroup) {
@@ -214,16 +232,16 @@ function setMessagingAttributes(span, attrs) {
     span.setAttribute(SEMATTRS_MESSAGING_KAFKA_MESSAGE_KEY, key);
   }
 }
-var DEFAULT_TRACER_NAME2 = "autotel-plugins/kafka";
+var DEFAULT_TRACER_NAME2 = 'autotel-plugins/kafka';
 async function withProducerSpan(descriptor, fn) {
-  const { name, topic, messageKey, system = "kafka" } = descriptor;
+  const { name, topic, messageKey, system = 'kafka' } = descriptor;
   const tracer = autotel.otelTrace.getTracer(DEFAULT_TRACER_NAME2);
   const span = tracer.startSpan(name, {
-    kind: autotel.SpanKind.PRODUCER
+    kind: autotel.SpanKind.PRODUCER,
   });
   span.setAttribute(SEMATTRS_MESSAGING_SYSTEM, system);
   span.setAttribute(SEMATTRS_MESSAGING_DESTINATION_NAME, topic);
-  span.setAttribute(SEMATTRS_MESSAGING_OPERATION, "publish");
+  span.setAttribute(SEMATTRS_MESSAGING_OPERATION, 'publish');
   if (messageKey !== void 0) {
     span.setAttribute(SEMATTRS_MESSAGING_KAFKA_MESSAGE_KEY, messageKey);
   }
@@ -248,31 +266,39 @@ async function withProducerSpan(descriptor, fn) {
 }
 var DEFAULT_MAX_LINKS = 128;
 function isValidSpanContext2(spanContext) {
-  return !!(spanContext && spanContext.traceId && spanContext.spanId && autotel.otelTrace.isSpanContextValid(spanContext));
+  return !!(
+    spanContext &&
+    spanContext.traceId &&
+    spanContext.spanId &&
+    autotel.otelTrace.isSpanContextValid(spanContext)
+  );
 }
 async function hashTraceIds(traceIds) {
-  const input = traceIds.join("|");
+  const input = traceIds.join('|');
   try {
     const encoder = new TextEncoder();
     const data = encoder.encode(input);
-    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+    const hashBuffer = await crypto.subtle.digest('SHA-256', data);
     const hashArray = new Uint8Array(hashBuffer);
-    return [...hashArray].map((byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, 16);
+    return [...hashArray]
+      .map((byte) => byte.toString(16).padStart(2, '0'))
+      .join('')
+      .slice(0, 16);
   } catch {
     let hash = 5381;
     for (let i = 0; i < input.length; i++) {
-      hash = hash * 33 ^ input.charCodeAt(i);
+      hash = (hash * 33) ^ input.charCodeAt(i);
     }
-    return (hash >>> 0).toString(16).padStart(16, "0");
+    return (hash >>> 0).toString(16).padStart(16, '0');
   }
 }
 function hashTraceIdsSync(traceIds) {
-  const input = traceIds.join("|");
+  const input = traceIds.join('|');
   let hash = 5381;
   for (let i = 0; i < input.length; i++) {
-    hash = hash * 33 ^ input.charCodeAt(i);
+    hash = (hash * 33) ^ input.charCodeAt(i);
   }
-  return (hash >>> 0).toString(16).padStart(16, "0");
+  return (hash >>> 0).toString(16).padStart(16, '0');
 }
 function extractBatchLineage(items, options = {}) {
   const { includeTraceIds = false, maxLinks = DEFAULT_MAX_LINKS } = options;
@@ -282,23 +308,29 @@ function extractBatchLineage(items, options = {}) {
     const normalizedHeaders = normalizeHeaders(item.headers);
     const extractedCtx = extractTraceContext(normalizedHeaders);
     const spanContext = autotel.otelTrace.getSpanContext(extractedCtx);
-    if (isValidSpanContext2(spanContext) && !seenTraceIds.has(spanContext.traceId)) {
+    if (
+      isValidSpanContext2(spanContext) &&
+      !seenTraceIds.has(spanContext.traceId)
+    ) {
       seenTraceIds.add(spanContext.traceId);
       extractedContexts.push({
         traceId: spanContext.traceId,
-        spanContext
+        spanContext,
       });
     }
   }
   extractedContexts.sort((a, b) => a.traceId.localeCompare(b.traceId));
   const traceIds = extractedContexts.map((ec) => ec.traceId);
-  const links = extractedContexts.slice(0, maxLinks).map((ec) => ({ context: ec.spanContext }));
-  const hash = traceIds.length > 0 ? hashTraceIdsSync(traceIds) : "0000000000000000";
+  const links = extractedContexts
+    .slice(0, maxLinks)
+    .map((ec) => ({ context: ec.spanContext }));
+  const hash =
+    traceIds.length > 0 ? hashTraceIdsSync(traceIds) : '0000000000000000';
   return {
     linked_trace_id_count: traceIds.length,
     linked_trace_id_hash: hash,
     links,
-    ...includeTraceIds && { trace_ids: traceIds }
+    ...(includeTraceIds && { trace_ids: traceIds }),
   };
 }
 async function extractBatchLineageAsync(items, options = {}) {
@@ -309,28 +341,34 @@ async function extractBatchLineageAsync(items, options = {}) {
     const normalizedHeaders = normalizeHeaders(item.headers);
     const extractedCtx = extractTraceContext(normalizedHeaders);
     const spanContext = autotel.otelTrace.getSpanContext(extractedCtx);
-    if (isValidSpanContext2(spanContext) && !seenTraceIds.has(spanContext.traceId)) {
+    if (
+      isValidSpanContext2(spanContext) &&
+      !seenTraceIds.has(spanContext.traceId)
+    ) {
       seenTraceIds.add(spanContext.traceId);
       extractedContexts.push({
         traceId: spanContext.traceId,
-        spanContext
+        spanContext,
       });
     }
   }
   extractedContexts.sort((a, b) => a.traceId.localeCompare(b.traceId));
   const traceIds = extractedContexts.map((ec) => ec.traceId);
-  const links = extractedContexts.slice(0, maxLinks).map((ec) => ({ context: ec.spanContext }));
-  const hash = traceIds.length > 0 ? await hashTraceIds(traceIds) : "0000000000000000";
+  const links = extractedContexts
+    .slice(0, maxLinks)
+    .map((ec) => ({ context: ec.spanContext }));
+  const hash =
+    traceIds.length > 0 ? await hashTraceIds(traceIds) : '0000000000000000';
   return {
     linked_trace_id_count: traceIds.length,
     linked_trace_id_hash: hash,
     links,
-    ...includeTraceIds && { trace_ids: traceIds }
+    ...(includeTraceIds && { trace_ids: traceIds }),
   };
 }
-var DEFAULT_TRACER_NAME3 = "autotel-plugins/kafka";
+var DEFAULT_TRACER_NAME3 = 'autotel-plugins/kafka';
 function withBatchConsumer(config, handler) {
-  const { name, consumerGroup, perMessageSpans = "none", onProgress } = config;
+  const { name, consumerGroup, perMessageSpans = 'none', onProgress } = config;
   const tracer = autotel.otelTrace.getTracer(DEFAULT_TRACER_NAME3);
   return async (payload) => {
     const { batch } = payload;
@@ -339,7 +377,7 @@ function withBatchConsumer(config, handler) {
     let failed = 0;
     let skipped = 0;
     const batchSpan = tracer.startSpan(name, {
-      kind: autotel.SpanKind.CONSUMER
+      kind: autotel.SpanKind.CONSUMER,
     });
     setBatchAttributes(batchSpan, {
       topic: batch.topic,
@@ -347,31 +385,34 @@ function withBatchConsumer(config, handler) {
       consumerGroup,
       messageCount: batch.messages.length,
       firstOffset: batch.firstOffset() ?? void 0,
-      lastOffset: batch.lastOffset()
+      lastOffset: batch.lastOffset(),
     });
-    const spanContext = autotel.otelTrace.setSpan(autotel.context.active(), batchSpan);
+    const spanContext = autotel.otelTrace.setSpan(
+      autotel.context.active(),
+      batchSpan,
+    );
     const {
       wrappedPayload,
       endOpenMessageSpans,
-      endRemainingMessageSpansOnSuccess
+      endRemainingMessageSpansOnSuccess,
     } = createWrappedPayload(
       payload,
       perMessageSpans,
       tracer,
       spanContext,
       (type) => {
-        if (type === "processed") processed++;
-        else if (type === "failed") failed++;
+        if (type === 'processed') processed++;
+        else if (type === 'failed') failed++;
         else skipped++;
         if (onProgress) {
           onProgress({
             processed,
             failed,
             skipped,
-            batchProcessingTimeMs: Date.now() - startTime
+            batchProcessingTimeMs: Date.now() - startTime,
           });
         }
-      }
+      },
     );
     try {
       await autotel.context.with(spanContext, async () => {
@@ -381,47 +422,47 @@ function withBatchConsumer(config, handler) {
       const processingTime = Date.now() - startTime;
       batchSpan.setAttribute(
         SEMATTRS_MESSAGING_KAFKA_BATCH_MESSAGES_PROCESSED,
-        processed
+        processed,
       );
       batchSpan.setAttribute(
         SEMATTRS_MESSAGING_KAFKA_BATCH_MESSAGES_FAILED,
-        failed
+        failed,
       );
       batchSpan.setAttribute(
         SEMATTRS_MESSAGING_KAFKA_BATCH_PROCESSING_TIME_MS,
-        processingTime
+        processingTime,
       );
       batchSpan.setStatus({ code: autotel.SpanStatusCode.OK });
       batchSpan.end();
     } catch (error) {
       endOpenMessageSpans?.(error);
       const firstMessage = batch.messages[0];
-      if (perMessageSpans === "errors" && firstMessage !== void 0) {
+      if (perMessageSpans === 'errors' && firstMessage !== void 0) {
         createMessageErrorSpan(
           name,
           {
             offset: firstMessage.offset,
             key: firstMessage.key ?? void 0,
-            headers: firstMessage.headers
+            headers: firstMessage.headers,
           },
           error instanceof Error ? error : new Error(String(error)),
           batch.topic,
-          batch.partition
+          batch.partition,
         );
       }
       const processingTime = Date.now() - startTime;
       batchSpan.setAttribute(
         SEMATTRS_MESSAGING_KAFKA_BATCH_MESSAGES_PROCESSED,
-        processed
+        processed,
       );
       batchSpan.setAttribute(
         SEMATTRS_MESSAGING_KAFKA_BATCH_MESSAGES_FAILED,
-        failed + 1
+        failed + 1,
         // Count the batch error
       );
       batchSpan.setAttribute(
         SEMATTRS_MESSAGING_KAFKA_BATCH_PROCESSING_TIME_MS,
-        processingTime
+        processingTime,
       );
       batchSpan.setStatus({ code: autotel.SpanStatusCode.ERROR });
       if (error instanceof Error) {
@@ -435,77 +476,86 @@ function withBatchConsumer(config, handler) {
   };
 }
 function setBatchAttributes(span, attrs) {
-  span.setAttribute(SEMATTRS_MESSAGING_SYSTEM, "kafka");
+  span.setAttribute(SEMATTRS_MESSAGING_SYSTEM, 'kafka');
   span.setAttribute(SEMATTRS_MESSAGING_DESTINATION_NAME, attrs.topic);
   span.setAttribute(SEMATTRS_MESSAGING_KAFKA_PARTITION, attrs.partition);
   span.setAttribute(SEMATTRS_MESSAGING_BATCH_MESSAGE_COUNT, attrs.messageCount);
   if (attrs.consumerGroup) {
     span.setAttribute(
       SEMATTRS_MESSAGING_KAFKA_CONSUMER_GROUP,
-      attrs.consumerGroup
+      attrs.consumerGroup,
     );
   }
   if (attrs.firstOffset) {
     span.setAttribute(
       SEMATTRS_MESSAGING_KAFKA_BATCH_FIRST_OFFSET,
-      attrs.firstOffset
+      attrs.firstOffset,
     );
   }
   span.setAttribute(
     SEMATTRS_MESSAGING_KAFKA_BATCH_LAST_OFFSET,
-    attrs.lastOffset
+    attrs.lastOffset,
   );
 }
-function createWrappedPayload(original, perMessageSpans, tracer, parentContext, onMetric) {
-  if (perMessageSpans === "none") {
+function createWrappedPayload(
+  original,
+  perMessageSpans,
+  tracer,
+  parentContext,
+  onMetric,
+) {
+  if (perMessageSpans === 'none') {
     return {
       wrappedPayload: {
         ...original,
         resolveOffset: (offset) => {
-          onMetric("processed");
+          onMetric('processed');
           original.resolveOffset(offset);
-        }
-      }
+        },
+      },
     };
   }
   const messageSpans = /* @__PURE__ */ new Map();
-  if (perMessageSpans === "all") {
+  if (perMessageSpans === 'all') {
     for (const message of original.batch.messages) {
       const normalizedHeaders = normalizeHeaders(message.headers);
       const extractedCtx = extractTraceContext(normalizedHeaders);
       const spanContext = autotel.otelTrace.getSpanContext(extractedCtx);
-      const parentCtx = spanContext && autotel.otelTrace.isSpanContextValid(spanContext) ? extractedCtx : parentContext;
+      const parentCtx =
+        spanContext && autotel.otelTrace.isSpanContextValid(spanContext)
+          ? extractedCtx
+          : parentContext;
       const span = tracer.startSpan(
         `${original.batch.topic}.${original.batch.partition}.${message.offset}`,
         {
-          kind: autotel.SpanKind.CONSUMER
+          kind: autotel.SpanKind.CONSUMER,
         },
-        parentCtx
+        parentCtx,
       );
       span.setAttributes({
-        [SEMATTRS_MESSAGING_SYSTEM]: "kafka",
+        [SEMATTRS_MESSAGING_SYSTEM]: 'kafka',
         [SEMATTRS_MESSAGING_DESTINATION_NAME]: original.batch.topic,
         [SEMATTRS_MESSAGING_KAFKA_PARTITION]: original.batch.partition,
         [SEMATTRS_MESSAGING_KAFKA_OFFSET]: message.offset,
-        ...message.key && {
-          [SEMATTRS_MESSAGING_KAFKA_MESSAGE_KEY]: message.key.toString()
-        }
+        ...(message.key && {
+          [SEMATTRS_MESSAGING_KAFKA_MESSAGE_KEY]: message.key.toString(),
+        }),
       });
       messageSpans.set(message.offset, span);
     }
   }
   const wrappedMessages = original.batch.messages.map((message) => ({
-    ...message
+    ...message,
   }));
   const wrappedBatch = {
     ...original.batch,
-    messages: wrappedMessages
+    messages: wrappedMessages,
   };
   const wrappedPayload = {
     ...original,
     batch: wrappedBatch,
     resolveOffset: (offset) => {
-      onMetric("processed");
+      onMetric('processed');
       const span = messageSpans.get(offset);
       if (span) {
         span.setStatus({ code: autotel.SpanStatusCode.OK });
@@ -513,31 +563,37 @@ function createWrappedPayload(original, perMessageSpans, tracer, parentContext,
         messageSpans.delete(offset);
       }
       original.resolveOffset(offset);
-    }
+    },
   };
-  const endOpenMessageSpans = perMessageSpans === "all" ? (error) => {
-    for (const [, span] of messageSpans) {
-      span.setStatus({ code: autotel.SpanStatusCode.ERROR });
-      if (error instanceof Error) {
-        span.recordException(error);
-      } else {
-        span.recordException(new Error(String(error)));
-      }
-      span.end();
-    }
-    messageSpans.clear();
-  } : void 0;
-  const endRemainingMessageSpansOnSuccess = perMessageSpans === "all" ? () => {
-    for (const [, span] of messageSpans) {
-      span.setStatus({ code: autotel.SpanStatusCode.OK });
-      span.end();
-    }
-    messageSpans.clear();
-  } : void 0;
+  const endOpenMessageSpans =
+    perMessageSpans === 'all'
+      ? (error) => {
+          for (const [, span] of messageSpans) {
+            span.setStatus({ code: autotel.SpanStatusCode.ERROR });
+            if (error instanceof Error) {
+              span.recordException(error);
+            } else {
+              span.recordException(new Error(String(error)));
+            }
+            span.end();
+          }
+          messageSpans.clear();
+        }
+      : void 0;
+  const endRemainingMessageSpansOnSuccess =
+    perMessageSpans === 'all'
+      ? () => {
+          for (const [, span] of messageSpans) {
+            span.setStatus({ code: autotel.SpanStatusCode.OK });
+            span.end();
+          }
+          messageSpans.clear();
+        }
+      : void 0;
   return {
     wrappedPayload,
     endOpenMessageSpans,
-    endRemainingMessageSpansOnSuccess
+    endRemainingMessageSpansOnSuccess,
   };
 }
 function createMessageErrorSpan(name, message, error, topic, partition) {
@@ -547,24 +603,24 @@ function createMessageErrorSpan(name, message, error, topic, partition) {
   const span = tracer.startSpan(
     `${name}.error`,
     {
-      kind: autotel.SpanKind.CONSUMER
+      kind: autotel.SpanKind.CONSUMER,
     },
-    extractedCtx
+    extractedCtx,
   );
   span.setAttributes({
-    [SEMATTRS_MESSAGING_SYSTEM]: "kafka",
+    [SEMATTRS_MESSAGING_SYSTEM]: 'kafka',
     [SEMATTRS_MESSAGING_DESTINATION_NAME]: topic,
     [SEMATTRS_MESSAGING_KAFKA_PARTITION]: partition,
     [SEMATTRS_MESSAGING_KAFKA_OFFSET]: message.offset,
-    ...message.key && {
-      [SEMATTRS_MESSAGING_KAFKA_MESSAGE_KEY]: message.key.toString()
-    }
+    ...(message.key && {
+      [SEMATTRS_MESSAGING_KAFKA_MESSAGE_KEY]: message.key.toString(),
+    }),
   });
   span.setStatus({ code: autotel.SpanStatusCode.ERROR });
   span.recordException(error);
   span.end();
 }
-var DEFAULT_TRACER_NAME4 = "autotel-plugins/kafka";
+var DEFAULT_TRACER_NAME4 = 'autotel-plugins/kafka';
 function createStreamProcessor(config) {
   const { name } = config;
   const tracer = autotel.otelTrace.getTracer(DEFAULT_TRACER_NAME4);
@@ -576,27 +632,39 @@ function createStreamProcessor(config) {
       const processorSpan = tracer.startSpan(
         name,
         {
-          kind: autotel.SpanKind.CONSUMER
+          kind: autotel.SpanKind.CONSUMER,
         },
-        inputSpanContext && autotel.otelTrace.isSpanContextValid(inputSpanContext) ? extractedCtx : void 0
+        inputSpanContext &&
+          autotel.otelTrace.isSpanContextValid(inputSpanContext)
+          ? extractedCtx
+          : void 0,
+      );
+      processorSpan.setAttribute(SEMATTRS_MESSAGING_SYSTEM, 'kafka');
+      processorSpan.setAttribute(SEMATTRS_MESSAGING_OPERATION, 'process');
+      const processorContext = autotel.otelTrace.setSpan(
+        autotel.context.active(),
+        processorSpan,
       );
-      processorSpan.setAttribute(SEMATTRS_MESSAGING_SYSTEM, "kafka");
-      processorSpan.setAttribute(SEMATTRS_MESSAGING_OPERATION, "process");
-      const processorContext = autotel.otelTrace.setSpan(autotel.context.active(), processorSpan);
       const ctx = {
         span: processorSpan,
         inputContext: inputSpanContext,
         async stage(stageName, fn) {
           return autotel.context.with(processorContext, async () => {
             const stageSpan = tracer.startSpan(`${name}.${stageName}`, {
-              kind: autotel.SpanKind.INTERNAL
+              kind: autotel.SpanKind.INTERNAL,
             });
-            stageSpan.setAttribute("stream.stage", stageName);
-            const stageContext = autotel.otelTrace.setSpan(autotel.context.active(), stageSpan);
+            stageSpan.setAttribute('stream.stage', stageName);
+            const stageContext = autotel.otelTrace.setSpan(
+              autotel.context.active(),
+              stageSpan,
+            );
             try {
-              const result = await autotel.context.with(stageContext, async () => {
-                return await fn();
-              });
+              const result = await autotel.context.with(
+                stageContext,
+                async () => {
+                  return await fn();
+                },
+              );
               stageSpan.setStatus({ code: autotel.SpanStatusCode.OK });
               stageSpan.end();
               return result;
@@ -613,33 +681,44 @@ function createStreamProcessor(config) {
           });
         },
         async produce(topic, _payload, options) {
-          const { linkToInput = false, headers: extraHeaders = {} } = options ?? {};
+          const { linkToInput = false, headers: extraHeaders = {} } =
+            options ?? {};
           const links = [];
-          if (linkToInput && inputSpanContext && autotel.otelTrace.isSpanContextValid(inputSpanContext)) {
+          if (
+            linkToInput &&
+            inputSpanContext &&
+            autotel.otelTrace.isSpanContextValid(inputSpanContext)
+          ) {
             links.push({ context: inputSpanContext });
           }
           const produceSpan = tracer.startSpan(`${name}.produce`, {
             kind: autotel.SpanKind.PRODUCER,
-            links
+            links,
           });
-          produceSpan.setAttribute(SEMATTRS_MESSAGING_SYSTEM, "kafka");
+          produceSpan.setAttribute(SEMATTRS_MESSAGING_SYSTEM, 'kafka');
           produceSpan.setAttribute(SEMATTRS_MESSAGING_DESTINATION_NAME, topic);
-          produceSpan.setAttribute(SEMATTRS_MESSAGING_OPERATION, "publish");
-          const produceContext = autotel.otelTrace.setSpan(autotel.context.active(), produceSpan);
+          produceSpan.setAttribute(SEMATTRS_MESSAGING_OPERATION, 'publish');
+          const produceContext = autotel.otelTrace.setSpan(
+            autotel.context.active(),
+            produceSpan,
+          );
           return autotel.context.with(produceContext, () => {
             const headers = injectTraceHeaders(extraHeaders, {
-              includeCorrelationIdHeader: true
+              includeCorrelationIdHeader: true,
             });
             produceSpan.setStatus({ code: autotel.SpanStatusCode.OK });
             produceSpan.end();
             return headers;
           });
-        }
+        },
       };
       try {
-        const result = await autotel.context.with(processorContext, async () => {
-          return await callback(ctx);
-        });
+        const result = await autotel.context.with(
+          processorContext,
+          async () => {
+            return await callback(ctx);
+          },
+        );
         processorSpan.setStatus({ code: autotel.SpanStatusCode.OK });
         processorSpan.end();
         return result;
@@ -653,7 +732,7 @@ function createStreamProcessor(config) {
         processorSpan.end();
         throw error;
       }
-    }
+    },
   };
 }
 var ConsumerMetrics = class {
@@ -668,61 +747,69 @@ var ConsumerMetrics = class {
   lagPollInterval;
   isRunning = false;
   constructor(config) {
-    if (config.enableLag && config.lagStrategy === "polling" && !config.lagPollIntervalMs) {
-      throw new Error("Lag polling requires lagPollIntervalMs");
+    if (
+      config.enableLag &&
+      config.lagStrategy === 'polling' &&
+      !config.lagPollIntervalMs
+    ) {
+      throw new Error('Lag polling requires lagPollIntervalMs');
     }
-    if (config.enableLag && (config.lagStrategy === "polling" || config.lagStrategy === "hybrid")) {
+    if (
+      config.enableLag &&
+      (config.lagStrategy === 'polling' || config.lagStrategy === 'hybrid')
+    ) {
       if (!config.admin) {
         throw new Error(
-          `Lag strategy '${config.lagStrategy}' requires admin client`
+          `Lag strategy '${config.lagStrategy}' requires admin client`,
         );
       }
       if (!config.groupId) {
-        throw new Error("Lag tracking requires groupId");
+        throw new Error('Lag tracking requires groupId');
       }
       if (!config.topics || config.topics.length === 0) {
-        throw new Error("Lag tracking requires topics");
+        throw new Error('Lag tracking requires topics');
       }
     }
     this.config = {
       ...config,
-      metricsPrefix: config.metricsPrefix ?? "kafka.consumer",
+      metricsPrefix: config.metricsPrefix ?? 'kafka.consumer',
       enableLag: config.enableLag ?? false,
-      lagStrategy: config.lagStrategy ?? "hybrid",
-      lagPollIntervalMs: config.lagPollIntervalMs ?? 3e4
+      lagStrategy: config.lagStrategy ?? 'hybrid',
+      lagPollIntervalMs: config.lagPollIntervalMs ?? 3e4,
     };
-    this.meter = api.metrics.getMeter("autotel-plugins/kafka");
+    this.meter = api.metrics.getMeter('autotel-plugins/kafka');
     const prefix = this.config.metricsPrefix;
     this.messagesProcessed = this.meter.createCounter(
       `${prefix}.messages_processed`,
       {
-        description: "Total number of messages processed"
-      }
+        description: 'Total number of messages processed',
+      },
     );
     this.processingDuration = this.meter.createHistogram(
       `${prefix}.processing_duration`,
       {
-        description: "Message processing duration in milliseconds",
-        unit: "ms"
-      }
+        description: 'Message processing duration in milliseconds',
+        unit: 'ms',
+      },
     );
     this.batchSize = this.meter.createHistogram(`${prefix}.batch_size`, {
-      description: "Number of messages in each batch"
+      description: 'Number of messages in each batch',
     });
     this.rebalances = this.meter.createCounter(`${prefix}.rebalances`, {
-      description: "Number of consumer group rebalances"
+      description: 'Number of consumer group rebalances',
     });
     this.lag = this.meter.createObservableGauge(`${prefix}.lag`, {
-      description: "Consumer lag per topic-partition"
+      description: 'Consumer lag per topic-partition',
     });
     if (this.config.enableLag) {
       this.lag.addCallback((observableResult) => {
         for (const [, state] of this.partitionStates.entries()) {
           if (state.highWatermark) {
-            const lagValue = BigInt(state.highWatermark) - BigInt(state.currentOffset);
+            const lagValue =
+              BigInt(state.highWatermark) - BigInt(state.currentOffset);
             observableResult.observe(Number(lagValue), {
               topic: state.topic,
-              partition: state.partition
+              partition: state.partition,
             });
           }
         }
@@ -736,18 +823,21 @@ var ConsumerMetrics = class {
     if (this.isRunning) return;
     this.isRunning = true;
     const { consumer } = this.config;
-    consumer.on("consumer.rebalancing", () => {
-      this.rebalances.add(1, { event: "rebalancing" });
+    consumer.on('consumer.rebalancing', () => {
+      this.rebalances.add(1, { event: 'rebalancing' });
     });
-    consumer.on("consumer.group_join", () => {
-      this.rebalances.add(1, { event: "group_join" });
+    consumer.on('consumer.group_join', () => {
+      this.rebalances.add(1, { event: 'group_join' });
     });
-    if (this.config.enableLag && (this.config.lagStrategy === "polling" || this.config.lagStrategy === "hybrid")) {
+    if (
+      this.config.enableLag &&
+      (this.config.lagStrategy === 'polling' ||
+        this.config.lagStrategy === 'hybrid')
+    ) {
       await this.pollLag();
       this.lagPollInterval = setInterval(
-        () => this.pollLag().catch(() => {
-        }),
-        this.config.lagPollIntervalMs
+        () => this.pollLag().catch(() => {}),
+        this.config.lagPollIntervalMs,
       );
     }
   }
@@ -800,7 +890,7 @@ var ConsumerMetrics = class {
       topic,
       partition,
       currentOffset: offset,
-      highWatermark: highWatermark ?? existing?.highWatermark
+      highWatermark: highWatermark ?? existing?.highWatermark,
     });
   }
   /**
@@ -812,15 +902,15 @@ var ConsumerMetrics = class {
     try {
       const committedOffsets = await admin.fetchOffsets({
         groupId,
-        topics
+        topics,
       });
       for (const topicOffsets of committedOffsets) {
         const topicHighWatermarks = await admin.fetchTopicOffsets(
-          topicOffsets.topic
+          topicOffsets.topic,
         );
         for (const partition of topicOffsets.partitions) {
           const hwm = topicHighWatermarks.find(
-            (p) => p.partition === partition.partition
+            (p) => p.partition === partition.partition,
           );
           if (hwm) {
             const key = `${topicOffsets.topic}-${partition.partition}`;
@@ -828,34 +918,33 @@ var ConsumerMetrics = class {
               topic: topicOffsets.topic,
               partition: partition.partition,
               currentOffset: partition.offset,
-              highWatermark: hwm.high
+              highWatermark: hwm.high,
             });
           }
         }
       }
-    } catch {
-    }
+    } catch {}
   }
 };
-var DEFAULT_TRACER_NAME5 = "autotel-plugins/kafka";
+var DEFAULT_TRACER_NAME5 = 'autotel-plugins/kafka';
 var REBALANCE_EVENTS = [
-  "consumer.group_join",
-  "consumer.rebalancing",
-  "consumer.stop"
+  'consumer.group_join',
+  'consumer.rebalancing',
+  'consumer.stop',
 ];
 var ERROR_EVENTS = [
-  "consumer.crash",
-  "consumer.disconnect",
-  "consumer.network.request_timeout"
+  'consumer.crash',
+  'consumer.disconnect',
+  'consumer.network.request_timeout',
 ];
-var HEARTBEAT_EVENTS = ["consumer.heartbeat"];
+var HEARTBEAT_EVENTS = ['consumer.heartbeat'];
 function instrumentConsumerEvents(consumer, config = {}) {
   const {
-    mode = "events",
+    mode = 'events',
     traceRebalances = true,
     traceErrors = true,
     traceHeartbeats = false,
-    lifecycleSpan
+    lifecycleSpan,
   } = config;
   const tracer = autotel.otelTrace.getTracer(DEFAULT_TRACER_NAME5);
   const listeners = [];
@@ -866,7 +955,7 @@ function instrumentConsumerEvents(consumer, config = {}) {
   if (traceRebalances) {
     for (const event of REBALANCE_EVENTS) {
       addListener(event, (payload) => {
-        if (mode === "spans") {
+        if (mode === 'spans') {
           createEventSpan(tracer, event, payload);
         } else if (lifecycleSpan) {
           lifecycleSpan.addEvent(event, extractEventAttributes(payload));
@@ -877,14 +966,14 @@ function instrumentConsumerEvents(consumer, config = {}) {
   if (traceErrors) {
     for (const event of ERROR_EVENTS) {
       addListener(event, (payload) => {
-        if (mode === "spans") {
+        if (mode === 'spans') {
           createErrorSpan(tracer, event, payload);
         } else if (lifecycleSpan) {
           lifecycleSpan.addEvent(event, {
             ...extractEventAttributes(payload),
-            "event.severity": "error"
+            'event.severity': 'error',
           });
-          if (event === "consumer.crash" && isErrorPayload(payload)) {
+          if (event === 'consumer.crash' && isErrorPayload(payload)) {
             lifecycleSpan.recordException(payload.error);
           }
         }
@@ -894,7 +983,7 @@ function instrumentConsumerEvents(consumer, config = {}) {
   if (traceHeartbeats) {
     for (const event of HEARTBEAT_EVENTS) {
       addListener(event, (payload) => {
-        if (mode === "spans") {
+        if (mode === 'spans') {
           createEventSpan(tracer, event, payload);
         } else if (lifecycleSpan) {
           lifecycleSpan.addEvent(event, extractEventAttributes(payload));
@@ -913,7 +1002,7 @@ function instrumentConsumerEvents(consumer, config = {}) {
 }
 function createEventSpan(tracer, eventName, payload) {
   const span = tracer.startSpan(`kafka.consumer.${eventName}`, {
-    kind: autotel.SpanKind.INTERNAL
+    kind: autotel.SpanKind.INTERNAL,
   });
   const attributes = extractEventAttributes(payload);
   for (const [key, value] of Object.entries(attributes)) {
@@ -924,7 +1013,7 @@ function createEventSpan(tracer, eventName, payload) {
 }
 function createErrorSpan(tracer, eventName, payload) {
   const span = tracer.startSpan(`kafka.consumer.${eventName}`, {
-    kind: autotel.SpanKind.INTERNAL
+    kind: autotel.SpanKind.INTERNAL,
   });
   const attributes = extractEventAttributes(payload);
   for (const [key, value] of Object.entries(attributes)) {
@@ -938,50 +1027,65 @@ function createErrorSpan(tracer, eventName, payload) {
 }
 function extractEventAttributes(payload) {
   const attributes = {};
-  if (!payload || typeof payload !== "object") {
+  if (!payload || typeof payload !== 'object') {
     return attributes;
   }
   const p = payload;
-  if (typeof p.groupId === "string") {
-    attributes["messaging.kafka.consumer.group"] = p.groupId;
+  if (typeof p.groupId === 'string') {
+    attributes['messaging.kafka.consumer.group'] = p.groupId;
   }
-  if (typeof p.memberId === "string") {
-    attributes["messaging.kafka.consumer.member_id"] = p.memberId;
+  if (typeof p.memberId === 'string') {
+    attributes['messaging.kafka.consumer.member_id'] = p.memberId;
   }
-  if (typeof p.leaderId === "string") {
-    attributes["messaging.kafka.consumer.leader_id"] = p.leaderId;
+  if (typeof p.leaderId === 'string') {
+    attributes['messaging.kafka.consumer.leader_id'] = p.leaderId;
   }
-  if (typeof p.duration === "number") {
-    attributes["event.duration_ms"] = p.duration;
+  if (typeof p.duration === 'number') {
+    attributes['event.duration_ms'] = p.duration;
   }
-  if (typeof p.isLeader === "boolean") {
-    attributes["messaging.kafka.consumer.is_leader"] = p.isLeader;
+  if (typeof p.isLeader === 'boolean') {
+    attributes['messaging.kafka.consumer.is_leader'] = p.isLeader;
   }
   if (Array.isArray(p.memberAssignment)) {
-    attributes["messaging.kafka.consumer.assignment_count"] = p.memberAssignment.length;
+    attributes['messaging.kafka.consumer.assignment_count'] =
+      p.memberAssignment.length;
   }
-  if (typeof p.type === "string") {
-    attributes["event.type"] = p.type;
+  if (typeof p.type === 'string') {
+    attributes['event.type'] = p.type;
   }
   return attributes;
 }
 function isErrorPayload(payload) {
-  return payload !== null && typeof payload === "object" && "error" in payload && payload.error instanceof Error;
+  return (
+    payload !== null &&
+    typeof payload === 'object' &&
+    'error' in payload &&
+    payload.error instanceof Error
+  );
 }
 
 exports.CORRELATION_ID_HEADER = CORRELATION_ID_HEADER;
 exports.ConsumerMetrics = ConsumerMetrics;
 exports.SEMATTRS_LINKED_TRACE_ID_COUNT = SEMATTRS_LINKED_TRACE_ID_COUNT;
 exports.SEMATTRS_LINKED_TRACE_ID_HASH = SEMATTRS_LINKED_TRACE_ID_HASH;
-exports.SEMATTRS_MESSAGING_BATCH_MESSAGE_COUNT = SEMATTRS_MESSAGING_BATCH_MESSAGE_COUNT;
-exports.SEMATTRS_MESSAGING_DESTINATION_NAME = SEMATTRS_MESSAGING_DESTINATION_NAME;
-exports.SEMATTRS_MESSAGING_KAFKA_BATCH_FIRST_OFFSET = SEMATTRS_MESSAGING_KAFKA_BATCH_FIRST_OFFSET;
-exports.SEMATTRS_MESSAGING_KAFKA_BATCH_LAST_OFFSET = SEMATTRS_MESSAGING_KAFKA_BATCH_LAST_OFFSET;
-exports.SEMATTRS_MESSAGING_KAFKA_BATCH_MESSAGES_FAILED = SEMATTRS_MESSAGING_KAFKA_BATCH_MESSAGES_FAILED;
-exports.SEMATTRS_MESSAGING_KAFKA_BATCH_MESSAGES_PROCESSED = SEMATTRS_MESSAGING_KAFKA_BATCH_MESSAGES_PROCESSED;
-exports.SEMATTRS_MESSAGING_KAFKA_BATCH_PROCESSING_TIME_MS = SEMATTRS_MESSAGING_KAFKA_BATCH_PROCESSING_TIME_MS;
-exports.SEMATTRS_MESSAGING_KAFKA_CONSUMER_GROUP = SEMATTRS_MESSAGING_KAFKA_CONSUMER_GROUP;
-exports.SEMATTRS_MESSAGING_KAFKA_MESSAGE_KEY = SEMATTRS_MESSAGING_KAFKA_MESSAGE_KEY;
+exports.SEMATTRS_MESSAGING_BATCH_MESSAGE_COUNT =
+  SEMATTRS_MESSAGING_BATCH_MESSAGE_COUNT;
+exports.SEMATTRS_MESSAGING_DESTINATION_NAME =
+  SEMATTRS_MESSAGING_DESTINATION_NAME;
+exports.SEMATTRS_MESSAGING_KAFKA_BATCH_FIRST_OFFSET =
+  SEMATTRS_MESSAGING_KAFKA_BATCH_FIRST_OFFSET;
+exports.SEMATTRS_MESSAGING_KAFKA_BATCH_LAST_OFFSET =
+  SEMATTRS_MESSAGING_KAFKA_BATCH_LAST_OFFSET;
+exports.SEMATTRS_MESSAGING_KAFKA_BATCH_MESSAGES_FAILED =
+  SEMATTRS_MESSAGING_KAFKA_BATCH_MESSAGES_FAILED;
+exports.SEMATTRS_MESSAGING_KAFKA_BATCH_MESSAGES_PROCESSED =
+  SEMATTRS_MESSAGING_KAFKA_BATCH_MESSAGES_PROCESSED;
+exports.SEMATTRS_MESSAGING_KAFKA_BATCH_PROCESSING_TIME_MS =
+  SEMATTRS_MESSAGING_KAFKA_BATCH_PROCESSING_TIME_MS;
+exports.SEMATTRS_MESSAGING_KAFKA_CONSUMER_GROUP =
+  SEMATTRS_MESSAGING_KAFKA_CONSUMER_GROUP;
+exports.SEMATTRS_MESSAGING_KAFKA_MESSAGE_KEY =
+  SEMATTRS_MESSAGING_KAFKA_MESSAGE_KEY;
 exports.SEMATTRS_MESSAGING_KAFKA_OFFSET = SEMATTRS_MESSAGING_KAFKA_OFFSET;
 exports.SEMATTRS_MESSAGING_KAFKA_PARTITION = SEMATTRS_MESSAGING_KAFKA_PARTITION;
 exports.SEMATTRS_MESSAGING_OPERATION = SEMATTRS_MESSAGING_OPERATION;
@@ -1000,4 +1104,4 @@ exports.withBatchConsumer = withBatchConsumer;
 exports.withProcessingSpan = withProcessingSpan;
 exports.withProducerSpan = withProducerSpan;
 //# sourceMappingURL=kafka.cjs.map
-//# sourceMappingURL=kafka.cjs.map
+//# sourceMappingURL=kafka.cjs.map