@drarzter/kafka-client 0.5.4 → 0.5.5

package/dist/core.d.mts

@@ -1,5 +1,5 @@
-import { T as TopicMapConstraint, I as IKafkaClient, C as ClientId, G as GroupId, k as KafkaClientOptions, b as TopicDescriptor, n as SendOptions, B as BatchMessageItem, r as TransactionContext, e as EventEnvelope, a as ConsumerOptions, c as BatchMeta } from './envelope-BR8d1m8c.mjs';
-export { d as ConsumerInterceptor, E as EnvelopeHeaderOptions, H as HEADER_CORRELATION_ID, f as HEADER_EVENT_ID, g as HEADER_SCHEMA_VERSION, h as HEADER_TIMESTAMP, i as HEADER_TRACEPARENT, j as InferSchema, K as KafkaInstrumentation, l as KafkaLogger, M as MessageHeaders, m as MessageLostContext, R as RetryOptions, S as SchemaLike, o as SubscribeRetryOptions, p as TTopicMessageMap, q as TopicsFrom, s as buildEnvelopeHeaders, t as decodeHeaders, u as extractEnvelope, v as getEnvelopeContext, w as runWithEnvelopeContext, x as topic } from './envelope-BR8d1m8c.mjs';
+import { T as TopicMapConstraint, I as IKafkaClient, C as ClientId, G as GroupId, l as KafkaClientOptions, b as TopicDescriptor, o as SendOptions, B as BatchMessageItem, s as TransactionContext, f as EventEnvelope, a as ConsumerOptions, d as ConsumerHandle, c as BatchMeta } from './envelope-BpyKN_WL.mjs';
+export { e as ConsumerInterceptor, E as EnvelopeHeaderOptions, H as HEADER_CORRELATION_ID, g as HEADER_EVENT_ID, h as HEADER_SCHEMA_VERSION, i as HEADER_TIMESTAMP, j as HEADER_TRACEPARENT, k as InferSchema, K as KafkaInstrumentation, m as KafkaLogger, M as MessageHeaders, n as MessageLostContext, R as RetryOptions, S as SchemaLike, p as SubscribeRetryOptions, q as TTopicMessageMap, r as TopicsFrom, t as buildEnvelopeHeaders, u as decodeHeaders, v as extractEnvelope, w as getEnvelopeContext, x as runWithEnvelopeContext, y as topic } from './envelope-BpyKN_WL.mjs';
 
 /**
  * Type-safe Kafka client.
@@ -24,6 +24,7 @@ declare class KafkaClient<T extends TopicMapConstraint<T>> implements IKafkaClie
     private readonly runningConsumers;
     private readonly instrumentation;
     private readonly onMessageLost;
+    private readonly onRebalance;
     private isAdminConnected;
     readonly clientId: ClientId;
     constructor(clientId: ClientId, groupId: GroupId, brokers: string[], options?: KafkaClientOptions);
@@ -39,15 +40,25 @@ declare class KafkaClient<T extends TopicMapConstraint<T>> implements IKafkaClie
     connectProducer(): Promise<void>;
     disconnectProducer(): Promise<void>;
     /** Subscribe to topics and start consuming messages with the given handler. */
-    startConsumer<K extends Array<keyof T>>(topics: K, handleMessage: (envelope: EventEnvelope<T[K[number]]>) => Promise<void>, options?: ConsumerOptions<T>): Promise<void>;
-    startConsumer<D extends TopicDescriptor<string & keyof T, T[string & keyof T]>>(topics: D[], handleMessage: (envelope: EventEnvelope<D["__type"]>) => Promise<void>, options?: ConsumerOptions<T>): Promise<void>;
+    startConsumer<K extends Array<keyof T>>(topics: K, handleMessage: (envelope: EventEnvelope<T[K[number]]>) => Promise<void>, options?: ConsumerOptions<T>): Promise<ConsumerHandle>;
+    startConsumer<D extends TopicDescriptor<string & keyof T, T[string & keyof T]>>(topics: D[], handleMessage: (envelope: EventEnvelope<D["__type"]>) => Promise<void>, options?: ConsumerOptions<T>): Promise<ConsumerHandle>;
     /** Subscribe to topics and consume messages in batches. */
