@drarzter/kafka-client 0.3.1 → 0.5.0

package/dist/index.js

@@ -29,6 +29,11 @@ var __decorateParam = (index, decorator) => (target, key) => decorator(target, k
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  HEADER_CORRELATION_ID: () => HEADER_CORRELATION_ID,
+  HEADER_EVENT_ID: () => HEADER_EVENT_ID,
+  HEADER_SCHEMA_VERSION: () => HEADER_SCHEMA_VERSION,
+  HEADER_TIMESTAMP: () => HEADER_TIMESTAMP,
+  HEADER_TRACEPARENT: () => HEADER_TRACEPARENT,
   InjectKafkaClient: () => InjectKafkaClient,
   KAFKA_CLIENT: () => KAFKA_CLIENT,
   KAFKA_SUBSCRIBER_METADATA: () => KAFKA_SUBSCRIBER_METADATA,
@@ -40,13 +45,78 @@ __export(index_exports, {
   KafkaRetryExhaustedError: () => KafkaRetryExhaustedError,
   KafkaValidationError: () => KafkaValidationError,
   SubscribeTo: () => SubscribeTo,
+  buildEnvelopeHeaders: () => buildEnvelopeHeaders,
+  decodeHeaders: () => decodeHeaders,
+  extractEnvelope: () => extractEnvelope,
+  getEnvelopeContext: () => getEnvelopeContext,
   getKafkaClientToken: () => getKafkaClientToken,
+  runWithEnvelopeContext: () => runWithEnvelopeContext,
   topic: () => topic
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/client/kafka.client.ts
-var import_kafkajs = require("kafkajs");
+var import_kafka_javascript = require("@confluentinc/kafka-javascript");
+
+// src/client/envelope.ts
+var import_node_async_hooks = require("async_hooks");
+var import_node_crypto = require("crypto");
+var HEADER_EVENT_ID = "x-event-id";
+var HEADER_CORRELATION_ID = "x-correlation-id";
+var HEADER_TIMESTAMP = "x-timestamp";
+var HEADER_SCHEMA_VERSION = "x-schema-version";
+var HEADER_TRACEPARENT = "traceparent";
+var envelopeStorage = new import_node_async_hooks.AsyncLocalStorage();
+function getEnvelopeContext() {
+  return envelopeStorage.getStore();
+}
+function runWithEnvelopeContext(ctx, fn) {
+  return envelopeStorage.run(ctx, fn);
+}
+function buildEnvelopeHeaders(options = {}) {
+  const ctx = getEnvelopeContext();
+  const correlationId = options.correlationId ?? ctx?.correlationId ?? (0, import_node_crypto.randomUUID)();
+  const eventId = options.eventId ?? (0, import_node_crypto.randomUUID)();
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const schemaVersion = String(options.schemaVersion ?? 1);
+  const envelope = {
+    [HEADER_EVENT_ID]: eventId,
+    [HEADER_CORRELATION_ID]: correlationId,
+    [HEADER_TIMESTAMP]: timestamp,
+    [HEADER_SCHEMA_VERSION]: schemaVersion
+  };
+  if (ctx?.traceparent) {
+    envelope[HEADER_TRACEPARENT] = ctx.traceparent;
+  }
+  return { ...envelope, ...options.headers };
+}
+function decodeHeaders(raw) {
+  if (!raw) return {};
+  const result = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (value === void 0) continue;
+    if (Array.isArray(value)) {
+      result[key] = value.map((v) => Buffer.isBuffer(v) ? v.toString() : v).join(",");
+    } else {
+      result[key] = Buffer.isBuffer(value) ? value.toString() : value;
+    }
+  }
+  return result;
+}
+function extractEnvelope(payload, headers, topic2, partition, offset) {
+  return {
+    payload,
+    topic: topic2,
+    partition,
+    offset,
+    eventId: headers[HEADER_EVENT_ID] ?? (0, import_node_crypto.randomUUID)(),
+    correlationId: headers[HEADER_CORRELATION_ID] ?? (0, import_node_crypto.randomUUID)(),
+    timestamp: headers[HEADER_TIMESTAMP] ?? (/* @__PURE__ */ new Date()).toISOString(),
+    schemaVersion: Number(headers[HEADER_SCHEMA_VERSION] ?? 1),
+    traceparent: headers[HEADER_TRACEPARENT],
+    headers
+  };
+}
 
 // src/client/errors.ts
 var KafkaProcessingError = class extends Error {
@@ -80,14 +150,159 @@ var KafkaRetryExhaustedError = class extends KafkaProcessingError {
   }
 };
 
-// src/client/kafka.client.ts
-var ACKS_ALL = -1;
+// src/client/consumer-pipeline.ts
 function toError(error) {
   return error instanceof Error ? error : new Error(String(error));
 }
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parseJsonMessage(raw, topic2, logger) {
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    logger.error(
+      `Failed to parse message from topic ${topic2}:`,
+      toError(error).stack
+    );
+    return null;
+  }
+}
+async function validateWithSchema(message, raw, topic2, schemaMap, interceptors, dlq, deps) {
+  const schema = schemaMap.get(topic2);
+  if (!schema) return message;
+  try {
+    return schema.parse(message);
+  } catch (error) {
+    const err = toError(error);
+    const validationError = new KafkaValidationError(topic2, message, {
+      cause: err
+    });
+    deps.logger.error(
+      `Schema validation failed for topic ${topic2}:`,
+      err.message
+    );
+    if (dlq) await sendToDlq(topic2, raw, deps);
+    const errorEnvelope = extractEnvelope(message, {}, topic2, -1, "");
+    for (const interceptor of interceptors) {
+      await interceptor.onError?.(errorEnvelope, validationError);
+    }
+    return null;
+  }
+}
+async function sendToDlq(topic2, rawMessage, deps) {
+  const dlqTopic = `${topic2}.dlq`;
+  try {
+    await deps.producer.send({
+      topic: dlqTopic,
+      messages: [{ value: rawMessage }]
+    });
+    deps.logger.warn(`Message sent to DLQ: ${dlqTopic}`);
+  } catch (error) {
+    deps.logger.error(
+      `Failed to send message to DLQ ${dlqTopic}:`,
+      toError(error).stack
+    );
+  }
+}
+async function executeWithRetry(fn, ctx, deps) {
+  const { envelope, rawMessages, interceptors, dlq, retry, isBatch } = ctx;
+  const maxAttempts = retry ? retry.maxRetries + 1 : 1;
+  const backoffMs = retry?.backoffMs ?? 1e3;
+  const envelopes = Array.isArray(envelope) ? envelope : [envelope];
+  const topic2 = envelopes[0]?.topic ?? "unknown";
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const cleanups = [];
+    try {
+      for (const env of envelopes) {
+        for (const inst of deps.instrumentation) {
+          const cleanup = inst.beforeConsume?.(env);
+          if (typeof cleanup === "function") cleanups.push(cleanup);
+        }
+      }
+      for (const env of envelopes) {
+        for (const interceptor of interceptors) {
+          await interceptor.before?.(env);
+        }
+      }
+      await fn();
+      for (const env of envelopes) {
+        for (const interceptor of interceptors) {
+          await interceptor.after?.(env);
+        }
+      }
+      for (const cleanup of cleanups) cleanup();
+      return;
+    } catch (error) {
+      const err = toError(error);
+      const isLastAttempt = attempt === maxAttempts;
+      for (const env of envelopes) {
+        for (const inst of deps.instrumentation) {
+          inst.onConsumeError?.(env, err);
+        }
+      }
+      for (const cleanup of cleanups) cleanup();
+      if (isLastAttempt && maxAttempts > 1) {
+        const exhaustedError = new KafkaRetryExhaustedError(
+          topic2,
+          envelopes.map((e) => e.payload),
+          maxAttempts,
+          { cause: err }
+        );
+        for (const env of envelopes) {
+          for (const interceptor of interceptors) {
+            await interceptor.onError?.(env, exhaustedError);
+          }
+        }
+      } else {
+        for (const env of envelopes) {
+          for (const interceptor of interceptors) {
+            await interceptor.onError?.(env, err);
+          }
+        }
+      }
+      deps.logger.error(
+        `Error processing ${isBatch ? "batch" : "message"} from topic ${topic2} (attempt ${attempt}/${maxAttempts}):`,
+        err.stack
+      );
+      if (isLastAttempt) {
+        if (dlq) {
+          for (const raw of rawMessages) {
+            await sendToDlq(topic2, raw, deps);
+          }
+        }
+      } else {
+        await sleep(backoffMs * attempt);
+      }
+    }
+  }
+}
+
+// src/client/subscribe-retry.ts
+async function subscribeWithRetry(consumer, topics, logger, retryOpts) {
+  const maxAttempts = retryOpts?.retries ?? 5;
+  const backoffMs = retryOpts?.backoffMs ?? 5e3;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      await consumer.subscribe({ topics });
+      return;
+    } catch (error) {
+      if (attempt === maxAttempts) throw error;
+      const msg = toError(error).message;
+      logger.warn(
+        `Failed to subscribe to [${topics.join(", ")}] (attempt ${attempt}/${maxAttempts}): ${msg}. Retrying in ${backoffMs}ms...`
+      );
+      await sleep(backoffMs);
+    }
+  }
+}
+
+// src/client/kafka.client.ts
+var { Kafka: KafkaClass, logLevel: KafkaLogLevel } = import_kafka_javascript.KafkaJS;
 var KafkaClient = class {
   kafka;
   producer;
+  txProducer;
   consumers = /* @__PURE__ */ new Map();
   admin;
   logger;
@@ -98,6 +313,7 @@ var KafkaClient = class {
   defaultGroupId;
   schemaRegistry = /* @__PURE__ */ new Map();
   runningConsumers = /* @__PURE__ */ new Map();
+  instrumentation;
   isAdminConnected = false;
   clientId;
   constructor(clientId, groupId, brokers, options) {
@@ -111,52 +327,72 @@ var KafkaClient = class {
     this.autoCreateTopicsEnabled = options?.autoCreateTopics ?? false;
     this.strictSchemasEnabled = options?.strictSchemas ?? true;
     this.numPartitions = options?.numPartitions ?? 1;
-    this.kafka = new import_kafkajs.Kafka({
-      clientId: this.clientId,
-      brokers,
-      logLevel: import_kafkajs.logLevel.WARN,
-      logCreator: () => ({ level, log }) => {
-        const msg = `[kafkajs] ${log.message}`;
-        if (level === import_kafkajs.logLevel.ERROR) {
-          const text = log.message ?? "";
-          const isRetriable = text.includes("TOPIC_ALREADY_EXISTS") || text.includes("GROUP_COORDINATOR_NOT_AVAILABLE") || text.includes("NOT_COORDINATOR") || text.includes("Response GroupCoordinator") || text.includes("Response CreateTopics");
-          if (isRetriable) this.logger.warn(msg);
-          else this.logger.error(msg);
-        } else if (level === import_kafkajs.logLevel.WARN) {
-          this.logger.warn(msg);
-        } else {
-          this.logger.log(msg);
-        }
+    this.instrumentation = options?.instrumentation ?? [];
+    this.kafka = new KafkaClass({
+      kafkaJS: {
+        clientId: this.clientId,
+        brokers,
+        logLevel: KafkaLogLevel.ERROR
       }
     });
     this.producer = this.kafka.producer({
-      createPartitioner: import_kafkajs.Partitioners.DefaultPartitioner,
-      idempotent: true,
-      transactionalId: `${clientId}-tx`,
-      maxInFlightRequests: 1
+      kafkaJS: {
+        acks: -1
+      }
     });
     this.admin = this.kafka.admin();
   }
   async sendMessage(topicOrDesc, message, options = {}) {
     const payload = this.buildSendPayload(topicOrDesc, [
-      { value: message, key: options.key, headers: options.headers }
+      {
+        value: message,
+        key: options.key,
+        headers: options.headers,
+        correlationId: options.correlationId,
+        schemaVersion: options.schemaVersion,
+        eventId: options.eventId
+      }
     ]);
     await this.ensureTopic(payload.topic);
     await this.producer.send(payload);
+    for (const inst of this.instrumentation) {
+      inst.afterSend?.(payload.topic);
+    }
   }
   async sendBatch(topicOrDesc, messages) {
     const payload = this.buildSendPayload(topicOrDesc, messages);
     await this.ensureTopic(payload.topic);
     await this.producer.send(payload);
+    for (const inst of this.instrumentation) {
+      inst.afterSend?.(payload.topic);
+    }
   }
   /** Execute multiple sends atomically. Commits on success, aborts on error. */
   async transaction(fn) {
-    const tx = await this.producer.transaction();
+    if (!this.txProducer) {
+      this.txProducer = this.kafka.producer({
+        kafkaJS: {
+          acks: -1,
+          idempotent: true,
+          transactionalId: `${this.clientId}-tx`,
+          maxInFlightRequests: 1
+        }
+      });
+      await this.txProducer.connect();
+    }
+    const tx = await this.txProducer.transaction();
     try {
       const ctx = {
         send: async (topicOrDesc, message, options = {}) => {
           const payload = this.buildSendPayload(topicOrDesc, [
-            { value: message, key: options.key, headers: options.headers }
+            {
+              value: message,
+              key: options.key,
+              headers: options.headers,
+              correlationId: options.correlationId,
+              schemaVersion: options.schemaVersion,
+              eventId: options.eventId
+            }
           ]);
           await this.ensureTopic(payload.topic);
           await tx.send(payload);
@@ -193,28 +429,41 @@ var KafkaClient = class {
   }
   async startConsumer(topics, handleMessage, options = {}) {
     const { consumer, schemaMap, gid, dlq, interceptors, retry } = await this.setupConsumer(topics, "eachMessage", options);
+    const deps = { logger: this.logger, producer: this.producer, instrumentation: this.instrumentation };
     await consumer.run({
-      autoCommit: options.autoCommit ?? true,
-      eachMessage: async ({ topic: topic2, message }) => {
+      eachMessage: async ({ topic: topic2, partition, message }) => {
         if (!message.value) {
           this.logger.warn(`Received empty message from topic ${topic2}`);
           return;
         }
         const raw = message.value.toString();
-        const parsed = this.parseJsonMessage(raw, topic2);
+        const parsed = parseJsonMessage(raw, topic2, this.logger);
         if (parsed === null) return;
-        const validated = await this.validateWithSchema(
+        const validated = await validateWithSchema(
           parsed,
           raw,
           topic2,
           schemaMap,
           interceptors,
-          dlq
+          dlq,
+          deps
         );
         if (validated === null) return;
-        await this.executeWithRetry(
-          () => handleMessage(validated, topic2),
-          { topic: topic2, messages: validated, rawMessages: [raw], interceptors, dlq, retry }
+        const headers = decodeHeaders(message.headers);
+        const envelope = extractEnvelope(
+          validated,
+          headers,
+          topic2,
+          partition,
+          message.offset
+        );
+        await executeWithRetry(
+          () => runWithEnvelopeContext(
+            { correlationId: envelope.correlationId, traceparent: envelope.traceparent },
+            () => handleMessage(envelope)
+          ),
+          { envelope, rawMessages: [raw], interceptors, dlq, retry },
+          deps
         );
       }
     });
@@ -222,15 +471,15 @@ var KafkaClient = class {
   }
   async startBatchConsumer(topics, handleBatch, options = {}) {
     const { consumer, schemaMap, gid, dlq, interceptors, retry } = await this.setupConsumer(topics, "eachBatch", options);
+    const deps = { logger: this.logger, producer: this.producer, instrumentation: this.instrumentation };
     await consumer.run({
-      autoCommit: options.autoCommit ?? true,
       eachBatch: async ({
         batch,
         heartbeat,
         resolveOffset,
         commitOffsetsIfNecessary
       }) => {
-        const validMessages = [];
+        const envelopes = [];
         const rawMessages = [];
         for (const message of batch.messages) {
           if (!message.value) {
@@ -240,21 +489,25 @@ var KafkaClient = class {
             continue;
           }
           const raw = message.value.toString();
-          const parsed = this.parseJsonMessage(raw, batch.topic);
+          const parsed = parseJsonMessage(raw, batch.topic, this.logger);
           if (parsed === null) continue;
-          const validated = await this.validateWithSchema(
+          const validated = await validateWithSchema(
             parsed,
             raw,
             batch.topic,
             schemaMap,
             interceptors,
-            dlq
+            dlq,
+            deps
           );
           if (validated === null) continue;
-          validMessages.push(validated);
+          const headers = decodeHeaders(message.headers);
+          envelopes.push(
+            extractEnvelope(validated, headers, batch.topic, batch.partition, message.offset)
+          );
           rawMessages.push(raw);
         }
-        if (validMessages.length === 0) return;
+        if (envelopes.length === 0) return;
         const meta = {
           partition: batch.partition,
           highWatermark: batch.highWatermark,
@@ -262,17 +515,17 @@ var KafkaClient = class {
           resolveOffset,
           commitOffsetsIfNecessary
         };
-        await this.executeWithRetry(
-          () => handleBatch(validMessages, batch.topic, meta),
+        await executeWithRetry(
+          () => handleBatch(envelopes, meta),
           {
-            topic: batch.topic,
-            messages: validMessages,
+            envelope: envelopes,
             rawMessages: batch.messages.filter((m) => m.value).map((m) => m.value.toString()),
             interceptors,
             dlq,
             retry,
             isBatch: true
-          }
+          },
+          deps
         );
       }
     });
@@ -304,6 +557,10 @@ var KafkaClient = class {
   /** Gracefully disconnect producer, all consumers, and admin. */
   async disconnect() {
     const tasks = [this.producer.disconnect()];
+    if (this.txProducer) {
+      tasks.push(this.txProducer.disconnect());
+      this.txProducer = void 0;
+    }
     for (const consumer of this.consumers.values()) {
       tasks.push(consumer.disconnect());
     }
@@ -317,12 +574,16 @@ var KafkaClient = class {
     this.logger.log("All connections closed");
   }
   // ── Private helpers ──────────────────────────────────────────────
-  getOrCreateConsumer(groupId) {
-    const gid = groupId || this.defaultGroupId;
-    if (!this.consumers.has(gid)) {
-      this.consumers.set(gid, this.kafka.consumer({ groupId: gid }));
+  getOrCreateConsumer(groupId, fromBeginning, autoCommit) {
+    if (!this.consumers.has(groupId)) {
+      this.consumers.set(
+        groupId,
+        this.kafka.consumer({
+          kafkaJS: { groupId, fromBeginning, autoCommit }
+        })
+      );
     }
-    return this.consumers.get(gid);
+    return this.consumers.get(groupId);
   }
   resolveTopicName(topicOrDescriptor) {
     if (typeof topicOrDescriptor === "string") return topicOrDescriptor;
@@ -362,19 +623,30 @@ var KafkaClient = class {
   }
   /**
    * Build a kafkajs-ready send payload.
-   * Handles: topic resolution, schema registration, validation, JSON serialization.
+   * Handles: topic resolution, schema registration, validation, JSON serialization,
+   * envelope header generation, and instrumentation hooks.
    */
   buildSendPayload(topicOrDesc, messages) {
     this.registerSchema(topicOrDesc);
     const topic2 = this.resolveTopicName(topicOrDesc);
     return {
       topic: topic2,
-      messages: messages.map((m) => ({
-        value: JSON.stringify(this.validateMessage(topicOrDesc, m.value)),
-        key: m.key ?? null,
-        headers: m.headers
-      })),
-      acks: ACKS_ALL
+      messages: messages.map((m) => {
+        const envelopeHeaders = buildEnvelopeHeaders({
+          correlationId: m.correlationId,
+          schemaVersion: m.schemaVersion,
+          eventId: m.eventId,
+          headers: m.headers
+        });
+        for (const inst of this.instrumentation) {
+          inst.beforeSend?.(topic2, envelopeHeaders);
+        }
+        return {
+          value: JSON.stringify(this.validateMessage(topicOrDesc, m.value)),
+          key: m.key ?? null,
+          headers: envelopeHeaders
+        };
+      })
     };
   }
   /** Shared consumer setup: groupId check, schema map, connect, subscribe. */
@@ -395,13 +667,21 @@ var KafkaClient = class {
         `Cannot use ${mode} on consumer group "${gid}" \u2014 it is already running with ${oppositeMode}. Use a different groupId for this consumer.`
       );
     }
-    const consumer = this.getOrCreateConsumer(optGroupId);
+    const consumer = this.getOrCreateConsumer(gid, fromBeginning, options.autoCommit ?? true);
     const schemaMap = this.buildSchemaMap(topics, optionSchemas);
     const topicNames = topics.map(
       (t) => this.resolveTopicName(t)
     );
+    for (const t of topicNames) {
+      await this.ensureTopic(t);
+    }
+    if (dlq) {
+      for (const t of topicNames) {
+        await this.ensureTopic(`${t}.dlq`);
+      }
+    }
     await consumer.connect();
-    await this.subscribeWithRetry(consumer, topicNames, fromBeginning, options.subscribeRetry);
+    await subscribeWithRetry(consumer, topicNames, this.logger, options.subscribeRetry);
     this.logger.log(
       `${mode === "eachBatch" ? "Batch consumer" : "Consumer"} subscribed to topics: ${topicNames.join(", ")}`
     );
@@ -424,148 +704,6 @@ var KafkaClient = class {
     }
     return schemaMap;
   }
-  /** Parse raw message as JSON. Returns null on failure (logs error). */
-  parseJsonMessage(raw, topic2) {
-    try {
-      return JSON.parse(raw);
-    } catch (error) {
-      this.logger.error(
-        `Failed to parse message from topic ${topic2}:`,
-        toError(error).stack
-      );
-      return null;
-    }
-  }
-  /**
-   * Validate a parsed message against the schema map.
-   * On failure: logs error, sends to DLQ if enabled, calls interceptor.onError.
-   * Returns validated message or null.
-   */
-  async validateWithSchema(message, raw, topic2, schemaMap, interceptors, dlq) {
-    const schema = schemaMap.get(topic2);
-    if (!schema) return message;
-    try {
-      return schema.parse(message);
-    } catch (error) {
-      const err = toError(error);
-      const validationError = new KafkaValidationError(topic2, message, {
-        cause: err
-      });
-      this.logger.error(
-        `Schema validation failed for topic ${topic2}:`,
-        err.message
-      );
-      if (dlq) await this.sendToDlq(topic2, raw);
-      for (const interceptor of interceptors) {
-        await interceptor.onError?.(message, topic2, validationError);
-      }
-      return null;
-    }
-  }
-  /**
-   * Execute a handler with retry, interceptors, and DLQ support.
-   * Used by both single-message and batch consumers.
-   */
-  async executeWithRetry(fn, ctx) {
-    const { topic: topic2, messages, rawMessages, interceptors, dlq, retry, isBatch } = ctx;
-    const maxAttempts = retry ? retry.maxRetries + 1 : 1;
-    const backoffMs = retry?.backoffMs ?? 1e3;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      try {
-        if (isBatch) {
-          for (const interceptor of interceptors) {
-            for (const msg of messages) {
-              await interceptor.before?.(msg, topic2);
-            }
-          }
-        } else {
-          for (const interceptor of interceptors) {
-            await interceptor.before?.(messages, topic2);
-          }
-        }
-        await fn();
-        if (isBatch) {
-          for (const interceptor of interceptors) {
-            for (const msg of messages) {
-              await interceptor.after?.(msg, topic2);
-            }
-          }
-        } else {
-          for (const interceptor of interceptors) {
-            await interceptor.after?.(messages, topic2);
-          }
-        }
-        return;
-      } catch (error) {
-        const err = toError(error);
-        const isLastAttempt = attempt === maxAttempts;
-        if (isLastAttempt && maxAttempts > 1) {
-          const exhaustedError = new KafkaRetryExhaustedError(
-            topic2,
-            messages,
-            maxAttempts,
-            { cause: err }
-          );
-          for (const interceptor of interceptors) {
-            await interceptor.onError?.(messages, topic2, exhaustedError);
-          }
-        } else {
-          for (const interceptor of interceptors) {
-            await interceptor.onError?.(messages, topic2, err);
-          }
-        }
-        this.logger.error(
-          `Error processing ${isBatch ? "batch" : "message"} from topic ${topic2} (attempt ${attempt}/${maxAttempts}):`,
-          err.stack
-        );
-        if (isLastAttempt) {
-          if (dlq) {
-            for (const raw of rawMessages) {
-              await this.sendToDlq(topic2, raw);
-            }
-          }
-        } else {
-          await this.sleep(backoffMs * attempt);
-        }
-      }
-    }
-  }
-  async sendToDlq(topic2, rawMessage) {
-    const dlqTopic = `${topic2}.dlq`;
-    try {
-      await this.producer.send({
-        topic: dlqTopic,
-        messages: [{ value: rawMessage }],
-        acks: ACKS_ALL
-      });
-      this.logger.warn(`Message sent to DLQ: ${dlqTopic}`);
-    } catch (error) {
-      this.logger.error(
-        `Failed to send message to DLQ ${dlqTopic}:`,
-        toError(error).stack
-      );
-    }
-  }
-  async subscribeWithRetry(consumer, topics, fromBeginning, retryOpts) {
-    const maxAttempts = retryOpts?.retries ?? 5;
-    const backoffMs = retryOpts?.backoffMs ?? 5e3;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      try {
-        await consumer.subscribe({ topics, fromBeginning });
-        return;
-      } catch (error) {
-        if (attempt === maxAttempts) throw error;
-        const msg = toError(error).message;
-        this.logger.warn(
-          `Failed to subscribe to [${topics.join(", ")}] (attempt ${attempt}/${maxAttempts}): ${msg}. Retrying in ${backoffMs}ms...`
-        );
-        await this.sleep(backoffMs);
-      }
-    }
-  }
-  sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
 };
 
 // src/client/topic.ts
@@ -664,16 +802,16 @@ var KafkaExplorer = class {
         if (entry.batch) {
           await client.startBatchConsumer(
             entry.topics,
-            async (messages, topic2, meta) => {
-              await handler(messages, topic2, meta);
+            async (envelopes, meta) => {
+              await handler(envelopes, meta);
             },
             consumerOptions
           );
         } else {
           await client.startConsumer(
             entry.topics,
-            async (message, topic2) => {
-              await handler(message, topic2);
+            async (envelope) => {
+              await handler(envelope);
             },
             consumerOptions
           );
@@ -705,6 +843,9 @@ var KafkaModule = class {
           options.brokers,
           {
             autoCreateTopics: options.autoCreateTopics,
+            strictSchemas: options.strictSchemas,
+            numPartitions: options.numPartitions,
+            instrumentation: options.instrumentation,
             logger: new import_common3.Logger(`KafkaClient:${options.clientId}`)
           }
         );
@@ -740,6 +881,9 @@ var KafkaModule = class {
           options.brokers,
           {
             autoCreateTopics: options.autoCreateTopics,
+            strictSchemas: options.strictSchemas,
+            numPartitions: options.numPartitions,
+            instrumentation: options.instrumentation,
             logger: new import_common3.Logger(`KafkaClient:${options.clientId}`)
           }
         );
@@ -793,6 +937,11 @@ KafkaHealthIndicator = __decorateClass([
 ], KafkaHealthIndicator);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  HEADER_CORRELATION_ID,
+  HEADER_EVENT_ID,
+  HEADER_SCHEMA_VERSION,
+  HEADER_TIMESTAMP,
+  HEADER_TRACEPARENT,
   InjectKafkaClient,
   KAFKA_CLIENT,
   KAFKA_SUBSCRIBER_METADATA,
@@ -804,7 +953,12 @@ KafkaHealthIndicator = __decorateClass([
   KafkaRetryExhaustedError,
   KafkaValidationError,
   SubscribeTo,
+  buildEnvelopeHeaders,
+  decodeHeaders,
+  extractEnvelope,
+  getEnvelopeContext,
   getKafkaClientToken,
+  runWithEnvelopeContext,
   topic
 });
 //# sourceMappingURL=index.js.map