@restorecommerce/kafka-client 1.2.13 → 1.2.15

package/lib/events/provider/kafka/index.js

@@ -1,30 +1,33 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Name = exports.Kafka = exports.Topic = void 0;
-const retry = require("retry");
-const _ = require("lodash");
+const retry = __importStar(require("retry"));
+const _ = __importStar(require("lodash"));
 const events_1 = require("events");
-const async = require("async");
+const async = __importStar(require("async"));
 const kafkajs_1 = require("kafkajs");
 const protos_1 = require("../../../protos");
 const makeProtoResolver = (protoFilePath, protoRoot) => {
@@ -41,6 +44,20 @@ const makeProtoResolver = (protoFilePath, protoRoot) => {
  * A Kafka topic.
  */
 class Topic {
+    name;
+    emitter;
+    provider;
+    subscribed;
+    waitQueue;
+    currentOffset;
+    consumer;
+    config;
+    // message sync throttling attributes
+    asyncQueue;
+    drainEvent;
+    // default process one message at at time
+    asyncLimit = 1;
+    manualOffsetCommit;
     /**
      * Kafka topic.
      * When the listener count for all events are zero, the consumer unsubscribes
@@ -53,8 +70,6 @@ class Topic {
      * @param config
      */
     constructor(name, provider, config, manualOffsetCommit = false) {
-        // default process one message at at time
-        this.asyncLimit = 1;
         this.name = name;
         this.emitter = new events_1.EventEmitter();
         this.provider = provider;
@@ -64,33 +79,31 @@ class Topic {
         this.config = config;
         this.manualOffsetCommit = manualOffsetCommit;
     }
-    createIfNotExists() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                this.provider.admin.listTopics().then((topics) => {
-                    if (topics.indexOf(this.name) < 0) {
-                        const operation = retry.operation();
-                        operation.attempt(() => __awaiter(this, void 0, void 0, function* () {
-                            this.provider.admin.createTopics({
-                                topics: [{
-                                        topic: this.name
-                                    }],
-                            }).then(() => {
-                                this.provider.logger.info(`Topic ${this.name} created successfully`);
-                                resolve();
-                            }).catch(err => {
-                                this.provider.logger.error(`Cannot create topic ${this.name}:`, { code: err.code, message: err.message, stack: err.stack });
-                                operation.retry(err);
-                                const attemptNo = operation.attempts();
-                                this.provider.logger.info(`Retry creating the Topic, attempt no: ${attemptNo}`);
-                            });
-                        }));
-                    }
-                    else {
-                        this.provider.logger.warn(`Topic ${this.name} already exists`);
-                        resolve();
-                    }
-                });
+    async createIfNotExists() {
+        return new Promise((resolve, reject) => {
+            this.provider.admin.listTopics().then((topics) => {
+                if (topics.indexOf(this.name) < 0) {
+                    const operation = retry.operation();
+                    operation.attempt(async () => {
+                        this.provider.admin.createTopics({
+                            topics: [{
+                                    topic: this.name
+                                }],
+                        }).then(() => {
+                            this.provider.logger.info(`Topic ${this.name} created successfully`);
+                            resolve();
+                        }).catch(err => {
+                            this.provider.logger.error(`Cannot create topic ${this.name}:`, { code: err.code, message: err.message, stack: err.stack });
+                            operation.retry(err);
+                            const attemptNo = operation.attempts();
+                            this.provider.logger.info(`Retry creating the Topic, attempt no: ${attemptNo}`);
+                        });
+                    });
+                }
+                else {
+                    this.provider.logger.warn(`Topic ${this.name} already exists`);
+                    resolve();
+                }
             });
         });
     }
@@ -128,14 +141,12 @@ class Topic {
      * @param  {string} eventName Name of the event
      * @param  {function|generator} listener  Event listener
      */
-    removeListener(eventName, listener) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.provider.logger.verbose(`Removing listener from event ${eventName}`);
-            this.emitter.removeListener(eventName, listener);
-            if (this.listenerCount(eventName) === 0) {
-                yield this.$unsubscribe(eventName);
-            }
-        });
+    async removeListener(eventName, listener) {
+        this.provider.logger.verbose(`Removing listener from event ${eventName}`);
+        this.emitter.removeListener(eventName, listener);
+        if (this.listenerCount(eventName) === 0) {
+            await this.$unsubscribe(eventName);
+        }
     }
     /**
      * Remove all listeners from given event.
@@ -143,14 +154,12 @@ class Topic {
      *
      * @param  {string} eventName Name of the event
      */
-    removeAllListeners(eventName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.provider.logger.verbose(`Removing all listeners from event ${eventName}`);
-            this.emitter.removeAllListeners(eventName);
-            if (this.listenerCount(eventName) === 0) {
-                yield this.$unsubscribe(eventName);
-            }
-        });
+    async removeAllListeners(eventName) {
+        this.provider.logger.verbose(`Removing all listeners from event ${eventName}`);
+        this.emitter.removeAllListeners(eventName);
+        if (this.listenerCount(eventName) === 0) {
+            await this.$unsubscribe(eventName);
+        }
     }
     /**
      * Return the offset number of this topic.
@@ -158,23 +167,21 @@ class Topic {
      * @param {number} time Use -1 for latest and 0 for earliest.
      * @return {number} offset number
      */
-    $offset() {
-        return __awaiter(this, arguments, void 0, function* (time = -1) {
-            return new Promise((resolve, reject) => {
-                if (time < 0) {
-                    return this.provider.admin.fetchTopicOffsets(this.name).then(data => {
-                        resolve(parseInt(data[0].offset, 10));
-                    }).catch(err => {
-                        this.provider.logger.error('Error occurred retrieving topic offset:', { code: err.code, message: err.message, stack: err.stack });
-                        reject(err);
-                    });
-                }
-                return this.provider.admin.fetchTopicOffsetsByTimestamp(this.name, time).then(data => {
+    async $offset(time = -1) {
+        return new Promise((resolve, reject) => {
+            if (time < 0) {
+                return this.provider.admin.fetchTopicOffsets(this.name).then(data => {
                     resolve(parseInt(data[0].offset, 10));
                 }).catch(err => {
                     this.provider.logger.error('Error occurred retrieving topic offset:', { code: err.code, message: err.message, stack: err.stack });
                     reject(err);
                 });
+            }
+            return this.provider.admin.fetchTopicOffsetsByTimestamp(this.name, time).then(data => {
+                resolve(parseInt(data[0].offset, 10));
+            }).catch(err => {
+                this.provider.logger.error('Error occurred retrieving topic offset:', { code: err.code, message: err.message, stack: err.stack });
+                reject(err);
             });
         });
     }
@@ -184,18 +191,16 @@ class Topic {
      * @return {Promise} Thunk will be resolved when a message is received
      * with the corresponding offset.
      */
-    $wait(offset) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((() => {
-                return (cb) => {
-                    if (this.currentOffset >= offset) {
-                        cb(null);
-                        return;
-                    }
-                    this.waitQueue.push({ offset, cb });
-                };
-            })());
-        });
+    async $wait(offset) {
+        return new Promise((() => {
+            return (cb) => {
+                if (this.currentOffset >= offset) {
+                    cb(null);
+                    return;
+                }
+                this.waitQueue.push({ offset, cb });
+            };
+        })());
     }
     /**
      * Reset consumer, unsubscribes all the events on the topic and then
@@ -204,28 +209,26 @@ class Topic {
      * @param {string[]} eventNames list of event names
      * @param {number} offset The offset at which to restart from.
      */
-    $resetConsumer(eventNames, offset) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.provider.logger.info('Event Names for consumer reset', eventNames);
-            if (eventNames && eventNames.length > 0) {
-                // since the consumer is set to undefined only when there is no more subscription
-                // need to unsubcribe all eventNames and then resubcribe at once
-                const eventNamesList = _.clone(eventNames);
-                // unsubscribe all events on consumer
-                for (let eventName of eventNamesList) {
-                    yield this.$unsubscribe(eventName);
-                    this.provider.logger.info(`Unsubscribed event ${eventName}`);
-                }
-                // subscribe all events on consumer
-                for (let eventName of eventNamesList) {
-                    yield this.$subscribe(eventName, offset);
-                    this.provider.logger.info(`Subscribed event ${eventName}`);
-                }
+    async $resetConsumer(eventNames, offset) {
+        this.provider.logger.info('Event Names for consumer reset', eventNames);
+        if (eventNames && eventNames.length > 0) {
+            // since the consumer is set to undefined only when there is no more subscription
+            // need to unsubcribe all eventNames and then resubcribe at once
+            const eventNamesList = _.clone(eventNames);
+            // unsubscribe all events on consumer
+            for (const eventName of eventNamesList) {
+                await this.$unsubscribe(eventName);
+                this.provider.logger.info(`Unsubscribed event ${eventName}`);
             }
-            else {
-                this.provider.logger.warn('Event names empty for consumer reset');
+            // subscribe all events on consumer
+            for (const eventName of eventNamesList) {
+                await this.$subscribe(eventName, offset);
+                this.provider.logger.info(`Subscribed event ${eventName}`);
             }
-        });
+        }
+        else {
+            this.provider.logger.warn('Event names empty for consumer reset');
+        }
     }
     /**
      * Force a committed offset reset.
@@ -233,34 +236,30 @@ class Topic {
      * @param {string} eventName
      * @param {number} offset The offset at which to restart from.
      */
-    $reset(eventName, offset) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.subscribed.indexOf(eventName) > -1) {
-                yield this.$unsubscribe(eventName);
-            }
-            yield this.$subscribe(eventName, offset);
-        });
+    async $reset(eventName, offset) {
+        if (this.subscribed.indexOf(eventName) > -1) {
+            await this.$unsubscribe(eventName);
+        }
+        await this.$subscribe(eventName, offset);
     }
     /**
      * Unsubscribe from Kafka topic. Does not remove any listeners.
      */
-    $unsubscribe(eventName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!_.includes(this.subscribed, eventName)) {
-                return;
-            }
-            const index = this.subscribed.indexOf(eventName);
-            this.subscribed.splice(index, 1);
-            if (this.subscribed.length == 0) {
-                this.provider.logger.info(`Closing consumer from topic ${this.name}`);
-                yield this.consumer.stop().then(() => this.consumer.disconnect()).then(() => {
-                    this.provider.logger.info(`Consumer disconnected from topic ${this.name}`);
-                    this.consumer = undefined;
-                }).catch((err) => {
-                    this.provider.logger.error(`Error occurred unsubscribing ${eventName} on topic ${this.name}`, { code: err.code, message: err.message, stack: err.stack });
-                });
-            }
-        });
+    async $unsubscribe(eventName) {
+        if (!_.includes(this.subscribed, eventName)) {
+            return;
+        }
+        const index = this.subscribed.indexOf(eventName);
+        this.subscribed.splice(index, 1);
+        if (this.subscribed.length == 0) {
+            this.provider.logger.info(`Closing consumer from topic ${this.name}`);
+            await this.consumer.stop().then(() => this.consumer.disconnect()).then(() => {
+                this.provider.logger.info(`Consumer disconnected from topic ${this.name}`);
+                this.consumer = undefined;
+            }).catch((err) => {
+                this.provider.logger.error(`Error occurred unsubscribing ${eventName} on topic ${this.name}`, { code: err.code, message: err.message, stack: err.stack });
+            });
+        }
     }
     /**
      * Filters subscribed messages among all received Kafka messages and then
@@ -305,49 +304,47 @@ class Topic {
      * @param offsetValue
      * @param queue
      **/
-    $subscribe(eventName, offsetValue, queue) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.consumer) {
-                this.consumer = this.provider.client.consumer({
-                    groupId: this.provider.config.groupId + '_' + this.name
-                });
-                yield this.consumer.connect().then(() => {
-                    this.provider.logger.info(`Consumer for topic '${this.name}' connected`);
-                }).catch(err => {
-                    this.provider.logger.error(`Consumer for topic '${this.name}' connection error`, { code: err.code, message: err.message, stack: err.stack });
-                });
-                yield this.consumer.subscribe({
-                    topic: this.name
-                }).then(() => {
-                    this.provider.logger.info(`Consumer for topic '${this.name}' subscribed`);
-                }).catch(err => {
-                    this.provider.logger.error(`Consumer for topic '${this.name}' subscriber error`, { code: err.code, message: err.message, stack: err.stack });
-                });
-                // On receiving the message on Kafka consumer put the message to async Queue.
-                if (queue) {
-                    // start drain process
-                    this.drain();
-                }
-                yield this.consumer.run({
-                    eachMessage: (payload) => __awaiter(this, void 0, void 0, function* () {
-                        if (queue) {
-                            this.onMessageForQueue(payload);
-                        }
-                        else {
-                            this.makeDataHandler(payload);
-                        }
-                    })
-                }).catch(err => {
-                    this.provider.logger.error(`Consumer for topic '${this.name}' failed to run`, { code: err.code, message: err.message, stack: err.stack });
-                });
-                this.consumer.seek({
-                    topic: this.name,
-                    partition: 0,
-                    offset: offsetValue.toString(10)
-                });
+    async $subscribe(eventName, offsetValue, queue) {
+        if (!this.consumer) {
+            this.consumer = this.provider.client.consumer({
+                groupId: this.provider.config.groupId + '_' + this.name
+            });
+            await this.consumer.connect().then(() => {
+                this.provider.logger.info(`Consumer for topic '${this.name}' connected`);
+            }).catch(err => {
+                this.provider.logger.error(`Consumer for topic '${this.name}' connection error`, { code: err.code, message: err.message, stack: err.stack });
+            });
+            await this.consumer.subscribe({
+                topic: this.name
+            }).then(() => {
+                this.provider.logger.info(`Consumer for topic '${this.name}' subscribed`);
+            }).catch(err => {
+                this.provider.logger.error(`Consumer for topic '${this.name}' subscriber error`, { code: err.code, message: err.message, stack: err.stack });
+            });
+            // On receiving the message on Kafka consumer put the message to async Queue.
+            if (queue) {
+                // start drain process
+                this.drain();
             }
-            this.subscribed.push(eventName);
-        });
+            await this.consumer.run({
+                eachMessage: async (payload) => {
+                    if (queue) {
+                        this.onMessageForQueue(payload);
+                    }
+                    else {
+                        this.makeDataHandler(payload);
+                    }
+                }
+            }).catch(err => {
+                this.provider.logger.error(`Consumer for topic '${this.name}' failed to run`, { code: err.code, message: err.message, stack: err.stack });
+            });
+            this.consumer.seek({
+                topic: this.name,
+                partition: 0,
+                offset: offsetValue.toString(10)
+            });
+        }
+        this.subscribed.push(eventName);
     }
     onMessageForQueue(context) {
         if (_.includes(this.subscribed, context.message.key.toString())) {
@@ -407,37 +404,33 @@ class Topic {
             });
         }
     }
