@codefresh-io/eventbus 3.0.0-alpha.0 → 3.0.0-alpha.2

package/lib/Bus.js

@@ -42,7 +42,7 @@ class Bus extends EventEmitter {
         this._forbidNewConsumers = false;
         this._reSubscribe = this._reSubscribe.bind(this);
         this._reconnect = this._reconnect.bind(this);
-        /** @type {Map<amqplib.Channel, string[]>} */
+        /** @type {Map<amqplib.Channel, { queueName: string, consumerTag: string }[]>} */
         this.consumerTagsByChannel = new Map();
     }
 
@@ -71,16 +71,16 @@ class Bus extends EventEmitter {
         for (const ch of this.consumerTagsByChannel.keys()) {
             const consumerTags = this.consumerTagsByChannel.get(ch) ?? [];
             const results = await Promise.allSettled(
-                consumerTags.map((consumerTag) => ch.cancel(consumerTag))
+                consumerTags.map((tagInfo) => ch.cancel(tagInfo.consumerTag))
             );
             for (let i = 0; i < results.length; i++) {
                 const result = results[i];
-                const consumerTag = consumerTags[i];
+                const tagInfo = consumerTags[i];
                 if (result.status === 'rejected') {
-                    this._logger.error(`Failed to cancel consumer with tag "${consumerTag}". Ignoring error`, { error: result.reason });
+                    this._logger.error(`Failed to cancel consumer with tag "${tagInfo.consumerTag}" on queue "${tagInfo.queueName}". Ignoring error`, { error: result.reason });
                     continue;
                 }
-                this._logger.debug(`Consumer with tag "${consumerTag}" was cancelled successfully`);
+                this._logger.debug(`Consumer with tag "${tagInfo.consumerTag}" on queue "${tagInfo.queueName}" was cancelled successfully`);
             }
         }
         this.consumerTagsByChannel.clear();
@@ -108,12 +108,12 @@ class Bus extends EventEmitter {
     async quit(options = {}) {
         this._terminating = true;
         if (options.force) {
-            this._logger.warn('Forcefully terminating eventbus connection. All consumers in progress will be interrupted and may not finish processing messages');
+            this._logger.warn('Forcefully terminating bus connection. All consumers in progress will be interrupted and may not finish processing messages');
             await this._closeConnection();
             this._terminated = true;
             return;
         }
-        this._logger.info('Gracefully terminating eventbus connection');
+        this._logger.info('Gracefully terminating bus connection');
         await this.cancelAllConsumers();
         await this.waitForConsumersToFinish();
         await this._closeConnection();
@@ -121,10 +121,10 @@ class Bus extends EventEmitter {
     }
 
     async _closeConnection() {
-        this._logger.info('Closing eventbus connection');
+        this._logger.info('Closing bus connection');
         await this.connection?.close();
         this.subscribers = {};
-        this._logger.info('Eventbus connection closed');
+        this._logger.info('Bus connection is closed');
     }
 
     /**
@@ -134,19 +134,19 @@ class Bus extends EventEmitter {
         this.initializing = true;
         this._createErrorHandler();
 
-        this._logger.debug('Eventbus connecting...');
+        this._logger.debug('Bus connecting...');
         this.openPromise = amqplib.connect(this.url);
         this.openPromise
             .then((newConnection) => {
-                this._logger.debug('Eventbus connected');
+                this._logger.debug('Bus connected');
                 if (this.reconnect && this.connection) {
                     this.publishChannel = undefined;
-                    this._logger.debug('Eventbus reconnected');
+                    this._logger.debug('Bus reconnected');
                 }
                 this.reconnect  = false;
                 this.connection = newConnection;
 
-                this._logger.debug('Eventbus ready');
+                this._logger.debug('Bus is ready');
                 this.emit('ready');
 
                 this.connection.on('error', (err) => {
@@ -154,17 +154,17 @@ class Bus extends EventEmitter {
                 });
 
                 this.connection.on('close', () => {
-                    this._logger.debug('Eventbus connection closed');
+                    this._logger.debug('Bus connection closed');
                     this.emit('close');
                     this._reconnect();
                 });
 
                 this.connection.on('blocked', () => {
-                    this._logger.debug('Eventbus connection blocked');
+                    this._logger.debug('Bus connection blocked');
                 });
 
                 this.connection.on('unblocked', () => {
-                    this._logger.debug('Eventbus connection unblocked');
+                    this._logger.debug('Bus connection unblocked');
                 });
 
                 return this._reSubscribe();
@@ -179,14 +179,13 @@ class Bus extends EventEmitter {
 
     _reconnect() {
         if (this.initializing || this._terminating || this._terminated) {
-            this._logger.debug('Skipping eventbus reconnect because eventbus is initializing or terminating');
+            this._logger.debug('Skipping bus reconnect because it is initializing or terminating');
             return;
         }
 
-        this._logger.debug(`Eventbus reconnecting in ${this.reconnectIntervalMs / 1000} seconds`);
+        this._logger.debug(`Bus reconnecting in ${this.reconnectIntervalMs / 1000} seconds...`);
         this.reconnect = true;
         setTimeout(() => {
-            this._logger.debug('Eventbus reconnecting...');
             this.init();
         }, this.reconnectIntervalMs);
     }
@@ -236,12 +235,12 @@ class Bus extends EventEmitter {
      * @returns {EventEmitter} An EventEmitter that emits 'error' event when an error occurs in the handler or during subscription process.
      */
     subscribe(eventName, handler, options = {}, restarting) {
-        this._logger.debug(`Subscribing to event "${eventName}", options:`, options);
+        this._logger.debug(`Subscribing to event "${eventName}", options:`, { options });
         const subscriberEmitter = new EventEmitter();
         subscriberEmitter.on('error', () => {});
 
         if (this._forbidNewConsumers || this._terminating || this._terminated) {
-            this._logger.warn(`Skipping new consumer subscription to "${eventName}" because eventbus is terminating or terminated or new consumers are forbidden`);
+            this._logger.warn(`Skipping new consumer subscription to "${eventName}" because bus is terminating or terminated or new consumers are forbidden`);
             return subscriberEmitter;
         }
 
@@ -316,8 +315,8 @@ class Bus extends EventEmitter {
                             ch.ack(msg);
                         }
                         const content = this._deserialize(msg.content.toString());
-                        this._consumersInProgressCount++;
-                        await handler(content).finally(() => this._consumersInProgressCount--);
+                        this._consumersInProgressCount += 1;
+                        await handler(content).finally(() => this._consumersInProgressCount -= 1);
                     } catch (error) {
                         subscriberEmitter.emit('error', error);
                         if (!finished && waitForAck) {
@@ -329,7 +328,7 @@ class Bus extends EventEmitter {
                     }
                 });
                 const consumerTags = this.consumerTagsByChannel.get(ch) ?? [];
-                consumerTags.push(consumerTag);
+                consumerTags.push({ queueName, consumerTag });
                 this.consumerTagsByChannel.set(ch, consumerTags);
             })
             .catch((err) => {
@@ -352,7 +351,7 @@ class Bus extends EventEmitter {
      */
     async _getSubscribeChannel() {
         const model = await this.openPromise;
-        return model?.createChannel();
+        return await model?.createChannel();
     }
 
     /**

package/lib/Store.js

@@ -51,9 +51,9 @@ class Store extends EventEmitter {
         this._logger.info(`Closing store for microservice "${this.microServiceName}"`);
         if (this.disablePostgresForEventbus || !this.pool) return;
 
-        this._logger.debug(`Pool client state before closing: total: ${this.pool.totalCount}, idle: ${this.pool.idleCount}, active: ${this.pool.activeCount}`);
+        this._logger.debug(`Pool client state before closing: total: ${this.pool.totalCount}, idle: ${this.pool.idleCount}, waiting: ${this.pool.waitingCount}`);
         await this.pool.end();
-        this._logger.debug(`Pool client state after closing: total: ${this.pool.totalCount}, idle: ${this.pool.idleCount}, active: ${this.pool.activeCount}`);
+        this._logger.debug(`Pool client state after closing: total: ${this.pool.totalCount}, idle: ${this.pool.idleCount}, waiting: ${this.pool.waitingCount}`);
         this._logger.info(`Store closed for microservice "${this.microServiceName}"`);
     }
 

package/lib/index.js

@@ -83,13 +83,13 @@ class EventBus extends EventEmitter {
 
         // wait for both the bus and the store to send their ready event
         this.bus.on('ready', () => {
-            this._logger.info(`Eventbus bus is ready. registered as: ${this.microServiceName}`);
+            this._logger.info(`Eventbus bus is ready. Registered as: ${this.microServiceName}`);
             this.busReady = true;
             this._emitReady();
         });
 
         this.store.on('ready', () => {
-            this._logger.info(`Eventbus store is ready. registered as: ${this.microServiceName}`);
+            this._logger.info(`Eventbus store is ready. Registered as: ${this.microServiceName}`);
             this.storeReady = true;
             this._emitReady();
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codefresh-io/eventbus",
-  "version": "3.0.0-alpha.0",
+  "version": "3.0.0-alpha.2",
   "description": "",
   "main": "index.js",
   "files": [