-    startBatchConsumer<K extends Array<keyof T>>(topics: K, handleBatch: (envelopes: EventEnvelope<T[K[number]]>[], meta: BatchMeta) => Promise<void>, options?: ConsumerOptions<T>): Promise<void>;
-    startBatchConsumer<D extends TopicDescriptor<string & keyof T, T[string & keyof T]>>(topics: D[], handleBatch: (envelopes: EventEnvelope<D["__type"]>[], meta: BatchMeta) => Promise<void>, options?: ConsumerOptions<T>): Promise<void>;
+    startBatchConsumer<K extends Array<keyof T>>(topics: K, handleBatch: (envelopes: EventEnvelope<T[K[number]]>[], meta: BatchMeta) => Promise<void>, options?: ConsumerOptions<T>): Promise<ConsumerHandle>;
+    startBatchConsumer<D extends TopicDescriptor<string & keyof T, T[string & keyof T]>>(topics: D[], handleBatch: (envelopes: EventEnvelope<D["__type"]>[], meta: BatchMeta) => Promise<void>, options?: ConsumerOptions<T>): Promise<ConsumerHandle>;
     stopConsumer(groupId?: string): Promise<void>;
+    /**
+     * Query consumer group lag per partition.
+     * Lag = broker high-watermark − last committed offset.
+     * A committed offset of -1 (nothing committed yet) counts as full lag.
+     */
+    getConsumerLag(groupId?: string): Promise<Array<{
+        topic: string;
+        partition: number;
+        lag: number;
+    }>>;
     /** Check broker connectivity and return status, clientId, and available topics. */
     checkStatus(): Promise<{
-        status: 'up';
+        status: "up";
         clientId: string;
         topics: string[];
     }>;
@@ -74,6 +85,11 @@ declare class KafkaClient<T extends TopicMapConstraint<T>> implements IKafkaClie
      */
     private waitForPartitionAssignment;
     private getOrCreateConsumer;
+    /**
+     * Start a timer that logs a warning if `fn` hasn't resolved within `timeoutMs`.
+     * The handler itself is not cancelled — the warning is diagnostic only.
+     */
+    private wrapWithTimeoutWarning;
     private resolveTopicName;
     private ensureTopic;
     /** Register schema from descriptor into global registry (side-effect). */
@@ -117,4 +133,4 @@ declare class KafkaRetryExhaustedError extends KafkaProcessingError {
     });
 }
 
-export { BatchMessageItem, BatchMeta, ClientId, ConsumerOptions, EventEnvelope, GroupId, IKafkaClient, KafkaClient, KafkaClientOptions, KafkaProcessingError, KafkaRetryExhaustedError, KafkaValidationError, SendOptions, TopicDescriptor, TopicMapConstraint, TransactionContext };
+export { BatchMessageItem, BatchMeta, ClientId, ConsumerHandle, ConsumerOptions, EventEnvelope, GroupId, IKafkaClient, KafkaClient, KafkaClientOptions, KafkaProcessingError, KafkaRetryExhaustedError, KafkaValidationError, SendOptions, TopicDescriptor, TopicMapConstraint, TransactionContext };

package/dist/core.d.ts

