@platformatic/kafka 1.0.0 → 1.1.0

package/README.md

@@ -264,6 +264,7 @@ Many of the methods accept the same options as the client's constructors. The co
 - [Admin API](./docs/admin.md)
 - [Base Client](./docs/base.md)
 - [Metrics](./docs/metrics.md)
+- [Diagnostic and Instrumentation](./docs/diagnostic.md)
 - [Other APIs and Types](./docs/other.md)
 
 ## Requirements

package/dist/apis/definitions.js

@@ -1,7 +1,6 @@
 import { promisify } from 'node:util';
 export function createAPI(apiKey, apiVersion, createRequest, parseResponse, hasRequestHeaderTaggedFields = true, hasResponseHeaderTaggedFields = true) {
     const api = function api(connection, ...args) {
-        /* c8 ignore next */
         const cb = typeof args[args.length - 1] === 'function' ? args.pop() : () => { };
         connection.send(apiKey, apiVersion, () => createRequest(...args), parseResponse, hasRequestHeaderTaggedFields, hasResponseHeaderTaggedFields, cb);
     };

package/dist/clients/admin/admin.js

@@ -5,13 +5,15 @@ import { api as describeGroupsV5 } from "../../apis/admin/describe-groups.js";
 import { api as listGroupsV5 } from "../../apis/admin/list-groups.js";
 import { FindCoordinatorKeyTypes } from "../../apis/enumerations.js";
 import { api as findCoordinatorV6 } from "../../apis/metadata/find-coordinator.js";
+import { adminGroupsChannel, adminTopicsChannel, createDiagnosticContext } from "../../diagnostic.js";
 import { Reader } from "../../protocol/reader.js";
-import { Base, kBootstrapBrokers, kCheckNotClosed, kConnections, kMetadata, kOptions, kPerformDeduplicated, kPerformWithRetry, kValidateOptions } from "../base/base.js";
+import { Base, kAfterCreate, kBootstrapBrokers, kCheckNotClosed, kConnections, kMetadata, kOptions, kPerformDeduplicated, kPerformWithRetry, kValidateOptions } from "../base/base.js";
 import { createPromisifiedCallback, kCallbackPromise, runConcurrentCallbacks } from "../callbacks.js";
 import { createTopicsOptionsValidator, deleteGroupsOptionsValidator, deleteTopicsOptionsValidator, describeGroupsOptionsValidator, listGroupsOptionsValidator } from "./options.js";
 export class Admin extends Base {
     constructor(options) {
         super(options);
+        this[kAfterCreate]('admin');
     }
     createTopics(options, callback) {
         if (!callback) {
@@ -25,7 +27,7 @@ export class Admin extends Base {
             callback(validationError, undefined);
             return callback[kCallbackPromise];
         }
-        this.#createTopics(options, callback);
+        adminTopicsChannel.traceCallback(this.#createTopics, 1, createDiagnosticContext({ client: this, operation: 'createTopics', options }), this, options, callback);
         return callback[kCallbackPromise];
     }
     deleteTopics(options, callback) {
@@ -40,7 +42,7 @@ export class Admin extends Base {
             callback(validationError, undefined);
             return callback[kCallbackPromise];
         }
-        this.#deleteTopics(options, callback);
+        adminTopicsChannel.traceCallback(this.#deleteTopics, 1, createDiagnosticContext({ client: this, operation: 'deleteTopics', options }), this, options, callback);
         return callback[kCallbackPromise];
     }
     listGroups(options, callback) {
@@ -59,7 +61,7 @@ export class Admin extends Base {
             return callback[kCallbackPromise];
         }
         options.types ??= ['classic'];
-        this.#listGroups(options, callback);
+        adminGroupsChannel.traceCallback(this.#listGroups, 1, createDiagnosticContext({ client: this, operation: 'listGroups', options }), this, options, callback);
         return callback[kCallbackPromise];
     }
     describeGroups(options, callback) {
@@ -74,7 +76,7 @@ export class Admin extends Base {
             callback(validationError, undefined);
             return callback[kCallbackPromise];
         }
-        this.#describeGroups(options, callback);
+        adminGroupsChannel.traceCallback(this.#describeGroups, 1, createDiagnosticContext({ client: this, operation: 'describeGroups', options }), this, options, callback);
         return callback[kCallbackPromise];
     }
     deleteGroups(options, callback) {
@@ -89,7 +91,7 @@ export class Admin extends Base {
             callback(validationError, undefined);
             return callback[kCallbackPromise];
         }
-        this.#deleteGroups(options, callback);
+        adminGroupsChannel.traceCallback(this.#deleteGroups, 1, createDiagnosticContext({ client: this, operation: 'deleteGroups', options }), this, options, callback);
         return callback[kCallbackPromise];
     }
     #createTopics(options, callback) {
@@ -150,7 +152,7 @@ export class Admin extends Base {
                     deleteTopicsV6(connection, requests, this[kOptions].timeout, retryCallback);
                 });
             }, deduplicateCallback, 0);
-        }, callback);
+        }, error => callback(error));
     }
     #listGroups(options, callback) {
         // Find all the brokers in the cluster
