kafka-ts 1.1.6 → 1.1.7

package/dist/api/index.d.ts

@@ -451,125 +451,126 @@ export declare const API: {
 };
 export declare const getApiName: <Request, Response>(api: Api<Request, Response>) => string;
 export declare const API_ERROR: {
-    UNKNOWN_SERVER_ERROR: number;
-    OFFSET_OUT_OF_RANGE: number;
-    CORRUPT_MESSAGE: number;
-    UNKNOWN_TOPIC_OR_PARTITION: number;
-    INVALID_FETCH_SIZE: number;
-    LEADER_NOT_AVAILABLE: number;
-    NOT_LEADER_OR_FOLLOWER: number;
-    REQUEST_TIMED_OUT: number;
-    BROKER_NOT_AVAILABLE: number;
-    REPLICA_NOT_AVAILABLE: number;
-    MESSAGE_TOO_LARGE: number;
-    STALE_CONTROLLER_EPOCH: number;
-    OFFSET_METADATA_TOO_LARGE: number;
-    NETWORK_EXCEPTION: number;
-    COORDINATOR_LOAD_IN_PROGRESS: number;
-    COORDINATOR_NOT_AVAILABLE: number;
-    NOT_COORDINATOR: number;
-    INVALID_TOPIC_EXCEPTION: number;
-    RECORD_LIST_TOO_LARGE: number;
-    NOT_ENOUGH_REPLICAS: number;
-    NOT_ENOUGH_REPLICAS_AFTER_APPEND: number;
-    INVALID_REQUIRED_ACKS: number;
-    ILLEGAL_GENERATION: number;
-    INCONSISTENT_GROUP_PROTOCOL: number;
-    INVALID_GROUP_ID: number;
-    UNKNOWN_MEMBER_ID: number;
-    INVALID_SESSION_TIMEOUT: number;
-    REBALANCE_IN_PROGRESS: number;
-    INVALID_COMMIT_OFFSET_SIZE: number;
-    TOPIC_AUTHORIZATION_FAILED: number;
-    GROUP_AUTHORIZATION_FAILED: number;
-    CLUSTER_AUTHORIZATION_FAILED: number;
-    INVALID_TIMESTAMP: number;
-    UNSUPPORTED_SASL_MECHANISM: number;
-    ILLEGAL_SASL_STATE: number;
-    UNSUPPORTED_VERSION: number;
-    TOPIC_ALREADY_EXISTS: number;
-    INVALID_PARTITIONS: number;
-    INVALID_REPLICATION_FACTOR: number;
-    INVALID_REPLICA_ASSIGNMENT: number;
-    INVALID_CONFIG: number;
-    NOT_CONTROLLER: number;
-    INVALID_REQUEST: number;
-    UNSUPPORTED_FOR_MESSAGE_FORMAT: number;
-    POLICY_VIOLATION: number;
-    OUT_OF_ORDER_SEQUENCE_NUMBER: number;
-    DUPLICATE_SEQUENCE_NUMBER: number;
-    INVALID_PRODUCER_EPOCH: number;
-    INVALID_TXN_STATE: number;
-    INVALID_PRODUCER_ID_MAPPING: number;
-    INVALID_TRANSACTION_TIMEOUT: number;
-    CONCURRENT_TRANSACTIONS: number;
-    TRANSACTION_COORDINATOR_FENCED: number;
-    TRANSACTIONAL_ID_AUTHORIZATION_FAILED: number;
-    SECURITY_DISABLED: number;
-    OPERATION_NOT_ATTEMPTED: number;
-    KAFKA_STORAGE_ERROR: number;
-    LOG_DIR_NOT_FOUND: number;
-    SASL_AUTHENTICATION_FAILED: number;
-    UNKNOWN_PRODUCER_ID: number;
-    REASSIGNMENT_IN_PROGRESS: number;
-    DELEGATION_TOKEN_AUTH_DISABLED: number;
-    DELEGATION_TOKEN_NOT_FOUND: number;
-    DELEGATION_TOKEN_OWNER_MISMATCH: number;
-    DELEGATION_TOKEN_REQUEST_NOT_ALLOWED: number;
-    DELEGATION_TOKEN_AUTHORIZATION_FAILED: number;
-    DELEGATION_TOKEN_EXPIRED: number;
-    INVALID_PRINCIPAL_TYPE: number;
-    NON_EMPTY_GROUP: number;
-    GROUP_ID_NOT_FOUND: number;
-    FETCH_SESSION_ID_NOT_FOUND: number;
-    INVALID_FETCH_SESSION_EPOCH: number;
-    LISTENER_NOT_FOUND: number;
-    TOPIC_DELETION_DISABLED: number;
-    FENCED_LEADER_EPOCH: number;
-    UNKNOWN_LEADER_EPOCH: number;
-    UNSUPPORTED_COMPRESSION_TYPE: number;
-    STALE_BROKER_EPOCH: number;
-    OFFSET_NOT_AVAILABLE: number;
-    MEMBER_ID_REQUIRED: number;
-    PREFERRED_LEADER_NOT_AVAILABLE: number;
-    GROUP_MAX_SIZE_REACHED: number;
-    FENCED_INSTANCE_ID: number;
-    ELIGIBLE_LEADERS_NOT_AVAILABLE: number;
-    ELECTION_NOT_NEEDED: number;
-    NO_REASSIGNMENT_IN_PROGRESS: number;
-    GROUP_SUBSCRIBED_TO_TOPIC: number;
-    INVALID_RECORD: number;
-    UNSTABLE_OFFSET_COMMIT: number;
-    THROTTLING_QUOTA_EXCEEDED: number;
-    PRODUCER_FENCED: number;
-    RESOURCE_NOT_FOUND: number;
-    DUPLICATE_RESOURCE: number;
-    UNACCEPTABLE_CREDENTIAL: number;
-    INCONSISTENT_VOTER_SET: number;
-    INVALID_UPDATE_VERSION: number;
-    FEATURE_UPDATE_FAILED: number;
-    PRINCIPAL_DESERIALIZATION_FAILURE: number;
-    SNAPSHOT_NOT_FOUND: number;
-    POSITION_OUT_OF_RANGE: number;
-    UNKNOWN_TOPIC_ID: number;
-    DUPLICATE_BROKER_REGISTRATION: number;
-    BROKER_ID_NOT_REGISTERED: number;
-    INCONSISTENT_TOPIC_ID: number;
-    INCONSISTENT_CLUSTER_ID: number;
-    TRANSACTIONAL_ID_NOT_FOUND: number;
-    FETCH_SESSION_TOPIC_ID_ERROR: number;
-    INELIGIBLE_REPLICA: number;
-    NEW_LEADER_ELECTED: number;
-    OFFSET_MOVED_TO_TIERED_STORAGE: number;
-    FENCED_MEMBER_EPOCH: number;
-    UNRELEASED_INSTANCE_ID: number;
-    UNSUPPORTED_ASSIGNOR: number;
-    STALE_MEMBER_EPOCH: number;
-    MISMATCHED_ENDPOINT_TYPE: number;
-    UNSUPPORTED_ENDPOINT_TYPE: number;
-    UNKNOWN_CONTROLLER_ID: number;
-    UNKNOWN_SUBSCRIPTION_ID: number;
-    TELEMETRY_TOO_LARGE: number;
-    INVALID_REGISTRATION: number;
-    TRANSACTION_ABORTABLE: number;
+    readonly UNKNOWN_SERVER_ERROR: -1;
+    readonly OFFSET_OUT_OF_RANGE: 1;
+    readonly CORRUPT_MESSAGE: 2;
+    readonly UNKNOWN_TOPIC_OR_PARTITION: 3;
+    readonly INVALID_FETCH_SIZE: 4;
+    readonly LEADER_NOT_AVAILABLE: 5;
+    readonly NOT_LEADER_OR_FOLLOWER: 6;
+    readonly REQUEST_TIMED_OUT: 7;
+    readonly BROKER_NOT_AVAILABLE: 8;
+    readonly REPLICA_NOT_AVAILABLE: 9;
+    readonly MESSAGE_TOO_LARGE: 10;
+    readonly STALE_CONTROLLER_EPOCH: 11;
+    readonly OFFSET_METADATA_TOO_LARGE: 12;
+    readonly NETWORK_EXCEPTION: 13;
+    readonly COORDINATOR_LOAD_IN_PROGRESS: 14;
+    readonly COORDINATOR_NOT_AVAILABLE: 15;
+    readonly NOT_COORDINATOR: 16;
+    readonly INVALID_TOPIC_EXCEPTION: 17;
+    readonly RECORD_LIST_TOO_LARGE: 18;
+    readonly NOT_ENOUGH_REPLICAS: 19;
+    readonly NOT_ENOUGH_REPLICAS_AFTER_APPEND: 20;
+    readonly INVALID_REQUIRED_ACKS: 21;
+    readonly ILLEGAL_GENERATION: 22;
+    readonly INCONSISTENT_GROUP_PROTOCOL: 23;
+    readonly INVALID_GROUP_ID: 24;
+    readonly UNKNOWN_MEMBER_ID: 25;
+    readonly INVALID_SESSION_TIMEOUT: 26;
+    readonly REBALANCE_IN_PROGRESS: 27;
+    readonly INVALID_COMMIT_OFFSET_SIZE: 28;
+    readonly TOPIC_AUTHORIZATION_FAILED: 29;
+    readonly GROUP_AUTHORIZATION_FAILED: 30;
+    readonly CLUSTER_AUTHORIZATION_FAILED: 31;
+    readonly INVALID_TIMESTAMP: 32;
+    readonly UNSUPPORTED_SASL_MECHANISM: 33;
+    readonly ILLEGAL_SASL_STATE: 34;
+    readonly UNSUPPORTED_VERSION: 35;
+    readonly TOPIC_ALREADY_EXISTS: 36;
+    readonly INVALID_PARTITIONS: 37;
+    readonly INVALID_REPLICATION_FACTOR: 38;
+    readonly INVALID_REPLICA_ASSIGNMENT: 39;
+    readonly INVALID_CONFIG: 40;
+    readonly NOT_CONTROLLER: 41;
+    readonly INVALID_REQUEST: 42;
+    readonly UNSUPPORTED_FOR_MESSAGE_FORMAT: 43;
+    readonly POLICY_VIOLATION: 44;
+    readonly OUT_OF_ORDER_SEQUENCE_NUMBER: 45;
+    readonly DUPLICATE_SEQUENCE_NUMBER: 46;
+    readonly INVALID_PRODUCER_EPOCH: 47;
+    readonly INVALID_TXN_STATE: 48;
+    readonly INVALID_PRODUCER_ID_MAPPING: 49;
+    readonly INVALID_TRANSACTION_TIMEOUT: 50;
+    readonly CONCURRENT_TRANSACTIONS: 51;
+    readonly TRANSACTION_COORDINATOR_FENCED: 52;
+    readonly TRANSACTIONAL_ID_AUTHORIZATION_FAILED: 53;
+    readonly SECURITY_DISABLED: 54;
+    readonly OPERATION_NOT_ATTEMPTED: 55;
+    readonly KAFKA_STORAGE_ERROR: 56;
+    readonly LOG_DIR_NOT_FOUND: 57;
+    readonly SASL_AUTHENTICATION_FAILED: 58;
+    readonly UNKNOWN_PRODUCER_ID: 59;
+    readonly REASSIGNMENT_IN_PROGRESS: 60;
+    readonly DELEGATION_TOKEN_AUTH_DISABLED: 61;
+    readonly DELEGATION_TOKEN_NOT_FOUND: 62;
+    readonly DELEGATION_TOKEN_OWNER_MISMATCH: 63;
+    readonly DELEGATION_TOKEN_REQUEST_NOT_ALLOWED: 64;
+    readonly DELEGATION_TOKEN_AUTHORIZATION_FAILED: 65;
+    readonly DELEGATION_TOKEN_EXPIRED: 66;
+    readonly INVALID_PRINCIPAL_TYPE: 67;
+    readonly NON_EMPTY_GROUP: 68;
+    readonly GROUP_ID_NOT_FOUND: 69;
+    readonly FETCH_SESSION_ID_NOT_FOUND: 70;
+    readonly INVALID_FETCH_SESSION_EPOCH: 71;
+    readonly LISTENER_NOT_FOUND: 72;
+    readonly TOPIC_DELETION_DISABLED: 73;
+    readonly FENCED_LEADER_EPOCH: 74;
+    readonly UNKNOWN_LEADER_EPOCH: 75;
+    readonly UNSUPPORTED_COMPRESSION_TYPE: 76;
+    readonly STALE_BROKER_EPOCH: 77;
+    readonly OFFSET_NOT_AVAILABLE: 78;
+    readonly MEMBER_ID_REQUIRED: 79;
+    readonly PREFERRED_LEADER_NOT_AVAILABLE: 80;
+    readonly GROUP_MAX_SIZE_REACHED: 81;
+    readonly FENCED_INSTANCE_ID: 82;
+    readonly ELIGIBLE_LEADERS_NOT_AVAILABLE: 83;
+    readonly ELECTION_NOT_NEEDED: 84;
+    readonly NO_REASSIGNMENT_IN_PROGRESS: 85;
+    readonly GROUP_SUBSCRIBED_TO_TOPIC: 86;
+    readonly INVALID_RECORD: 87;
+    readonly UNSTABLE_OFFSET_COMMIT: 88;
+    readonly THROTTLING_QUOTA_EXCEEDED: 89;
+    readonly PRODUCER_FENCED: 90;
+    readonly RESOURCE_NOT_FOUND: 91;
+    readonly DUPLICATE_RESOURCE: 92;
+    readonly UNACCEPTABLE_CREDENTIAL: 93;
+    readonly INCONSISTENT_VOTER_SET: 94;
+    readonly INVALID_UPDATE_VERSION: 95;
+    readonly FEATURE_UPDATE_FAILED: 96;
+    readonly PRINCIPAL_DESERIALIZATION_FAILURE: 97;
+    readonly SNAPSHOT_NOT_FOUND: 98;
+    readonly POSITION_OUT_OF_RANGE: 99;
+    readonly UNKNOWN_TOPIC_ID: 100;
+    readonly DUPLICATE_BROKER_REGISTRATION: 101;
+    readonly BROKER_ID_NOT_REGISTERED: 102;
+    readonly INCONSISTENT_TOPIC_ID: 103;
+    readonly INCONSISTENT_CLUSTER_ID: 104;
+    readonly TRANSACTIONAL_ID_NOT_FOUND: 105;
+    readonly FETCH_SESSION_TOPIC_ID_ERROR: 106;
+    readonly INELIGIBLE_REPLICA: 107;
+    readonly NEW_LEADER_ELECTED: 108;
+    readonly OFFSET_MOVED_TO_TIERED_STORAGE: 109;
+    readonly FENCED_MEMBER_EPOCH: 110;
+    readonly UNRELEASED_INSTANCE_ID: 111;
+    readonly UNSUPPORTED_ASSIGNOR: 112;
+    readonly STALE_MEMBER_EPOCH: 113;
+    readonly MISMATCHED_ENDPOINT_TYPE: 114;
+    readonly UNSUPPORTED_ENDPOINT_TYPE: 115;
+    readonly UNKNOWN_CONTROLLER_ID: 116;
+    readonly UNKNOWN_SUBSCRIPTION_ID: 117;
+    readonly TELEMETRY_TOO_LARGE: 118;
+    readonly INVALID_REGISTRATION: 119;
+    readonly TRANSACTION_ABORTABLE: 120;
 };