@@ -1,5 +1,5 @@
-import { T as TopicMapConstraint, I as IKafkaClient, C as ClientId, G as GroupId, k as KafkaClientOptions, b as TopicDescriptor, n as SendOptions, B as BatchMessageItem, r as TransactionContext, e as EventEnvelope, a as ConsumerOptions, c as BatchMeta } from './envelope-BR8d1m8c.js';
-export { d as ConsumerInterceptor, E as EnvelopeHeaderOptions, H as HEADER_CORRELATION_ID, f as HEADER_EVENT_ID, g as HEADER_SCHEMA_VERSION, h as HEADER_TIMESTAMP, i as HEADER_TRACEPARENT, j as InferSchema, K as KafkaInstrumentation, l as KafkaLogger, M as MessageHeaders, m as MessageLostContext, R as RetryOptions, S as SchemaLike, o as SubscribeRetryOptions, p as TTopicMessageMap, q as TopicsFrom, s as buildEnvelopeHeaders, t as decodeHeaders, u as extractEnvelope, v as getEnvelopeContext, w as runWithEnvelopeContext, x as topic } from './envelope-BR8d1m8c.js';
+import { T as TopicMapConstraint, I as IKafkaClient, C as ClientId, G as GroupId, l as KafkaClientOptions, b as TopicDescriptor, o as SendOptions, B as BatchMessageItem, s as TransactionContext, f as EventEnvelope, a as ConsumerOptions, d as ConsumerHandle, c as BatchMeta } from './envelope-BpyKN_WL.js';
+export { e as ConsumerInterceptor, E as EnvelopeHeaderOptions, H as HEADER_CORRELATION_ID, g as HEADER_EVENT_ID, h as HEADER_SCHEMA_VERSION, i as HEADER_TIMESTAMP, j as HEADER_TRACEPARENT, k as InferSchema, K as KafkaInstrumentation, m as KafkaLogger, M as MessageHeaders, n as MessageLostContext, R as RetryOptions, S as SchemaLike, p as SubscribeRetryOptions, q as TTopicMessageMap, r as TopicsFrom, t as buildEnvelopeHeaders, u as decodeHeaders, v as extractEnvelope, w as getEnvelopeContext, x as runWithEnvelopeContext, y as topic } from './envelope-BpyKN_WL.js';
 
 /**
  * Type-safe Kafka client.
@@ -24,6 +24,7 @@ declare class KafkaClient<T extends TopicMapConstraint<T>> implements IKafkaClie
     private readonly runningConsumers;
     private readonly instrumentation;
     private readonly onMessageLost;
+    private readonly onRebalance;
     private isAdminConnected;
     readonly clientId: ClientId;
     constructor(clientId: ClientId, groupId: GroupId, brokers: string[], options?: KafkaClientOptions);
@@ -39,15 +40,25 @@ declare class KafkaClient<T extends TopicMapConstraint<T>> implements IKafkaClie
     connectProducer(): Promise<void>;
     disconnectProducer(): Promise<void>;
     /** Subscribe to topics and start consuming messages with the given handler. */
-    startConsumer<K extends Array<keyof T>>(topics: K, handleMessage: (envelope: EventEnvelope<T[K[number]]>) => Promise<void>, options?: ConsumerOptions<T>): Promise<void>;
-    startConsumer<D extends TopicDescriptor<string & keyof T, T[string & keyof T]>>(topics: D[], handleMessage: (envelope: EventEnvelope<D["__type"]>) => Promise<void>, options?: ConsumerOptions<T>): Promise<void>;
+    startConsumer<K extends Array<keyof T>>(topics: K, handleMessage: (envelope: EventEnvelope<T[K[number]]>) => Promise<void>, options?: ConsumerOptions<T>): Promise<ConsumerHandle>;
+    startConsumer<D extends TopicDescriptor<string & keyof T, T[string & keyof T]>>(topics: D[], handleMessage: (envelope: EventEnvelope<D["__type"]>) => Promise<void>, options?: ConsumerOptions<T>): Promise<ConsumerHandle>;
     /** Subscribe to topics and consume messages in batches. */