@@ -296,9 +298,7 @@ export class Admin extends Base {
                             deleteGroupsV2(connection, groups, retryCallback);
                         }, concurrentCallback, 0);
                     });
-                }, error => {
-                    callback(error);
-                });
+                }, error => callback(error));
             });
         });
     }

package/dist/clients/base/base.d.ts

@@ -1,8 +1,10 @@
 import { type ValidateFunction } from 'ajv';
 import { EventEmitter } from 'node:events';
 import { type Callback } from '../../apis/definitions.ts';
+import { type ClientType } from '../../diagnostic.ts';
 import { ConnectionPool } from '../../network/connection-pool.ts';
 import { type Broker } from '../../network/connection.ts';
+import { kInstance } from '../../symbols.ts';
 import { type CallbackWithPromise } from '../callbacks.ts';
 import { type Metrics } from '../metrics.ts';
 import { type BaseOptions, type ClusterMetadata, type MetadataOptions } from './types.ts';
@@ -22,20 +24,24 @@ export declare const kPerformDeduplicated: unique symbol;
 export declare const kValidateOptions: unique symbol;
 export declare const kInspect: unique symbol;
 export declare const kFormatValidationErrors: unique symbol;
-export declare const kInstance: unique symbol;
 export declare const kPrometheus: unique symbol;