+export declare const handleApiError: (error: unknown) => Promise<void>;

package/dist/api/index.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.API_ERROR = exports.getApiName = exports.API = void 0;
+exports.handleApiError = exports.API_ERROR = exports.getApiName = exports.API = void 0;
+const delay_1 = require("../utils/delay");
+const error_1 = require("../utils/error");
+const logger_1 = require("../utils/logger");
 const api_versions_1 = require("./api-versions");
 const create_topics_1 = require("./create-topics");
 const delete_topics_1 = require("./delete-topics");
@@ -163,3 +166,23 @@ exports.API_ERROR = {
     INVALID_REGISTRATION: 119,
     TRANSACTION_ABORTABLE: 120,
 };
+const handleApiError = async (error) => {
+    if (error instanceof error_1.KafkaTSApiError) {
+        switch (error.errorCode) {
+            case exports.API_ERROR.LEADER_NOT_AVAILABLE:
+                logger_1.log.debug('Leader not available yet. Retrying...');
+                return (0, delay_1.delay)(500);
+            case exports.API_ERROR.COORDINATOR_LOAD_IN_PROGRESS:
+                logger_1.log.debug('Coordinator load in progress. Retrying...');
+                return (0, delay_1.delay)(100);
+            case exports.API_ERROR.COORDINATOR_NOT_AVAILABLE:
+                logger_1.log.debug('Coordinator not available yet. Retrying...');
+                return (0, delay_1.delay)(100);
+            case exports.API_ERROR.OFFSET_NOT_AVAILABLE:
+                logger_1.log.debug('Offset not available yet. Retrying...');
+                return (0, delay_1.delay)(100);
+        }
+    }
+    throw error;
+};
+exports.handleApiError = handleApiError;