-    startBatchConsumer<K extends Array<keyof T>>(topics: K, handleBatch: (envelopes: EventEnvelope<T[K[number]]>[], meta: BatchMeta) => Promise<void>, options?: ConsumerOptions<T>): Promise<void>;
-    startBatchConsumer<D extends TopicDescriptor<string & keyof T, T[string & keyof T]>>(topics: D[], handleBatch: (envelopes: EventEnvelope<D["__type"]>[], meta: BatchMeta) => Promise<void>, options?: ConsumerOptions<T>): Promise<void>;
+    startBatchConsumer<K extends Array<keyof T>>(topics: K, handleBatch: (envelopes: EventEnvelope<T[K[number]]>[], meta: BatchMeta) => Promise<void>, options?: ConsumerOptions<T>): Promise<ConsumerHandle>;
+    startBatchConsumer<D extends TopicDescriptor<string & keyof T, T[string & keyof T]>>(topics: D[], handleBatch: (envelopes: EventEnvelope<D["__type"]>[], meta: BatchMeta) => Promise<void>, options?: ConsumerOptions<T>): Promise<ConsumerHandle>;
     stopConsumer(groupId?: string): Promise<void>;
+    /**
+     * Query consumer group lag per partition.
+     * Lag = broker high-watermark − last committed offset.
+     * A committed offset of -1 (nothing committed yet) counts as full lag.
+     */
+    getConsumerLag(groupId?: string): Promise<Array<{
+        topic: string;
+        partition: number;
+        lag: number;
+    }>>;
     /** Check broker connectivity and return status, clientId, and available topics. */
     checkStatus(): Promise<{
-        status: 'up';
+        status: "up";
         clientId: string;
         topics: string[];
     }>;
@@ -74,6 +85,11 @@ declare class KafkaClient<T extends TopicMapConstraint<T>> implements IKafkaClie
      */
     private waitForPartitionAssignment;
     private getOrCreateConsumer;
+    /**
+     * Start a timer that logs a warning if `fn` hasn't resolved within `timeoutMs`.
+     * The handler itself is not cancelled — the warning is diagnostic only.
+     */
+    private wrapWithTimeoutWarning;
     private resolveTopicName;
     private ensureTopic;
     /** Register schema from descriptor into global registry (side-effect). */
@@ -117,4 +133,4 @@ declare class KafkaRetryExhaustedError extends KafkaProcessingError {
     });
 }
 
-export { BatchMessageItem, BatchMeta, ClientId, ConsumerOptions, EventEnvelope, GroupId, IKafkaClient, KafkaClient, KafkaClientOptions, KafkaProcessingError, KafkaRetryExhaustedError, KafkaValidationError, SendOptions, TopicDescriptor, TopicMapConstraint, TransactionContext };
+export { BatchMessageItem, BatchMeta, ClientId, ConsumerHandle, ConsumerOptions, EventEnvelope, GroupId, IKafkaClient, KafkaClient, KafkaClientOptions, KafkaProcessingError, KafkaRetryExhaustedError, KafkaValidationError, SendOptions, TopicDescriptor, TopicMapConstraint, TransactionContext };

package/dist/core.js

@@ -172,9 +172,20 @@ async function validateWithSchema(message, raw, topic2, schemaMap, interceptors,
         originalHeaders: deps.originalHeaders
       });
     } else {
-      await deps.onMessageLost?.({ topic: topic2, error: validationError, attempt: 0, headers: deps.originalHeaders ?? {} });
+      await deps.onMessageLost?.({
+        topic: topic2,
+        error: validationError,
+        attempt: 0,
+        headers: deps.originalHeaders ?? {}
+      });
     }
-    const errorEnvelope = extractEnvelope(message, deps.originalHeaders ?? {}, topic2, -1, "");
+    const errorEnvelope = extractEnvelope(
+      message,
+      deps.originalHeaders ?? {},
+      topic2,
+      -1,
+      ""
+    );
     for (const interceptor of interceptors) {
       await interceptor.onError?.(errorEnvelope, validationError);
     }