-export declare class Base<OptionsType extends BaseOptions> extends EventEmitter {
+export declare const kClientType: unique symbol;
+export declare const kAfterCreate: unique symbol;
+export declare class Base<OptionsType extends BaseOptions = BaseOptions> extends EventEmitter {
     #private;
     [kInstance]: number;
     [kClientId]: string;
+    [kClientType]: ClientType;
     [kBootstrapBrokers]: Broker[];
     [kOptions]: OptionsType;
     [kConnections]: ConnectionPool;
     [kClosed]: boolean;
     [kPrometheus]: Metrics | undefined;
     constructor(options: OptionsType);
+    get instanceId(): number;
     get clientId(): string;
     get closed(): boolean;
+    get type(): ClientType;
     emitWithDebug(section: string | null, name: string, ...args: any[]): boolean;
     close(callback: CallbackWithPromise<void>): void;
     close(): Promise<void>;
@@ -51,4 +57,5 @@ export declare class Base<OptionsType extends BaseOptions> extends EventEmitter
     [kValidateOptions](target: unknown, validator: ValidateFunction<unknown>, targetName: string, throwOnErrors?: boolean): Error | null;
     [kInspect](...args: unknown[]): void;
     [kFormatValidationErrors](validator: ValidateFunction<unknown>, targetName: string): string;
+    [kAfterCreate](type: ClientType): void;
 }

package/dist/clients/base/base.js

@@ -1,7 +1,9 @@
 import { EventEmitter } from 'node:events';
 import { api as metadataV12 } from "../../apis/metadata/metadata.js";
+import { baseMetadataChannel, createDiagnosticContext, notifyCreation } from "../../diagnostic.js";
 import { MultipleErrors, NetworkError, UserError } from "../../errors.js";
 import { ConnectionPool } from "../../network/connection-pool.js";
+import { kInstance } from "../../symbols.js";
 import { ajv, debugDump, loggers } from "../../utils.js";
 import { createPromisifiedCallback, kCallbackPromise } from "../callbacks.js";
 import { baseOptionsValidator, defaultBaseOptions, defaultPort, metadataOptionsValidator } from "./options.js";
@@ -21,14 +23,16 @@ export const kPerformDeduplicated = Symbol('plt.kafka.base.performDeduplicated')
 export const kValidateOptions = Symbol('plt.kafka.base.validateOptions');
 export const kInspect = Symbol('plt.kafka.base.inspect');
 export const kFormatValidationErrors = Symbol('plt.kafka.base.formatValidationErrors');
-export const kInstance = Symbol('plt.kafka.base.instance');
 export const kPrometheus = Symbol('plt.kafka.base.prometheus');
+export const kClientType = Symbol('plt.kafka.base.clientType');
+export const kAfterCreate = Symbol('plt.kafka.base.afterCreate');
 let currentInstance = 0;
 export class Base extends EventEmitter {
-    // This is just used for debugging
+    // This is declared using a symbol (a.k.a protected/friend) to make it available in ConnectionPool and MessagesStream
     [kInstance];
     // General status - Use symbols rather than JS private property to make them "protected" as in C++
     [kClientId];
+    [kClientType];
     [kBootstrapBrokers];
     [kOptions];
     [kConnections];
@@ -38,6 +42,7 @@ export class Base extends EventEmitter {
     #inflightDeduplications;
     constructor(options) {
         super();
+        this[kClientType] = 'base';
         this[kInstance] = currentInstance++;
         // Validate options
         this[kOptions] = Object.assign({}, defaultBaseOptions, options);
@@ -57,19 +62,22 @@ export class Base extends EventEmitter {
             this[kPrometheus] = options.metrics;
         }
     }
-    /* c8 ignore next 3 */
+    get instanceId() {
+        return this[kInstance];
+    }
     get clientId() {
         return this[kClientId];
     }
-    /* c8 ignore next 3 */
     get closed() {
         return this[kClosed] === true;
     }
+    get type() {
+        return this[kClientType];
+    }
     emitWithDebug(section, name, ...args) {
         if (!section) {
             return this.emit(name, ...args);
         }
-        /* c8 ignore next */
         loggers[section]?.({ event: name, payload: args });
         return this.emit(`${section}:${name}`, ...args);
     }
@@ -90,7 +98,7 @@ export class Base extends EventEmitter {
             callback(validationError, undefined);
             return callback[kCallbackPromise];
         }
-        this[kMetadata](options, callback);
+        baseMetadataChannel.traceCallback(this[kMetadata], 1, createDiagnosticContext({ client: this, operation: 'metadata' }), this, options, callback);
         return callback[kCallbackPromise];
     }
     [kCreateConnectionPool]() {
@@ -135,7 +143,7 @@ export class Base extends EventEmitter {
                     brokers.set(broker.nodeId, { host, port });
                 }
                 for (const { name, topicId: id, partitions: rawPartitions, isInternal } of metadata.topics) {
-                    /* c8 ignore next 3 */
+                    /* c8 ignore next 3 - Sometimes internal topics might be returned by Kafka */
                     if (isInternal) {
                         continue;
                     }
@@ -242,12 +250,15 @@ export class Base extends EventEmitter {
         }
         return null;
     }
-    // This is a private API used to debug during development
-    /* c8 ignore next 3 */
+    /* c8 ignore next 3 -- This is a private API used to debug during development */
     [kInspect](...args) {
         debugDump(`client:${this[kInstance]}`, ...args);
     }
     [kFormatValidationErrors](validator, targetName) {
         return ajv.errorsText(validator.errors, { dataVar: '$dataVar$' }).replaceAll('$dataVar$', targetName) + '.';
     }
+    [kAfterCreate](type) {
+        this[kClientType] = type;
+        notifyCreation(type, this);
+    }
 }

package/dist/clients/callbacks.d.ts

@@ -1,5 +1,6 @@
 import { type Callback } from '../apis/definitions.ts';
 export declare const kCallbackPromise: unique symbol;
+export declare const kNoopCallbackReturnValue: unique symbol;
 export declare const noopCallback: CallbackWithPromise<any>;
 export type CallbackWithPromise<ReturnType> = Callback<ReturnType> & {
     [kCallbackPromise]?: Promise<ReturnType>;

package/dist/clients/callbacks.js

@@ -1,8 +1,9 @@
 import { MultipleErrors } from "../errors.js";
 export const kCallbackPromise = Symbol('plt.kafka.callbackPromise');
-/* c8 ignore next 3 */
+// This is only meaningful for testing
+export const kNoopCallbackReturnValue = Symbol('plt.kafka.noopCallbackReturnValue');
 export const noopCallback = () => {
-    return Promise.resolve();
+    return Promise.resolve(kNoopCallbackReturnValue);
 };
 export function createPromisifiedCallback() {
     const { promise, resolve, reject } = Promise.withResolvers();

package/dist/clients/consumer/consumer.js

@@ -8,10 +8,11 @@ import { api as offsetFetchV9 } from "../../apis/consumer/offset-fetch.js";
 import { api as syncGroupV5 } from "../../apis/consumer/sync-group.js";
 import { FetchIsolationLevels, FindCoordinatorKeyTypes } from "../../apis/enumerations.js";
 import { api as findCoordinatorV6 } from "../../apis/metadata/find-coordinator.js";
+import { consumerCommitsChannel, consumerConsumesChannel, consumerFetchesChannel, consumerGroupChannel, consumerHeartbeatChannel, consumerOffsetsChannel, createDiagnosticContext } from "../../diagnostic.js";
 import { UserError } from "../../errors.js";
 import { Reader } from "../../protocol/reader.js";
 import { Writer } from "../../protocol/writer.js";
-import { Base, kBootstrapBrokers, kCheckNotClosed, kClosed, kConnections, kCreateConnectionPool, kFetchConnections, kFormatValidationErrors, kMetadata, kOptions, kPerformDeduplicated, kPerformWithRetry, kPrometheus, kValidateOptions } from "../base/base.js";
+import { Base, kAfterCreate, kBootstrapBrokers, kCheckNotClosed, kClosed, kConnections, kCreateConnectionPool, kFetchConnections, kFormatValidationErrors, kMetadata, kOptions, kPerformDeduplicated, kPerformWithRetry, kPrometheus, kValidateOptions } from "../base/base.js";
 import { defaultBaseOptions } from "../base/options.js";
 import { createPromisifiedCallback, kCallbackPromise, runConcurrentCallbacks } from "../callbacks.js";
 import { ensureMetric } from "../metrics.js";
@@ -72,6 +73,7 @@ export class Consumer extends Base {
             this.#metricActiveStreams = ensureMetric(this[kPrometheus], 'Gauge', 'kafka_consumers_streams', 'Number of active Kafka consumers streams');
             this.topics.setMetric(ensureMetric(this[kPrometheus], 'Gauge', 'kafka_consumers_topics', 'Number of topics being consumed'));
         }
+        this[kAfterCreate]('consumer');
     }
     get streamsCount() {
         return this.#streams.size;
@@ -153,7 +155,7 @@ export class Consumer extends Base {
             callback(validationError, undefined);
             return callback[kCallbackPromise];
         }
-        this.#fetch(options, callback);
+        consumerFetchesChannel.traceCallback(this.#fetch, 1, createDiagnosticContext({ client: this, operation: 'fetch', options }), this, options, callback);
         return callback[kCallbackPromise];
     }
     commit(options, callback) {
@@ -168,7 +170,7 @@ export class Consumer extends Base {
             callback(validationError);
             return callback[kCallbackPromise];
         }
-        this.#commit(options, callback);
+        consumerCommitsChannel.traceCallback(this.#commit, 1, createDiagnosticContext({ client: this, operation: 'commit', options }), this, options, callback);
         return callback[kCallbackPromise];
     }
     listOffsets(options, callback) {
@@ -183,7 +185,7 @@ export class Consumer extends Base {
             callback(validationError, undefined);
             return callback[kCallbackPromise];
         }
-        this.#listOffsets(options, callback);
+        consumerOffsetsChannel.traceCallback(this.#listOffsets, 1, createDiagnosticContext({ client: this, operation: 'listOffsets', options }), this, options, callback);
         return callback[kCallbackPromise];
     }
     listCommittedOffsets(options, callback) {
@@ -198,7 +200,7 @@ export class Consumer extends Base {
             callback(validationError, undefined);
             return callback[kCallbackPromise];
         }
-        this.#listCommittedOffsets(options, callback);
+        consumerOffsetsChannel.traceCallback(this.#listCommittedOffsets, 1, createDiagnosticContext({ client: this, operation: 'listCommittedOffsets', options }), this, options, callback);
         return callback[kCallbackPromise];
     }
     findGroupCoordinator(callback) {
@@ -258,37 +260,8 @@ export class Consumer extends Base {
         });
         return callback[kCallbackPromise];
     }
-    #consume(options, callback, trackTopics = true) {
-        // Subscribe all topics
-        let joinNeeded = this.memberId === null;
-        if (trackTopics) {
-            for (const topic of options.topics) {
-                if (this.topics.track(topic)) {
-                    joinNeeded = true;
-                }
-            }
-        }
-        // If we need to (re)join the group, do that first and then try again
-        if (joinNeeded) {
-            this.joinGroup(options, error => {
-                if (error) {
-                    callback(error, undefined);
-                    return;
-                }
-                this.#consume(options, callback, false);
-            });
-            return callback[kCallbackPromise];
-        }
-        // Create the stream and start consuming
-        const stream = new MessagesStream(this, options);
-        this.#streams.add(stream);
-        this.#metricActiveStreams?.inc();
-        stream.once('close', () => {
-            this.#metricActiveStreams?.dec();
-            this.#streams.delete(stream);
-        });
-        callback(null, stream);
-        return callback[kCallbackPromise];
+    #consume(options, callback) {
+        consumerConsumesChannel.traceCallback(this.#performConsume, 2, createDiagnosticContext({ client: this, operation: 'consume', options }), this, options, true, callback);
     }
     #fetch(options, callback) {
         this[kPerformWithRetry]('fetch', retryCallback => {
@@ -427,6 +400,91 @@ export class Consumer extends Base {
             callback(null, this.#coordinatorId);
             return;
         }
+        consumerGroupChannel.traceCallback(this.#performFindGroupCoordinator, 0, createDiagnosticContext({ client: this, operation: 'findGroupCoordinator' }), this, callback);
+    }
+    #joinGroup(options, callback) {
+        consumerGroupChannel.traceCallback(this.#performJoinGroup, 1, createDiagnosticContext({ client: this, operation: 'joinGroup', options }), this, options, callback);
+    }
+    #leaveGroup(force, callback) {
+        consumerGroupChannel.traceCallback(this.#performLeaveGroup, 1, createDiagnosticContext({ client: this, operation: 'leaveGroup', force }), this, force, callback);
+    }
+    #syncGroup(callback) {
+        consumerGroupChannel.traceCallback(this.#performSyncGroup, 1, createDiagnosticContext({ client: this, operation: 'syncGroup' }), this, null, callback);
+    }
+    #heartbeat(options) {
+        const eventPayload = { groupId: this.groupId, memberId: this.memberId, generationId: this.generationId };
+        consumerHeartbeatChannel.traceCallback((this.#performDeduplicateGroupOperaton), 2, createDiagnosticContext({ client: this, operation: 'heartbeat' }), this, 'heartbeat', (connection, groupCallback) => {
+            // We have left the group in the meanwhile, abort
+            if (!this.#membershipActive) {
+                this.emitWithDebug('consumer:heartbeat', 'cancel', eventPayload);
+                return;
+            }
+            this.emitWithDebug('consumer:heartbeat', 'start', eventPayload);
+            heartbeatV4(connection, this.groupId, this.generationId, this.memberId, null, groupCallback);
+        }, error => {
+            // The heartbeat has been aborted elsewhere, ignore the response
+            if (this.#heartbeatInterval === null || !this.#membershipActive) {
+                this.emitWithDebug('consumer:heartbeat', 'cancel', eventPayload);
+                return;
+            }
+            if (error) {
+                this.#cancelHeartbeat();
+                if (this.#getRejoinError(error)) {
+                    this[kPerformWithRetry]('rejoinGroup', retryCallback => {
+                        this.#joinGroup(options, retryCallback);
+                    }, error => {
+                        if (error) {
+                            this.emitWithDebug(null, 'error', error);
+                        }
+                        this.emitWithDebug('consumer', 'rejoin');
+                    }, 0);
+                    return;
+                }
+                this.emitWithDebug('consumer:heartbeat', 'error', { ...eventPayload, error });
+                // Note that here we purposely do not return, since it was not a group related problem we schedule another heartbeat
+            }
+            else {
+                this.emitWithDebug('consumer:heartbeat', 'end', eventPayload);
+            }
+            this.#heartbeatInterval?.refresh();
+        });
+    }
+    #cancelHeartbeat() {
+        clearTimeout(this.#heartbeatInterval);
+        this.#heartbeatInterval = null;
+    }
+    #performConsume(options, trackTopics, callback) {
+        // Subscribe all topics
+        let joinNeeded = this.memberId === null;
+        if (trackTopics) {
+            for (const topic of options.topics) {
+                if (this.topics.track(topic)) {
+                    joinNeeded = true;
+                }
+            }
+        }
+        // If we need to (re)join the group, do that first and then try again
+        if (joinNeeded) {
+            this.joinGroup(options, error => {
+                if (error) {
+                    callback(error, undefined);
+                    return;
+                }
+                this.#performConsume(options, false, callback);
+            });
+            return;
+        }
+        // Create the stream and start consuming
+        const stream = new MessagesStream(this, options);
+        this.#streams.add(stream);
+        this.#metricActiveStreams?.inc();
+        stream.once('close', () => {
+            this.#metricActiveStreams?.dec();
+            this.#streams.delete(stream);
+        });
+        callback(null, stream);
+    }
+    #performFindGroupCoordinator(callback) {
         this[kPerformDeduplicated]('findGroupCoordinator', deduplicateCallback => {
             this[kPerformWithRetry]('findGroupCoordinator', retryCallback => {
                 this[kConnections].getFirstAvailable(this[kBootstrapBrokers], (error, connection) => {
@@ -447,7 +505,7 @@ export class Consumer extends Base {
             }, 0);
         }, callback);
     }
-    #joinGroup(options, callback) {
+    #performJoinGroup(options, callback) {
         if (!this.#membershipActive) {
             callback(null, undefined);
             return;
@@ -469,7 +527,7 @@ export class Consumer extends Base {
             }
             if (error) {
                 if (this.#getRejoinError(error)) {
-                    this.#joinGroup(options, callback);
+                    this.#performJoinGroup(options, callback);
                     return;
                 }
                 callback(error, undefined);
@@ -483,14 +541,14 @@ export class Consumer extends Base {
                 this.#members.set(member.memberId, this.#decodeProtocolSubscriptionMetadata(member.memberId, member.metadata));
             }
             // Send a syncGroup request
-            this.#syncGroup(null, (error, response) => {
+            this.#syncGroup((error, response) => {
                 if (!this.#membershipActive) {
                     callback(null, undefined);
                     return;
                 }
                 if (error) {
                     if (this.#getRejoinError(error)) {
-                        this.#joinGroup(options, callback);
+                        this.#performJoinGroup(options, callback);
                         return;
                     }
                     callback(error, undefined);
@@ -512,7 +570,7 @@ export class Consumer extends Base {
             });
         });
     }
-    #leaveGroup(force, callback) {
+    #performLeaveGroup(force, callback) {
         if (!this.memberId) {
             callback(null);
             return;
@@ -536,7 +594,7 @@ export class Consumer extends Base {
                     return;
                 }
                 // All streams are closed, try the operation again without force
-                this.#leaveGroup(false, callback);
+                this.#performLeaveGroup(false, callback);
             });
             return;
         }
@@ -563,7 +621,7 @@ export class Consumer extends Base {
             callback(null);
         });
     }
-    #syncGroup(assignments, callback) {
+    #performSyncGroup(assignments, callback) {
         if (!this.#membershipActive) {
             callback(null, []);
             return;
@@ -587,7 +645,7 @@ export class Consumer extends Base {
                         callback(error, undefined);
                         return;
                     }
-                    this.#syncGroup(this.#roundRobinAssignments(metadata), callback);
+                    this.#performSyncGroup(this.#roundRobinAssignments(metadata), callback);
                 });
                 return;
             }
@@ -618,48 +676,6 @@ export class Consumer extends Base {
             callback(error, assignments);
         });
     }