package/dist/broker.d.ts

@@ -20,7 +20,6 @@ export declare class Broker {
     sendRequest: SendRequest;
     constructor(options: BrokerOptions);
     connect(): Promise<this>;
-    ensureConnected(): Promise<void>;
     disconnect(): Promise<void>;
     private validateApiVersions;
     private saslHandshake;

package/dist/broker.js

@@ -19,16 +19,13 @@ class Broker {
         this.sendRequest = this.connection.sendRequest.bind(this.connection);
     }
     async connect() {
-        await this.connection.connect();
-        await this.validateApiVersions();
-        await this.saslHandshake();
-        await this.saslAuthenticate();
-        return this;
-    }
-    async ensureConnected() {
         if (!this.connection.isConnected()) {
-            await this.connect();
+            await this.connection.connect();
+            await this.validateApiVersions();
+            await this.saslHandshake();
+            await this.saslAuthenticate();
         }
+        return this;
     }
     async disconnect() {
         await this.connection.disconnect();

package/dist/cluster.d.ts

@@ -16,13 +16,13 @@ export declare class Cluster {
     private brokerMetadata;
     constructor(options: ClusterOptions);
     connect(): Promise<void>;
-    refreshBrokerMetadata(): Promise<void>;
-    ensureConnected(): Promise<void>;
     disconnect(): Promise<void>;
+    ensureConnected: () => Promise<void>;
     setSeedBroker: (nodeId: number) => Promise<void>;
     sendRequest: SendRequest;
     sendRequestToNode: (nodeId: number) => SendRequest;
     acquireBroker(nodeId: number): Promise<Broker>;
     private findSeedBroker;
+    private refreshBrokerMetadata;
 }
 export {};

package/dist/cluster.js

@@ -14,6 +14,7 @@ const api_1 = require("./api");
 const broker_1 = require("./broker");
 const error_1 = require("./utils/error");
 const logger_1 = require("./utils/logger");
+const shared_1 = require("./utils/shared");
 const tracer_1 = require("./utils/tracer");
 const trace = (0, tracer_1.createTracer)('Cluster');
 class Cluster {
@@ -27,24 +28,6 @@ class Cluster {
     async connect() {
         this.seedBroker = await this.findSeedBroker();
         this.brokerById = {};
-        await this.refreshBrokerMetadata();
-    }
-    async refreshBrokerMetadata() {
-        const metadata = await this.sendRequest(api_1.API.METADATA, { topics: [] });
-        this.brokerMetadata = Object.fromEntries(metadata.brokers.map((options) => [options.nodeId, options]));
-    }
-    async ensureConnected() {
-        if (!this.seedBroker) {
-            return this.connect();
-        }
-        try {
-            await Promise.all([this.seedBroker, ...Object.values(this.brokerById)].map((x) => x.ensureConnected()));
-        }
-        catch {
-            logger_1.log.warn('Failed to connect to known brokers, reconnecting...');
-            await this.disconnect();
-            return this.connect();
-        }
     }
     async disconnect() {
         await Promise.all([
@@ -52,11 +35,45 @@ class Cluster {
             ...Object.values(this.brokerById).map((x) => x.disconnect()),
         ]);
     }
+    ensureConnected = (0, shared_1.shared)(async () => {
+        if (!this.seedBroker) {
+            return this.connect();
+        }
+        const brokers = [
+            {
+                broker: this.seedBroker,
+                handleError: async (error) => {
+                    logger_1.log.debug(`Failed to connect to seed broker. Reconnecting...`, { reason: error.message });
+                    await this.seedBroker?.disconnect();
+                    this.seedBroker = await this.findSeedBroker();
+                },
+            },
+            ...Object.entries(this.brokerById).map(([nodeId, broker]) => ({
+                broker,
+                handleError: async (error) => {
+                    logger_1.log.debug(`Failed to connect to broker ${nodeId}. Disconnecting...`, { reason: error.message });
+                    await broker.disconnect();
+                    delete this.brokerById[parseInt(nodeId)];
+                },
+            })),
+        ];
+        await Promise.all(brokers.map(async ({ broker, handleError }) => {
+            try {
+                await broker.connect();
+            }
+            catch (error) {
+                await handleError(error);
+            }
+        }));
+    });
     setSeedBroker = async (nodeId) => {
+        const broker = await this.acquireBroker(nodeId);
         await this.seedBroker?.disconnect();
-        this.seedBroker = await this.acquireBroker(nodeId);
+        this.seedBroker = broker;
+    };
+    sendRequest = async (...args) => {
+        return this.seedBroker.sendRequest(...args);
     };
-    sendRequest = (...args) => this.seedBroker.sendRequest(...args);
     sendRequestToNode = (nodeId) => async (...args) => {
         if (!this.brokerById[nodeId]) {
             this.brokerById[nodeId] = await this.acquireBroker(nodeId);
@@ -64,9 +81,10 @@ class Cluster {
         return this.brokerById[nodeId].sendRequest(...args);
     };
     async acquireBroker(nodeId) {
-        if (!(nodeId in this.brokerMetadata)) {
-            throw new error_1.BrokerNotAvailableError(nodeId);
-        }
+        if (!(nodeId in this.brokerMetadata))
+            await this.refreshBrokerMetadata();
+        if (!(nodeId in this.brokerMetadata))
+            throw new error_1.ConnectionError(`Broker ${nodeId} is not available`);
         const broker = new broker_1.Broker({
             clientId: this.options.clientId,
             sasl: this.options.sasl,
@@ -92,11 +110,17 @@ class Cluster {
                 return broker;
             }
             catch (error) {
-                logger_1.log.warn(`Failed to connect to seed broker ${options.host}:${options.port}`, error);
+                logger_1.log.debug(`Failed to connect to seed broker ${options.host}:${options.port}`, {
+                    reason: error.message,
+                });
             }
         }
         throw new error_1.KafkaTSError('No seed brokers found');
     }
+    async refreshBrokerMetadata() {
+        const metadata = await this.sendRequest(api_1.API.METADATA, { topics: [] });
+        this.brokerMetadata = Object.fromEntries(metadata.brokers.map((options) => [options.nodeId, options]));
+    }
 }
 exports.Cluster = Cluster;
 __decorate([

package/dist/connection.js

@@ -71,6 +71,7 @@ class Connection {
     async connect() {
         this.queue = {};
         this.chunks = [];
+        const { stack } = new Error();
         await new Promise((resolve, reject) => {
             const { ssl, connection } = this.options;
             this.socket = ssl
@@ -81,14 +82,16 @@ class Connection {
                 }, resolve)
                 : net_1.default.connect(connection, resolve);
             this.socket.setKeepAlive(true, 30_000);
-            this.socket.once('error', reject);
+            this.socket.once('error', (error) => {
+                reject(new error_1.ConnectionError(error.message, stack));
+            });
         });
         this.socket.removeAllListeners('error');
         this.socket.on('error', (error) => logger_1.log.debug('Socket error', { error }));
         this.socket.on('data', (data) => this.handleData(data));
         this.socket.once('close', async () => {
             Object.values(this.queue).forEach(({ reject }) => {
-                reject(new error_1.ConnectionError('Socket closed unexpectedly'));
+                reject(new error_1.ConnectionError('Socket closed unexpectedly', stack));
             });
             this.queue = {};
         });
@@ -112,18 +115,19 @@ class Connection {
             .writeString(this.options.clientId);
         const request = api.request(encoder, body);
         const requestEncoder = new encoder_1.Encoder().writeInt32(request.getBufferLength()).writeEncoder(request);
+        const { stack } = new Error();
         let timeout;
         const { responseDecoder, responseSize } = await new Promise(async (resolve, reject) => {
             timeout = setTimeout(() => {
                 delete this.queue[correlationId];
-                reject(new error_1.ConnectionError(`${apiName} timed out`));
+                reject(new error_1.ConnectionError(`${apiName} timed out`, stack));
             }, this.options.requestTimeout);
             try {
                 this.queue[correlationId] = { resolve, reject };
                 await this.write(requestEncoder.value());
             }
             catch (error) {
-                reject(error);
+                reject(new error_1.ConnectionError(error.message, stack));
             }
         });
         clearTimeout(timeout);
@@ -142,15 +146,7 @@ class Connection {
     }
     write(buffer) {
         return new Promise((resolve, reject) => {
-            const { stack } = new Error('Write error');
-            this.socket.write(buffer, 'binary', (error) => {
-                if (error) {
-                    const err = new error_1.ConnectionError(error.message);
-                    err.stack += `\n${stack}`;
-                    return reject(err);
-                }
-                resolve();
-            });
+            this.socket.write(buffer, 'binary', (error) => (error ? reject(error) : resolve()));
         });
     }
     handleData(buffer) {

package/dist/consumer/consumer-group.d.ts

@@ -28,12 +28,13 @@ export declare class ConsumerGroup {
     private startHeartbeater;
     private stopHeartbeater;
     handleLastHeartbeat(): void;
-    private findCoordinator;
+    findCoordinator(): Promise<void>;
     private joinGroup;
     private syncGroup;
     private offsetFetch;
     offsetCommit(topicPartitions: Record<string, Set<number>>): Promise<void>;
     heartbeat(): Promise<void>;
     leaveGroup(): Promise<void>;
+    private handleError;
 }
 export {};

package/dist/consumer/consumer-group.js

@@ -12,6 +12,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConsumerGroup = void 0;
 const api_1 = require("../api");
 const find_coordinator_1 = require("../api/find-coordinator");
+const error_1 = require("../utils/error");
+const logger_1 = require("../utils/logger");
 const tracer_1 = require("../utils/tracer");
 const trace = (0, tracer_1.createTracer)('ConsumerGroup');
 class ConsumerGroup {
@@ -28,7 +30,6 @@ class ConsumerGroup {
     }
     async init() {
         await this.findCoordinator();
-        await this.options.cluster.setSeedBroker(this.coordinatorId);
         this.memberId = '';
     }
     async join() {
@@ -61,11 +62,19 @@ class ConsumerGroup {
         }
     }
     async findCoordinator() {
-        const { coordinators } = await this.options.cluster.sendRequest(api_1.API.FIND_COORDINATOR, {
-            keyType: find_coordinator_1.KEY_TYPE.GROUP,
-            keys: [this.options.groupId],
-        });
-        this.coordinatorId = coordinators[0].nodeId;
+        try {
+            const { coordinators } = await this.options.cluster.sendRequest(api_1.API.FIND_COORDINATOR, {
+                keyType: find_coordinator_1.KEY_TYPE.GROUP,
+                keys: [this.options.groupId],
+            });
+            this.coordinatorId = coordinators[0].nodeId;
+            await this.options.cluster.setSeedBroker(this.coordinatorId);
+            this.heartbeatError = null;
+        }
+        catch (error) {
+            await this.handleError(error);
+            return this.findCoordinator();
+        }
     }
     async joinGroup() {
         const { cluster, groupId, groupInstanceId, sessionTimeoutMs, rebalanceTimeoutMs, topics } = this.options;
@@ -86,11 +95,8 @@ class ConsumerGroup {
             this.memberIds = response.members.map((member) => member.memberId);
         }
         catch (error) {
-            if (error.errorCode === api_1.API_ERROR.MEMBER_ID_REQUIRED) {
-                this.memberId = error.response.memberId;
-                return this.joinGroup();
-            }
-            throw error;
+            await this.handleError(error);
+            return this.joinGroup();
         }
     }
     async syncGroup() {
@@ -108,16 +114,22 @@ class ConsumerGroup {
             }, {});
             assignments = Object.entries(memberAssignments).map(([memberId, assignment]) => ({ memberId, assignment }));
         }
-        const response = await cluster.sendRequest(api_1.API.SYNC_GROUP, {
-            groupId,
-            groupInstanceId,
-            memberId: this.memberId,
-            generationId: this.generationId,
-            protocolType: 'consumer',
-            protocolName: 'RoundRobinAssigner',
-            assignments,
-        });
-        metadata.setAssignment(response.assignments);
+        try {
+            const response = await cluster.sendRequest(api_1.API.SYNC_GROUP, {
+                groupId,
+                groupInstanceId,
+                memberId: this.memberId,
+                generationId: this.generationId,
+                protocolType: 'consumer',
+                protocolName: 'RoundRobinAssigner',
+                assignments,
+            });
+            metadata.setAssignment(response.assignments);
+        }
+        catch (error) {
+            await this.handleError(error);
+            return this.syncGroup();
+        }
     }
     async offsetFetch() {
         const { cluster, groupId, topics, metadata, offsetManager } = this.options;
@@ -135,20 +147,26 @@ class ConsumerGroup {
         };
         if (!request.groups.length)
             return;
-        const response = await cluster.sendRequest(api_1.API.OFFSET_FETCH, request);
-        const topicPartitions = {};
-        response.groups.forEach((group) => {
-            group.topics.forEach((topic) => {
-                topicPartitions[topic.name] ??= new Set();
-                topic.partitions.forEach(({ partitionIndex, committedOffset }) => {
-                    if (committedOffset >= 0) {
-                        topicPartitions[topic.name].add(partitionIndex);
-                        offsetManager.resolve(topic.name, partitionIndex, committedOffset);
-                    }
+        try {
+            const response = await cluster.sendRequest(api_1.API.OFFSET_FETCH, request);
+            const topicPartitions = {};
+            response.groups.forEach((group) => {
+                group.topics.forEach((topic) => {
+                    topicPartitions[topic.name] ??= new Set();
+                    topic.partitions.forEach(({ partitionIndex, committedOffset }) => {
+                        if (committedOffset >= 0) {
+                            topicPartitions[topic.name].add(partitionIndex);
+                            offsetManager.resolve(topic.name, partitionIndex, committedOffset);
+                        }
+                    });
                 });
             });
-        });
-        offsetManager.flush(topicPartitions);
+            offsetManager.flush(topicPartitions);
+        }
+        catch (error) {
+            await this.handleError(error);
+            return this.offsetFetch();
+        }
     }
     async offsetCommit(topicPartitions) {
         const { cluster, groupId, groupInstanceId, offsetManager, consumer } = this.options;
@@ -174,7 +192,13 @@ class ConsumerGroup {
         if (!request.topics.length) {
             return;
         }
-        await cluster.sendRequest(api_1.API.OFFSET_COMMIT, request);
+        try {
+            await cluster.sendRequest(api_1.API.OFFSET_COMMIT, request);
+        }
+        catch (error) {
+            await this.handleError(error);
+            return this.offsetCommit(topicPartitions);
+        }
         consumer.emit('offsetCommit');
     }
     async heartbeat() {
@@ -200,12 +224,27 @@ class ConsumerGroup {
             });
         }
         catch (error) {
-            if (error.errorCode === api_1.API_ERROR.FENCED_INSTANCE_ID) {
+            if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.FENCED_INSTANCE_ID) {
                 return;
             }
-            throw error;
+            await this.handleError(error);
+            return this.leaveGroup();
         }
     }
+    async handleError(error) {
+        await (0, api_1.handleApiError)(error).catch(async (error) => {
+            if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.NOT_COORDINATOR) {
+                logger_1.log.debug('Not coordinator. Searching for new coordinator...');
+                await this.findCoordinator();
+                return;
+            }
+            if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.MEMBER_ID_REQUIRED) {
+                this.memberId = error.response.memberId;
+                return;
+            }
+            throw error;
+        });
+    }
 }
 exports.ConsumerGroup = ConsumerGroup;
 __decorate([

package/dist/consumer/consumer.d.ts

@@ -41,4 +41,7 @@ export declare class Consumer extends EventEmitter<{
     private waitForReassignment;
     private process;
     private fetch;
+    private fetchMetadata;
+    private fetchOffsets;
+    private handleError;
 }

package/dist/consumer/consumer.js

@@ -75,13 +75,12 @@ class Consumer extends events_1.default {
             : undefined;
     }
     async start() {
-        const { topics, allowTopicAutoCreation, fromTimestamp } = this.options;
         this.stopHook = undefined;
         try {
             await this.cluster.connect();
-            await this.metadata.fetchMetadata({ topics, allowTopicAutoCreation });
+            await this.fetchMetadata();
             this.metadata.setAssignment(this.metadata.getTopicPartitions());
-            await this.offsetManager.fetchOffsets({ fromTimestamp });
+            await this.fetchOffsets();
             await this.consumerGroup?.init();
         }
         catch (error) {
@@ -101,8 +100,8 @@ class Consumer extends events_1.default {
                 await this.fetchManager?.stop();
             });
         }
-        await this.consumerGroup?.leaveGroup().catch((error) => logger_1.log.debug(`Failed to leave group: ${error.message}`));
-        await this.cluster.disconnect().catch((error) => logger_1.log.debug(`Failed to disconnect: ${error.message}`));
+        await this.consumerGroup?.leaveGroup().catch((error) => logger_1.log.debug('Failed to leave group', { reason: error.message }));
+        await this.cluster.disconnect().catch(() => { });
     }
     async startFetchManager() {
         const { groupId } = this.options;
@@ -129,18 +128,22 @@ class Consumer extends events_1.default {
             }
             catch (error) {
                 await this.fetchManager?.stop();
-                if (error.errorCode === api_1.API_ERROR.REBALANCE_IN_PROGRESS) {
+                if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.REBALANCE_IN_PROGRESS) {
                     logger_1.log.debug('Rebalance in progress...', { apiName: error.apiName, groupId });
                     continue;
                 }
-                if (error.errorCode === api_1.API_ERROR.FENCED_INSTANCE_ID) {
+                if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.FENCED_INSTANCE_ID) {
                     logger_1.log.debug('New consumer with the same groupInstanceId joined. Exiting the consumer...');
                     this.close();
                     break;
                 }
-                if (error instanceof error_1.ConnectionError ||
-                    (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.NOT_COORDINATOR)) {
-                    logger_1.log.debug(`${error.message}. Restarting consumer...`);
+                if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.NOT_COORDINATOR) {
+                    logger_1.log.debug('Not coordinator. Searching for new coordinator...');
+                    await this.consumerGroup?.findCoordinator();
+                    return;
+                }
+                if (error instanceof error_1.ConnectionError) {
+                    logger_1.log.debug(`${error.message}. Restarting consumer...`, { stack: error.stack });
                     this.close().then(() => this.start());
                     break;
                 }
@@ -233,13 +236,44 @@ class Consumer extends events_1.default {
             });
         }
         catch (error) {
+            await this.handleError(error);
+            return this.fetch(nodeId, assignment);
+        }
+    }
+    async fetchMetadata() {
+        const { topics, allowTopicAutoCreation } = this.options;
+        try {
+            await this.metadata.fetchMetadata({ topics, allowTopicAutoCreation });
+        }
+        catch (error) {
+            await this.handleError(error);
+            return this.fetchMetadata();
+        }
+    }
+    async fetchOffsets() {
+        const { fromTimestamp } = this.options;
+        try {
+            await this.offsetManager.fetchOffsets({ fromTimestamp });
+        }
+        catch (error) {
+            await this.handleError(error);
+            return this.fetchOffsets();
+        }
+    }
+    async handleError(error) {
+        await (0, api_1.handleApiError)(error).catch(async (error) => {
+            if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.NOT_LEADER_OR_FOLLOWER) {
+                logger_1.log.debug('Refreshing metadata', { reason: error.message });
+                await this.fetchMetadata();
+                return;
+            }
             if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.OFFSET_OUT_OF_RANGE) {
                 logger_1.log.warn('Offset out of range. Resetting offsets.');
-                await this.offsetManager.fetchOffsets({ fromTimestamp: this.options.fromTimestamp });
-                return this.fetch(nodeId, assignment);
+                await this.fetchOffsets();
+                return;
             }
             throw error;
-        }
+        });
     }
 }
 exports.Consumer = Consumer;

package/dist/producer/producer.d.ts

@@ -19,8 +19,10 @@ export declare class Producer {
         acks?: -1 | 1;
     }): Promise<void>;
     close(): Promise<void>;
-    private ensureConnected;
+    private ensureProducerInitialized;
     private initProducerId;
     private getSequence;
     private updateSequence;
+    private fetchMetadata;
+    private handleError;
 }

package/dist/producer/producer.js

@@ -14,7 +14,6 @@ const api_1 = require("../api");
 const messages_to_topic_partition_leaders_1 = require("../distributors/messages-to-topic-partition-leaders");
 const partitioner_1 = require("../distributors/partitioner");
 const metadata_1 = require("../metadata");
-const delay_1 = require("../utils/delay");
 const error_1 = require("../utils/error");
 const lock_1 = require("../utils/lock");
 const logger_1 = require("../utils/logger");
@@ -41,7 +40,7 @@ class Producer {
         this.partition = this.options.partitioner({ metadata: this.metadata });
     }
     async send(messages, { acks = -1 } = {}) {
-        await this.ensureConnected();
+        await this.ensureProducerInitialized();
         const { allowTopicAutoCreation } = this.options;
         const defaultTimestamp = BigInt(Date.now());
         const topics = new Set(messages.map((message) => message.topic));
@@ -51,96 +50,74 @@ class Producer {
             return message;
         });
         const nodeTopicPartitionMessages = (0, messages_to_topic_partition_leaders_1.distributeMessagesToTopicPartitionLeaders)(partitionedMessages, this.metadata.getTopicPartitionLeaderIds());
-        try {
-            await Promise.all(Object.entries(nodeTopicPartitionMessages).map(async ([nodeId, topicPartitionMessages]) => {
-                try {
-                    await this.lock.acquire([`node:${nodeId}`], async () => {
-                        const topicData = Object.entries(topicPartitionMessages).map(([topic, partitionMessages]) => ({
-                            name: topic,
-                            partitionData: Object.entries(partitionMessages).map(([partition, messages]) => {
-                                const partitionIndex = parseInt(partition);
-                                let baseTimestamp;
-                                let maxTimestamp;
-                                messages.forEach(({ timestamp = defaultTimestamp }) => {
-                                    if (!baseTimestamp || timestamp < baseTimestamp) {
-                                        baseTimestamp = timestamp;
-                                    }
-                                    if (!maxTimestamp || timestamp > maxTimestamp) {
-                                        maxTimestamp = timestamp;
-                                    }
-                                });
-                                return {
-                                    index: partitionIndex,
-                                    baseOffset: 0n,
-                                    partitionLeaderEpoch: -1,
+        await Promise.all(Object.entries(nodeTopicPartitionMessages).map(async ([nodeId, topicPartitionMessages]) => {
+            try {
+                await this.lock.acquire([`node:${nodeId}`], async () => {
+                    const topicData = Object.entries(topicPartitionMessages).map(([topic, partitionMessages]) => ({
+                        name: topic,
+                        partitionData: Object.entries(partitionMessages).map(([partition, messages]) => {
+                            const partitionIndex = parseInt(partition);
+                            let baseTimestamp;
+                            let maxTimestamp;
+                            messages.forEach(({ timestamp = defaultTimestamp }) => {
+                                if (!baseTimestamp || timestamp < baseTimestamp) {
+                                    baseTimestamp = timestamp;
+                                }
+                                if (!maxTimestamp || timestamp > maxTimestamp) {
+                                    maxTimestamp = timestamp;
+                                }
+                            });
+                            return {
+                                index: partitionIndex,
+                                baseOffset: 0n,
+                                partitionLeaderEpoch: -1,
+                                attributes: 0,
+                                lastOffsetDelta: messages.length - 1,
+                                baseTimestamp: baseTimestamp ?? 0n,
+                                maxTimestamp: maxTimestamp ?? 0n,
+                                producerId: this.producerId,
+                                producerEpoch: 0,
+                                baseSequence: this.getSequence(topic, partitionIndex),
+                                records: messages.map((message, index) => ({
                                     attributes: 0,
-                                    lastOffsetDelta: messages.length - 1,
-                                    baseTimestamp: baseTimestamp ?? 0n,
-                                    maxTimestamp: maxTimestamp ?? 0n,
-                                    producerId: this.producerId,
-                                    producerEpoch: 0,
-                                    baseSequence: this.getSequence(topic, partitionIndex),
-                                    records: messages.map((message, index) => ({
-                                        attributes: 0,
-                                        timestampDelta: (message.timestamp ?? defaultTimestamp) - (baseTimestamp ?? 0n),
-                                        offsetDelta: index,
-                                        key: message.key ?? null,
-                                        value: message.value,
-                                        headers: Object.entries(message.headers ?? {}).map(([key, value]) => ({
-                                            key,
-                                            value,
-                                        })),
+                                    timestampDelta: (message.timestamp ?? defaultTimestamp) - (baseTimestamp ?? 0n),
+                                    offsetDelta: index,
+                                    key: message.key ?? null,
+                                    value: message.value,
+                                    headers: Object.entries(message.headers ?? {}).map(([key, value]) => ({
+                                        key,
+                                        value,
                                     })),
-                                };
-                            }),
-                        }));
-                        await this.cluster.sendRequestToNode(parseInt(nodeId))(api_1.API.PRODUCE, {
-                            transactionalId: null,
-                            acks,
-                            timeoutMs: 30000,
-                            topicData,
-                        });
-                        topicData.forEach(({ name, partitionData }) => {
-                            partitionData.forEach(({ index, records }) => {
-                                this.updateSequence(name, index, records.length);
-                            });
+                                })),
+                            };
+                        }),
+                    }));
+                    await this.cluster.sendRequestToNode(parseInt(nodeId))(api_1.API.PRODUCE, {
+                        transactionalId: null,
+                        acks,
+                        timeoutMs: 30000,
+                        topicData,
+                    });
+                    topicData.forEach(({ name, partitionData }) => {
+                        partitionData.forEach(({ index, records }) => {
+                            this.updateSequence(name, index, records.length);
                         });
                     });
-                }
-                catch (error) {
-                    if (error instanceof error_1.BrokerNotAvailableError || (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.NOT_LEADER_OR_FOLLOWER)) {
-                        logger_1.log.debug('Refreshing broker metadata', { reason: error.message, nodeId });
-                        await this.cluster.refreshBrokerMetadata();
-                        await this.metadata.fetchMetadata({ topics, allowTopicAutoCreation });
-                        const messages = Object.values(topicPartitionMessages).flatMap(partitionMessages => Object.values(partitionMessages).flat()).map(({ partition, ...message }) => message);
-                        return this.send(messages, { acks });
-                    }
-                    throw error;
-                }
-            }));
-        }
-        catch (error) {
-            if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.NOT_LEADER_OR_FOLLOWER) {
-                await this.metadata.fetchMetadata({ topics, allowTopicAutoCreation });
-            }
-            if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.OUT_OF_ORDER_SEQUENCE_NUMBER) {
-                await this.initProducerId();
-            }
-            logger_1.log.warn('Reconnecting producer due to an unhandled error', { error });
-            try {
-                await this.cluster.disconnect();
-                await this.cluster.connect();
+                });
             }
             catch (error) {
-                logger_1.log.warn('Failed to reconnect producer', { error });
+                await this.handleError(error);
+                const messages = Object.values(topicPartitionMessages)
+                    .flatMap((partitionMessages) => Object.values(partitionMessages).flat())
+                    .map(({ partition, ...message }) => message);
+                return this.send(messages, { acks });
             }
-            throw error;
-        }
+        }));
     }
     async close() {
         await this.cluster.disconnect();
     }
-    ensureConnected = (0, shared_1.shared)(async () => {
+    ensureProducerInitialized = (0, shared_1.shared)(async () => {
         await this.cluster.ensureConnected();
         if (!this.producerId) {
             await this.initProducerId();
@@ -159,11 +136,8 @@ class Producer {
             this.sequences = {};
         }
         catch (error) {
-            if (error.errorCode === api_1.API_ERROR.COORDINATOR_LOAD_IN_PROGRESS) {
-                await (0, delay_1.delay)(100);
-                return this.initProducerId();
-            }
-            throw error;
+            await this.handleError(error);
+            return this.initProducerId();
         }
     }
     getSequence(topic, partition) {
@@ -174,6 +148,31 @@ class Producer {
         this.sequences[topic][partition] ??= 0;
         this.sequences[topic][partition] += messagesCount;
     }
+    async fetchMetadata(topics, allowTopicAutoCreation) {
+        try {
+            await this.metadata.fetchMetadata({ topics, allowTopicAutoCreation });
+        }
+        catch (error) {
+            await this.handleError(error);
+            return this.fetchMetadata(topics, allowTopicAutoCreation);
+        }
+    }
+    async handleError(error) {
+        await (0, api_1.handleApiError)(error).catch(async (error) => {
+            if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.NOT_LEADER_OR_FOLLOWER) {
+                logger_1.log.debug('Refreshing metadata', { reason: error.message });
+                const topics = Object.keys(this.metadata.getTopicPartitions());
+                await this.fetchMetadata(topics, false);
+                return;
+            }
+            if (error instanceof error_1.KafkaTSApiError && error.errorCode === api_1.API_ERROR.OUT_OF_ORDER_SEQUENCE_NUMBER) {
+                logger_1.log.debug('Out of order sequence number. Reinitializing producer ID');
+                await this.initProducerId();
+                return;
+            }
+            throw error;
+        });
+    }
 }
 exports.Producer = Producer;
 __decorate([

package/dist/utils/error.d.ts

@@ -9,9 +9,6 @@ export declare class KafkaTSApiError<T = any> extends KafkaTSError {
     request: unknown | undefined;
     constructor(errorCode: number, errorMessage: string | null, response: T);
 }
-export declare class BrokerNotAvailableError extends KafkaTSError {
-    brokerId: number;
-    constructor(brokerId: number);
-}
 export declare class ConnectionError extends KafkaTSError {
+    constructor(message: string, stack?: string);
 }

package/dist/utils/error.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectionError = exports.BrokerNotAvailableError = exports.KafkaTSApiError = exports.KafkaTSError = void 0;
+exports.ConnectionError = exports.KafkaTSApiError = exports.KafkaTSError = void 0;
 const api_1 = require("../api");
 class KafkaTSError extends Error {
     constructor(message) {
@@ -24,14 +24,10 @@ class KafkaTSApiError extends KafkaTSError {
     }
 }
 exports.KafkaTSApiError = KafkaTSApiError;
-class BrokerNotAvailableError extends KafkaTSError {
-    brokerId;
-    constructor(brokerId) {
-        super(`Broker ${brokerId} is not available`);
-        this.brokerId = brokerId;
-    }
-}
-exports.BrokerNotAvailableError = BrokerNotAvailableError;
 class ConnectionError extends KafkaTSError {
+    constructor(message, stack) {
+        super(message);
+        this.stack += `\n${stack}`;
+    }
 }
 exports.ConnectionError = ConnectionError;

package/dist/utils/logger.d.ts

@@ -4,6 +4,13 @@ export interface Logger {
     warn: (message: string, metadata?: unknown) => void;
     error: (message: string, metadata?: unknown) => void;
 }
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARNING = 2,
+    ERROR = 3
+}
 export declare const jsonSerializer: (_: unknown, v: unknown) => unknown;
 export declare let log: Logger;
 export declare const setLogger: (newLogger: Logger) => void;
+export declare const setLogLevel: (newLogLevel: LogLevel) => void;

package/dist/utils/logger.js

@@ -1,6 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setLogger = exports.log = exports.jsonSerializer = void 0;
+exports.setLogLevel = exports.setLogger = exports.log = exports.jsonSerializer = exports.LogLevel = void 0;
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARNING"] = 2] = "WARNING";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
 const jsonSerializer = (_, v) => {
     if (v instanceof Error) {
         return Object.getOwnPropertyNames(v).reduce((acc, key) => {
@@ -19,16 +26,19 @@ const jsonSerializer = (_, v) => {
 exports.jsonSerializer = jsonSerializer;
 class JsonLogger {
     debug(message, metadata) {
-        console.debug(JSON.stringify({ message, metadata, level: 'debug' }, exports.jsonSerializer));
+        logLevel <= LogLevel.DEBUG &&
+            console.debug(JSON.stringify({ message, metadata, level: 'debug' }, exports.jsonSerializer));
     }
     info(message, metadata) {
-        console.info(JSON.stringify({ message, metadata, level: 'info' }, exports.jsonSerializer));
+        logLevel <= LogLevel.INFO && console.info(JSON.stringify({ message, metadata, level: 'info' }, exports.jsonSerializer));
     }
     warn(message, metadata) {
-        console.warn(JSON.stringify({ message, metadata, level: 'warning' }, exports.jsonSerializer));
+        logLevel <= LogLevel.WARNING &&
+            console.warn(JSON.stringify({ message, metadata, level: 'warning' }, exports.jsonSerializer));
     }
     error(message, metadata) {
-        console.error(JSON.stringify({ message, metadata, level: 'error' }, exports.jsonSerializer));
+        logLevel <= LogLevel.ERROR &&
+            console.error(JSON.stringify({ message, metadata, level: 'error' }, exports.jsonSerializer));
     }
 }
 exports.log = new JsonLogger();
@@ -36,3 +46,8 @@ const setLogger = (newLogger) => {
     exports.log = newLogger;
 };
 exports.setLogger = setLogger;
+let logLevel = LogLevel.INFO;
+const setLogLevel = (newLogLevel) => {
+    logLevel = newLogLevel;
+};
+exports.setLogLevel = setLogLevel;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "kafka-ts",
-    "version": "1.1.6",
+    "version": "1.1.7",
     "main": "dist/index.js",
     "author": "Priit Käärd",
     "license": "MIT",