-    commitCurrentOffsets() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                this.consumer.commitOffsets([
-                    {
-                        topic: this.name,
-                        offset: this.currentOffset.toString(10),
-                        partition: 0 // ?
-                    }
-                ]).then(resolve).catch(err => {
-                    this.provider.logger.error('Error committing offset', { code: err.code, message: err.message, stack: err.stack });
-                    reject(err);
-                });
+    async commitCurrentOffsets() {
+        return new Promise((resolve, reject) => {
+            this.consumer.commitOffsets([
+                {
+                    topic: this.name,
+                    offset: this.currentOffset.toString(10),
+                    partition: 0 // ?
+                }
+            ]).then(resolve).catch(err => {
+                this.provider.logger.error('Error committing offset', { code: err.code, message: err.message, stack: err.stack });
+                reject(err);
             });
         });
     }
     /**
      * Manually commit the current offset.
      */
-    commitOffset() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // Commit the current offset
-                yield this.commitCurrentOffsets();
-                this.provider.logger.verbose('Offset committed manually');
-            }
-            catch (error) {
-                this.provider.logger.error('Failed to commit offset manually', { code: error.code, message: error.message, stack: error.stack });
-                throw error;
-            }
-        });
+    async commitOffset() {
+        try {
+            // Commit the current offset
+            await this.commitCurrentOffsets();
+            this.provider.logger.verbose('Offset committed manually');
+        }
+        catch (error) {
+            this.provider.logger.error('Failed to commit offset manually', { code: error.code, message: error.message, stack: error.stack });
+            throw error;
+        }
     }
     /**
      * Internal function for receiving event messages from Kafka and
@@ -469,19 +462,18 @@ class Topic {
      * @param  {function|generator} listener  Listener
      * @param opts
      */