-    #heartbeat(options) {
-        const eventPayload = { groupId: this.groupId, memberId: this.memberId, generationId: this.generationId };
-        this.#performDeduplicateGroupOperaton('heartbeat', (connection, groupCallback) => {
-            // We have left the group in the meanwhile, abort
-            if (!this.#membershipActive) {
-                this.emitWithDebug('consumer:heartbeat', 'cancel', eventPayload);
-                return;
-            }
-            this.emitWithDebug('consumer:heartbeat', 'start', eventPayload);
-            heartbeatV4(connection, this.groupId, this.generationId, this.memberId, null, groupCallback);
-        }, error => {
-            // The heartbeat has been aborted elsewhere, ignore the response
-            if (this.#heartbeatInterval === null || !this.#membershipActive) {
-                this.emitWithDebug('consumer:heartbeat', 'cancel', eventPayload);
-                return;
-            }
-            if (error) {
-                this.#cancelHeartbeat();
-                if (this.#getRejoinError(error)) {
-                    this[kPerformWithRetry]('rejoinGroup', retryCallback => {
-                        this.#joinGroup(options, retryCallback);
-                    }, error => {
-                        if (error) {
-                            this.emitWithDebug(null, 'error', error);
-                        }
-                        this.emitWithDebug('consumer', 'rejoin');
-                    }, 0);
-                    return;
-                }
-                this.emitWithDebug('consumer:heartbeat', 'error', { ...eventPayload, error });
-                // Note that here we purposely do not return, since it was not a group related problem we schedule another heartbeat
-            }
-            else {
-                this.emitWithDebug('consumer:heartbeat', 'end', eventPayload);
-            }
-            this.#heartbeatInterval?.refresh();
-        });
-    }
-    #cancelHeartbeat() {
-        clearTimeout(this.#heartbeatInterval);
-        this.#heartbeatInterval = null;
-    }
     #performDeduplicateGroupOperaton(operationId, operation, callback) {
         return this[kPerformDeduplicated](operationId, deduplicateCallback => {
             this.#performGroupOperation(operationId, operation, deduplicateCallback);

package/dist/clients/consumer/messages-stream.d.ts

@@ -5,6 +5,7 @@ import { type CallbackWithPromise } from '../callbacks.ts';
 import { type Consumer } from './consumer.ts';
 import { type CommitOptionsPartition, type ConsumeOptions } from './types.ts';
 export declare function noopDeserializer(data?: Buffer): Buffer | undefined;
+export declare function defaultCorruptedMessageHandler(): boolean;
 export declare class MessagesStream<Key, Value, HeaderKey, HeaderValue> extends Readable {
     #private;
     constructor(consumer: Consumer<Key, Value, HeaderKey, HeaderValue>, options: ConsumeOptions<Key, Value, HeaderKey, HeaderValue>);