@@ -226,7 +237,10 @@ async function sendToRetryTopic(originalTopic, rawMessages, attempt, maxRetries,
   };
   try {
     for (const raw of rawMessages) {
-      await deps.producer.send({ topic: retryTopic, messages: [{ value: raw, headers }] });
+      await deps.producer.send({
+        topic: retryTopic,
+        messages: [{ value: raw, headers }]
+      });
     }
     deps.logger.warn(
       `Message queued in retry topic ${retryTopic} (attempt ${attempt}/${maxRetries})`
@@ -239,7 +253,15 @@ async function sendToRetryTopic(originalTopic, rawMessages, attempt, maxRetries,
   }
 }
 async function executeWithRetry(fn, ctx, deps) {
-  const { envelope, rawMessages, interceptors, dlq, retry, isBatch, retryTopics } = ctx;
+  const {
+    envelope,
+    rawMessages,
+    interceptors,
+    dlq,
+    retry,
+    isBatch,
+    retryTopics
+  } = ctx;
   const maxAttempts = retryTopics ? 1 : retry ? retry.maxRetries + 1 : 1;
   const backoffMs = retry?.backoffMs ?? 1e3;
   const maxBackoffMs = retry?.maxBackoffMs ?? 3e4;
@@ -374,6 +396,7 @@ var KafkaClient = class {
   runningConsumers = /* @__PURE__ */ new Map();
   instrumentation;
   onMessageLost;
+  onRebalance;
   isAdminConnected = false;
   clientId;
   constructor(clientId, groupId, brokers, options) {
@@ -389,6 +412,7 @@ var KafkaClient = class {
     this.numPartitions = options?.numPartitions ?? 1;
     this.instrumentation = options?.instrumentation ?? [];
     this.onMessageLost = options?.onMessageLost;
+    this.onRebalance = options?.onRebalance;
     this.kafka = new KafkaClass({
       kafkaJS: {
         clientId: this.clientId,
@@ -495,7 +519,13 @@ var KafkaClient = class {
       );
     }
     const { consumer, schemaMap, topicNames, gid, dlq, interceptors, retry } = await this.setupConsumer(topics, "eachMessage", options);
-    const deps = { logger: this.logger, producer: this.producer, instrumentation: this.instrumentation, onMessageLost: this.onMessageLost };
+    const deps = {
+      logger: this.logger,
+      producer: this.producer,
+      instrumentation: this.instrumentation,
+      onMessageLost: this.onMessageLost
+    };
+    const timeoutMs = options.handlerTimeoutMs;
     await consumer.run({
       eachMessage: async ({ topic: topic2, partition, message }) => {
         if (!message.value) {
@@ -524,11 +554,24 @@ var KafkaClient = class {
           message.offset
         );
         await executeWithRetry(
-          () => runWithEnvelopeContext(
-            { correlationId: envelope.correlationId, traceparent: envelope.traceparent },
-            () => handleMessage(envelope)
-          ),
-          { envelope, rawMessages: [raw], interceptors, dlq, retry, retryTopics: options.retryTopics },
+          () => {
+            const fn = () => runWithEnvelopeContext(
+              {
+                correlationId: envelope.correlationId,
+                traceparent: envelope.traceparent
+              },
+              () => handleMessage(envelope)
+            );
+            return timeoutMs ? this.wrapWithTimeoutWarning(fn, timeoutMs, topic2) : fn();
+          },
+          {
+            envelope,
+            rawMessages: [raw],
+            interceptors,
+            dlq,
+            retry,
+            retryTopics: options.retryTopics
+          },
           deps
         );
       }
@@ -545,10 +588,17 @@ var KafkaClient = class {
         schemaMap
       );
     }
+    return { groupId: gid, stop: () => this.stopConsumer(gid) };
   }
   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, onMessageLost: this.onMessageLost };
+    const deps = {
+      logger: this.logger,
+      producer: this.producer,
+      instrumentation: this.instrumentation,
+      onMessageLost: this.onMessageLost
+    };
+    const timeoutMs = options.handlerTimeoutMs;
     await consumer.run({
       eachBatch: async ({
         batch,
@@ -580,7 +630,13 @@ var KafkaClient = class {
           );
           if (validated === null) continue;
           envelopes.push(
-            extractEnvelope(validated, headers, batch.topic, batch.partition, message.offset)
+            extractEnvelope(
+              validated,
+              headers,
+              batch.topic,
+              batch.partition,
+              message.offset
+            )
           );
           rawMessages.push(raw);
         }
@@ -593,7 +649,10 @@ var KafkaClient = class {
           commitOffsetsIfNecessary
         };
         await executeWithRetry(
-          () => handleBatch(envelopes, meta),
+          () => {
+            const fn = () => handleBatch(envelopes, meta);
+            return timeoutMs ? this.wrapWithTimeoutWarning(fn, timeoutMs, batch.topic) : fn();
+          },
           {
             envelope: envelopes,
             rawMessages: batch.messages.filter((m) => m.value).map((m) => m.value.toString()),
@@ -607,13 +666,16 @@ var KafkaClient = class {
       }
     });
     this.runningConsumers.set(gid, "eachBatch");
+    return { groupId: gid, stop: () => this.stopConsumer(gid) };
   }
   // ── Consumer lifecycle ───────────────────────────────────────────
   async stopConsumer(groupId) {
     if (groupId !== void 0) {
       const consumer = this.consumers.get(groupId);
       if (!consumer) {
-        this.logger.warn(`stopConsumer: no active consumer for group "${groupId}"`);
+        this.logger.warn(
+          `stopConsumer: no active consumer for group "${groupId}"`
+        );
         return;
       }
       await consumer.disconnect().catch(() => {
@@ -632,6 +694,32 @@ var KafkaClient = class {
       this.logger.log("All consumers disconnected");
     }
   }
+  /**
+   * Query consumer group lag per partition.
+   * Lag = broker high-watermark − last committed offset.
+   * A committed offset of -1 (nothing committed yet) counts as full lag.
+   */
+  async getConsumerLag(groupId) {
+    const gid = groupId ?? this.defaultGroupId;
+    if (!this.isAdminConnected) {
+      await this.admin.connect();
+      this.isAdminConnected = true;
+    }
+    const committedByTopic = await this.admin.fetchOffsets({ groupId: gid });
+    const result = [];
+    for (const { topic: topic2, partitions } of committedByTopic) {
+      const brokerOffsets = await this.admin.fetchTopicOffsets(topic2);
+      for (const { partition, offset } of partitions) {
+        const broker = brokerOffsets.find((o) => o.partition === partition);
+        if (!broker) continue;
+        const committed = parseInt(offset, 10);
+        const high = parseInt(broker.high, 10);
+        const lag = committed === -1 ? high : Math.max(0, high - committed);
+        result.push({ topic: topic2, partition, lag });
+      }
+    }
+    return result;
+  }
   /** Check broker connectivity and return status, clientId, and available topics. */
   async checkStatus() {
     if (!this.isAdminConnected) {
@@ -740,19 +828,30 @@ var KafkaClient = class {
             const c = inst.beforeConsume?.(envelope);
             if (typeof c === "function") cleanups.push(c);
           }
-          for (const interceptor of interceptors) await interceptor.before?.(envelope);
+          for (const interceptor of interceptors)
+            await interceptor.before?.(envelope);
           await runWithEnvelopeContext(
-            { correlationId: envelope.correlationId, traceparent: envelope.traceparent },
+            {
+              correlationId: envelope.correlationId,
+              traceparent: envelope.traceparent
+            },
             () => handleMessage(envelope)
           );
-          for (const interceptor of interceptors) await interceptor.after?.(envelope);
+          for (const interceptor of interceptors)
+            await interceptor.after?.(envelope);
           for (const cleanup of cleanups) cleanup();
         } catch (error) {
           const err = toError(error);
           const nextAttempt = currentAttempt + 1;
           const exhausted = currentAttempt >= maxRetries;
-          for (const inst of this.instrumentation) inst.onConsumeError?.(envelope, err);
-          const reportedError = exhausted && maxRetries > 1 ? new KafkaRetryExhaustedError(originalTopic, [envelope.payload], maxRetries, { cause: err }) : err;
+          for (const inst of this.instrumentation)
+            inst.onConsumeError?.(envelope, err);
+          const reportedError = exhausted && maxRetries > 1 ? new KafkaRetryExhaustedError(
+            originalTopic,
+            [envelope.payload],
+            maxRetries,
+            { cause: err }
+          ) : err;
           for (const interceptor of interceptors) {
             await interceptor.onError?.(envelope, reportedError);
           }
@@ -823,15 +922,48 @@ var KafkaClient = class {
   }
   getOrCreateConsumer(groupId, fromBeginning, autoCommit) {
     if (!this.consumers.has(groupId)) {
-      this.consumers.set(
-        groupId,
-        this.kafka.consumer({
-          kafkaJS: { groupId, fromBeginning, autoCommit }
-        })
-      );
+      const config = {
+        kafkaJS: { groupId, fromBeginning, autoCommit }
+      };
+      if (this.onRebalance) {
+        const onRebalance = this.onRebalance;
+        config["rebalance_cb"] = (err, assignment) => {
+          const type = err.code === -175 ? "assign" : "revoke";
+          try {
+            onRebalance(
+              type,
+              assignment.map((p) => ({
+                topic: p.topic,
+                partition: p.partition
+              }))
+            );
+          } catch (e) {
+            this.logger.warn(
+              `onRebalance callback threw: ${e.message}`
+            );
+          }
+        };
+      }
+      this.consumers.set(groupId, this.kafka.consumer(config));
     }
     return this.consumers.get(groupId);
   }
+  /**
+   * Start a timer that logs a warning if `fn` hasn't resolved within `timeoutMs`.
+   * The handler itself is not cancelled — the warning is diagnostic only.
+   */
+  wrapWithTimeoutWarning(fn, timeoutMs, topic2) {
+    let timer;
+    const promise = fn().finally(() => {
+      if (timer !== void 0) clearTimeout(timer);
+    });
+    timer = setTimeout(() => {
+      this.logger.warn(
+        `Handler for topic "${topic2}" has not resolved after ${timeoutMs}ms \u2014 possible stuck handler`
+      );
+    }, timeoutMs);
+    return promise;
+  }
   resolveTopicName(topicOrDescriptor) {
     if (typeof topicOrDescriptor === "string") return topicOrDescriptor;
     if (topicOrDescriptor && typeof topicOrDescriptor === "object" && "__topic" in topicOrDescriptor) {
@@ -888,7 +1020,9 @@ var KafkaClient = class {
           inst.beforeSend?.(topic2, envelopeHeaders);
         }
         return {
-          value: JSON.stringify(await this.validateMessage(topicOrDesc, m.value)),
+          value: JSON.stringify(
+            await this.validateMessage(topicOrDesc, m.value)
+          ),
           key: m.key ?? null,
           headers: envelopeHeaders
         };
@@ -914,7 +1048,11 @@ 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(gid, fromBeginning, options.autoCommit ?? true);
+    const consumer = this.getOrCreateConsumer(
+      gid,
+      fromBeginning,
+      options.autoCommit ?? true
+    );
     const schemaMap = this.buildSchemaMap(topics, optionSchemas);
     const topicNames = topics.map(
       (t) => this.resolveTopicName(t)
@@ -928,7 +1066,12 @@ var KafkaClient = class {
       }
     }
     await consumer.connect();
-    await subscribeWithRetry(consumer, topicNames, this.logger, options.subscribeRetry);
+    await subscribeWithRetry(
+      consumer,
+      topicNames,
+      this.logger,
+      options.subscribeRetry
+    );
     this.logger.log(
       `${mode === "eachBatch" ? "Batch consumer" : "Consumer"} subscribed to topics: ${topicNames.join(", ")}`
     );