-    on(eventName_1, listener_1) {
-        return __awaiter(this, arguments, void 0, function* (eventName, listener, opts = {}) {
-            let { startingOffset, queue, forceOffset } = opts;
-            if (!(this.subscribed.indexOf(eventName) > -1)) {
-                if (_.isNil(startingOffset) || (this.config.latestOffset && !forceOffset)) {
-                    // override the startingOffset with the latestOffset from Kafka
-                    // if above config is set
-                    startingOffset = yield this.$offset(-1);
-                }
-                yield this.$subscribe(eventName, startingOffset, queue);
+    async on(eventName, listener, opts = {}) {
+        let { startingOffset } = opts;
+        const { queue, forceOffset } = opts;
+        if (!(this.subscribed.indexOf(eventName) > -1)) {
+            if (_.isNil(startingOffset) || (this.config.latestOffset && !forceOffset)) {
+                // override the startingOffset with the latestOffset from Kafka
+                // if above config is set
+                startingOffset = await this.$offset(-1);
             }
-            this.emitter.on(eventName, listener);
-        });
+            await this.$subscribe(eventName, startingOffset, queue);
+        }
+        this.emitter.on(eventName, listener);
     }
     /**
      * Send event messages.
@@ -489,14 +481,12 @@ class Topic {
      * @param  {string} eventName Event name
      * @param  {Object} message   Message
      */
-    emit(eventName, message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.provider.$send(this.name, eventName, message);
-        });
+    async emit(eventName, message) {
+        await this.provider.$send(this.name, eventName, message);
     }
 }
 exports.Topic = Topic;
-const toWinstonLogLevel = level => {
+const toWinstonLogLevel = (level) => {
     switch (level) {
         case kafkajs_1.logLevel.ERROR:
         case kafkajs_1.logLevel.NOTHING:
@@ -513,6 +503,14 @@ const toWinstonLogLevel = level => {
  * Events provider.
  */
 class Kafka {
+    config;
+    topics;
+    logger;
+    client;
+    producer;
+    admin;
+    producerConnected;
+    adminConnected;
     /**
      * Kafka is a provider for Events.
      *
@@ -530,67 +528,67 @@ class Kafka {
      * Start connects to kafka with a producer.
      * Suspends the calling function until the producer is connected.
      */
-    start() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const operation = retry.operation({
-                forever: true,
-                maxTimeout: (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.timeout) !== null && _b !== void 0 ? _b : 60000,
-            });
-            return new Promise((resolveRetry) => {
-                operation.attempt(() => __awaiter(this, void 0, void 0, function* () {
-                    var _a;
-                    try {
-                        this.client = new kafkajs_1.Kafka(Object.assign(Object.assign({ retry: {
-                                initialRetryTime: 1000,
-                                maxRetryTime: 10000,
-                                retries: 100,
-                            } }, this.config.kafka), { logCreator: () => {
-                                return ({ level, log }) => {
-                                    const { message } = log, extra = __rest(log, ["message"]);
-                                    this.logger.log(toWinstonLogLevel(level), '[kafka-client] ' + message, extra);
-                                };
-                            } }));
-                        this.producer = this.client.producer();
-                        this.admin = this.client.admin();
-                        // waiting for producer to be ready
-                        yield new Promise((resolveProducer, rejectProducer) => {
-                            this.producer.on('producer.connect', () => {
-                                this.producerConnected = true;
-                                this.logger.info('The Producer is ready.');
-                                resolveProducer(true);
-                            });
-                            this.producer.on('producer.disconnect', (err) => {
-                                this.producerConnected = false;
-                                this.logger.warn('The Producer has disconnected:', err);
-                                rejectProducer(err);
-                            });
-                            this.producer.on('producer.network.request_timeout', (err) => {
-                                this.logger.warn('The Producer timed out:', err);
-                                rejectProducer(err);
-                            });
-                            this.producer.connect().catch(err => {
-                                this.logger.warn('Producer connection error:', err);
-                            });
-                        }).then(() => __awaiter(this, void 0, void 0, function* () {
-                            this.admin.on('admin.connect', () => {
-                                this.adminConnected = true;
-                                resolveRetry();
-                            });
-                            this.admin.on('admin.disconnect', () => this.adminConnected = false);
-                            yield this.admin.connect().catch(err => {
-                                this.logger.warn('Admin connection error:', err);
-                                throw err;
-                            });
-                        }));
-                    }
-                    catch (err) {
-                        operation.retry(err);
-                        const attemptNo = operation.attempts();
-                        (_a = this.producer) === null || _a === void 0 ? void 0 : _a.disconnect();
-                        this.logger.info(`Retry initialize the Producer, attempt no: ${attemptNo}`);
-                    }
-                }));
+    async start() {
+        const operation = retry.operation({
+            forever: true,
+            maxTimeout: this.config?.timeout ?? 60000,
+        });
+        return new Promise((resolveRetry) => {
+            operation.attempt(async () => {
+                try {
+                    this.client = new kafkajs_1.Kafka({
+                        retry: {
+                            initialRetryTime: 1000,
+                            maxRetryTime: 10000,
+                            retries: 100,
+                        },
+                        ...this.config.kafka,
+                        logCreator: () => {
+                            return ({ level, log }) => {
+                                const { message, ...extra } = log;
+                                this.logger.log(toWinstonLogLevel(level), '[kafka-client] ' + message, extra);
+                            };
+                        },
+                    });
+                    this.producer = this.client.producer();
+                    this.admin = this.client.admin();
+                    // waiting for producer to be ready
+                    await new Promise((resolveProducer, rejectProducer) => {
+                        this.producer.on('producer.connect', () => {
+                            this.producerConnected = true;
+                            this.logger.info('The Producer is ready.');
+                            resolveProducer(true);
+                        });
+                        this.producer.on('producer.disconnect', (err) => {
+                            this.producerConnected = false;
+                            this.logger.warn('The Producer has disconnected:', err);
+                            rejectProducer(err);
+                        });
+                        this.producer.on('producer.network.request_timeout', (err) => {
+                            this.logger.warn('The Producer timed out:', err);
+                            rejectProducer(err);
+                        });
+                        this.producer.connect().catch(err => {
+                            this.logger.warn('Producer connection error:', err);
+                        });
+                    }).then(async () => {
+                        this.admin.on('admin.connect', () => {
+                            this.adminConnected = true;
+                            resolveRetry();
+                        });
+                        this.admin.on('admin.disconnect', () => this.adminConnected = false);
+                        await this.admin.connect().catch(err => {
+                            this.logger.warn('Admin connection error:', err);
+                            throw err;
+                        });
+                    });
+                }
+                catch (err) {
+                    operation.retry(err);
+                    const attemptNo = operation.attempts();
+                    this.producer?.disconnect();
+                    this.logger.info(`Retry initialize the Producer, attempt no: ${attemptNo}`);
+                }
             });
         });
     }
@@ -626,53 +624,52 @@ class Kafka {
      * @param  {string} eventName
      * @param  {Object|Object[]} message
      */
-    $send(topicName, eventName, message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let messages = message;
-            const messageObject = this.config[eventName].messageObject;
-            if (!_.isArray(message)) {
-                messages = [message];
+    async $send(topicName, eventName, message) {
+        let messages = message;
+        const config = this.config;
+        const messageObject = config[eventName].messageObject;
+        if (!_.isArray(message)) {
+            messages = [message];
+        }
+        try {
+            const values = [];
+            for (let i = 0; i < messages.length; i += 1) {
+                //  get the binary representation of the message using serializeBinary()
+                //  and build a Buffer from it.
+                const msg = messages[i];
+                const bufferObj = Kafka.encodeObject(msg, messageObject);
+                values.push({
+                    key: eventName,
+                    value: Buffer.from(bufferObj),
+                    partition: 0
+                });
             }
-            try {
-                const values = [];
-                for (let i = 0; i < messages.length; i += 1) {
-                    //  get the binary representation of the message using serializeBinary()
-                    //  and build a Buffer from it.
-                    const msg = messages[i];
-                    const bufferObj = Kafka.encodeObject(msg, messageObject);
-                    values.push({
-                        key: eventName,
-                        value: Buffer.from(bufferObj),
-                        partition: 0
-                    });
+            for (const msg of messages) {
+                if (config && config[eventName].omittedFields) {
+                    const keys = config[eventName].omittedFields;
+                    this.omitFields(keys, msg, config[eventName].enableLogging);
                 }
-                for (let msg of messages) {
-                    if (this.config && this.config[eventName].omittedFields) {
-                        const keys = this.config[eventName].omittedFields;
-                        this.omitFields(keys, msg, this.config[eventName].enableLogging);
+            }
+            this.logger.debug(`Sending event ${eventName} to topic ${topicName}`, { messages });
+            return new Promise((resolve, reject) => {
+                this.producer.send({
+                    topic: topicName,
+                    messages: values
+                }).then((data) => {
+                    for (const msg of messages) {
+                        this.logger.debug(`Sent event ${eventName} to topic ${topicName}`, msg);
                     }
-                }
-                this.logger.debug(`Sending event ${eventName} to topic ${topicName}`, { messages });
-                return new Promise((resolve, reject) => {
-                    this.producer.send({
-                        topic: topicName,
-                        messages: values
-                    }).then((data) => {
-                        for (let msg of messages) {
-                            this.logger.debug(`Sent event ${eventName} to topic ${topicName}`, msg);
-                        }
-                        resolve(data);
-                    }).catch((err) => {
-                        this.logger.error(`error sending event ${eventName} to topic ${topicName}`, { code: err.code, message: err.message, stack: err.stack });
-                        reject(err);
-                    });
+                    resolve(data);
+                }).catch((err) => {
+                    this.logger.error(`error sending event ${eventName} to topic ${topicName}`, { code: err.code, message: err.message, stack: err.stack });
+                    reject(err);
                 });
-            }
-            catch (err) {
-                this.logger.error(`error on sending event ${eventName} to topic ${topicName}`, { code: err.code, message: err.message, stack: err.stack });
-                throw err;
-            }
-        });
+            });
+        }
+        catch (err) {
+            this.logger.error(`error on sending event ${eventName} to topic ${topicName}`, { code: err.code, message: err.message, stack: err.stack });
+            throw err;
+        }
     }
     omitFields(keys, msg, enableLogging) {
         let msgs;
@@ -682,14 +679,14 @@ class Kafka {
         else {
             msgs = msg;
         }
-        for (let key of keys) {
-            for (let msg of msgs) {
+        for (const key of keys) {
+            for (const msg of msgs) {
                 if (typeof key === 'string') {
                     if (enableLogging && msg[key] && msg[key].value) {
                         msg[key] = msg[key].value.toString();
                     }
                     else if (enableLogging && msg[key] && _.isArray(msg[key])) {
-                        for (let eachMsg of msg[key]) {
+                        for (const eachMsg of msg[key]) {
                             msg[key] = eachMsg.value.toString();
                         }
                     }
@@ -711,53 +708,49 @@ class Kafka {
      * @param config
      * @return {Topic} Kafka topic
      */
-    topic(topicName, config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.topics[topicName]) {
-                return this.topics[topicName];
-            }
-            this.topics[topicName] = new Topic(topicName, this, config);
-            yield this.topics[topicName].createIfNotExists();
+    async topic(topicName, config) {
+        if (this.topics[topicName]) {
             return this.topics[topicName];
-        });
+        }
+        this.topics[topicName] = new Topic(topicName, this, config);
+        await this.topics[topicName].createIfNotExists();
+        return this.topics[topicName];
     }
     /**
      * stops the connection to kafka.
      * The calling function is suspended until the producer and
      * all consumers from topics are disconnected.
      */
-    stop() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.warn('Stopping Kafka. Ignore any following connection errors');
-            const errors = [];
-            if (this.producerConnected) {
-                yield this.producer.disconnect().catch(err => {
-                    this.logger.warn('Error occurred stopping Kafka producer:', err);
-                    errors.push(err);
-                });
-            }
-            if (this.adminConnected) {
-                yield this.admin.disconnect().catch(err => {
-                    this.logger.warn('Error occurred stopping Kafka admin:', err);
-                    errors.push(err);
-                });
-            }
-            const topicNames = _.keys(this.topics);
-            for (let i = 0; i < topicNames.length; i += 1) {
-                const topic = this.topics[topicNames[i]];
-                const eventNames = topic.subscribed;
-                for (let j = eventNames.length - 1; j >= 0; j -= 1) {
-                    const eventName = eventNames[j];
-                    // This closes both producer and consumer objects
-                    // via unsubscribe()
-                    yield topic.removeAllListeners(eventName);
-                }
-            }
-            if (errors.length > 0) {
-                this.logger.error('Errors when stopping Kafka client:', errors);
-                throw errors;
+    async stop() {
+        this.logger.warn('Stopping Kafka. Ignore any following connection errors');
+        const errors = [];
+        if (this.producerConnected) {
+            await this.producer.disconnect().catch(err => {
+                this.logger.warn('Error occurred stopping Kafka producer:', err);
+                errors.push(err);
+            });
+        }
+        if (this.adminConnected) {
+            await this.admin.disconnect().catch(err => {
+                this.logger.warn('Error occurred stopping Kafka admin:', err);
+                errors.push(err);
+            });
+        }
+        const topicNames = _.keys(this.topics);
+        for (let i = 0; i < topicNames.length; i += 1) {
+            const topic = this.topics[topicNames[i]];
+            const eventNames = topic.subscribed;
+            for (let j = eventNames.length - 1; j >= 0; j -= 1) {
+                const eventName = eventNames[j];
+                // This closes both producer and consumer objects
+                // via unsubscribe()
+                await topic.removeAllListeners(eventName);
             }
-        });
+        }
+        if (errors.length > 0) {
+            this.logger.error('Errors when stopping Kafka client:', errors);
+            throw errors;
+        }
     }
 }
 exports.Kafka = Kafka;