@autofleet/rabbit 3.2.2 → 3.2.4-beta.0

package/dist/index.d.ts

@@ -17,6 +17,9 @@ export interface IAfRabbitMq {
     sendToQueue: any;
     redisClient?: any;
 }
+interface NackOptions {
+    skipRetry?: boolean;
+}
 export interface AfRabbitOptions {
     disableReconnect?: boolean;
     /**
@@ -69,8 +72,8 @@ declare class RabbitMq implements IAfRabbitMq {
     private consumers;
     constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig);
     private shouldConsumeMessageByTimestamp;
-    ack: (channel: ChannelWrapper, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp?: boolean, releaseLock?: null) => (userMsg: ConsumeMessage) => Promise<any>;
-    nack: (channel: ChannelWrapper, queue: string, options: any, deadQueueOptions: Options.AssertQueue, msg: ConsumeMessageOrNull, releaseLock: any) => (userMsg: ConsumeMessageOrNull, { skipRetry, }?: any) => Promise<any>;
+    ack: (channel: ConfirmChannel, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp?: boolean, releaseLock?: null) => (userMsg: ConsumeMessage) => Promise<any>;
+    nack: (channel: ConfirmChannel, queue: string, options: any, deadQueueOptions: Options.AssertQueue, msg: ConsumeMessageOrNull, releaseLock: any) => (userMsg: ConsumeMessageOrNull, { skipRetry, }?: NackOptions) => Promise<any>;
     getConnection(): Promise<AmqpConnectionManager>;
     getNewChannel({ name, onClose }?: newChannelOpts): Promise<ChannelWrapper>;
     assertChannel({ force }?: assertChannelOpts): Promise<ChannelWrapper>;
@@ -80,7 +83,6 @@ declare class RabbitMq implements IAfRabbitMq {
     bindQueue(queue: string, exchange: string): Promise<void>;
     assertQueue(queueName: string, options?: Options.AssertQueue): Promise<any>;
     private saveConsumer;
-    private loadConsumers;
     consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any>;
     private lockRedisIfNeeded;
     private unlockRedisIfNeeded;

package/dist/index.js

@@ -75,7 +75,6 @@ class RabbitMq {
             }
             else {
                 logger_1.default.error('no channel or msg', {
-                    channel: channel ? channel.name : '',
                     msg,
                 });
             }
@@ -160,6 +159,9 @@ class RabbitMq {
             }
             this.creatingConnection = true;
             let isResolved = false;
+            // It is import to use it as a function and not as a variable
+            // because of k8s changes the env variables
+            // and we want to use the new values
             const findServers = () => {
                 const userName = process.env.RABBITMQ_USERNAME || 'guest';
                 const password = process.env.RABBITMQ_PASSWORD || 'guest';
@@ -190,8 +192,6 @@ class RabbitMq {
             });
             this.connection.on('disconnect', ({ err }) => {
                 debug('rabbit: connection closed');
-                this.exchanges = {};
-                this.queues = {};
                 if (this.options?.disableReconnect) {
                     logger_1.default.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
                     this.blockReconnect = true;
@@ -202,7 +202,6 @@ class RabbitMq {
             });
             this.connection.once('connect', async () => {
                 debug('rabbit: connection established');
-                await this.loadConsumers();
                 this.creatingConnection = false;
                 this.em.emit(consts_1.CONNECTION_CREATED_CONST, connection);
                 isResolved = true;
@@ -216,7 +215,7 @@ class RabbitMq {
             const channel = connection.createChannel({});
             let isResolved = false;
             channel.on('error', (err) => {
-                logger_1.default.error(`rabbit: channel ${name} error`, { err });
+                logger_1.default.error(`rabbit: channel error ${name} error`, { err });
                 if (!isResolved) {
                     isResolved = true;
                     reject(err);
@@ -264,9 +263,12 @@ class RabbitMq {
     }
     async getQueueLength(queue) {
         RabbitMq.validateName('queue', queue);
-        const channel = await this.assertChannel();
+        const { channel } = this;
+        if (!channel) {
+            throw new Error('channel is not defined');
+        }
         debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
-        return channel.checkQueue(queue);
+        return channel?.checkQueue(queue);
     }
     async deleteQueue(queue) {
         RabbitMq.validateName('queue', queue);
@@ -319,18 +321,8 @@ class RabbitMq {
             options,
         });
     }
-    async loadConsumers() {
-        debug('rabbit: loading consumers', { consumers: this.consumers.length });
-        if (this.consumers.length > 0) {
-            await Promise.all(this.consumers.map((consumer) => this
-                .consumeFromRabbit(consumer.queue, consumer.callback, consumer.options)));
-        }
-    }
     async consume(queue, callback, options) {
-        if (this.connection && !this.creatingConnection) {
-            this.consumeFromRabbit(queue, callback, options);
-        }
-        return this.saveConsumer(queue, callback, options);
+        return this.consumeFromRabbit(queue, callback, options);
     }
     async lockRedisIfNeeded(msg, options) {
         const { properties: { headers } } = msg;
@@ -357,10 +349,10 @@ class RabbitMq {
             logger_1.default.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
         }
         const channel = await this.getNewChannel({ name: `consume-queue-${queue}` });
-        return channel.addSetup(async (c) => {
-            await c.assertQueue(queue, options ? { messageTtl: options.messageTtl } : undefined);
-            await c.prefetch(limit, true);
-            const { consumerTag } = await c.consume(queue, async (msg) => {
+        return channel.addSetup(async (confirmChannel) => {
+            await confirmChannel.assertQueue(queue, options ? { messageTtl: options.messageTtl } : undefined);
+            await confirmChannel.prefetch(limit, true);
+            const { consumerTag } = await confirmChannel.consume(queue, async (msg) => {
                 if (!msg) {
                     return null;
                 }
@@ -382,7 +374,7 @@ class RabbitMq {
                     }
                     catch (e) {
                         logger_1.default.error('rabbit: failed to setRabbitTrace', { userId, e });
-                        await this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
+                        await this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
                     }
                 }
                 if (traceId) {
@@ -395,13 +387,29 @@ class RabbitMq {
                 const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
                 if (!shouldConsume) {
                     await this.unlockRedisIfNeeded(releaseLock);
-                    return this.ack(channel, msg)(msg);
+                    return this.ack(confirmChannel, msg)(msg);
                 }
+                let messageAcked = false;
+                // setting the localAck function to be used in the callback
+                const localAck = async () => {
+                    if (messageAcked) {
+                        return;
+                    }
+                    messageAcked = true;
+                    return this.ack(confirmChannel, msg, true, releaseLock)(msg);
+                };
+                const localNack = async (_, nackOptions = {}) => {
+                    if (messageAcked) {
+                        return;
+                    }
+                    messageAcked = true;
+                    return this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg, nackOptions);
+                };
                 try {
-                    await callback(parsedMessage, this.ack(channel, msg, true, releaseLock), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock));
+                    await callback(parsedMessage, localAck, localNack);
                 }
                 catch (e) {
-                    await this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
+                    await localNack(msg);
                 }
             }, types_1.CONSUMER_DEFAULT_OPTIONS);
             if (!consumerTag) {
@@ -409,7 +417,7 @@ class RabbitMq {
             }
             else {
                 logger_1.default.info(`rabbit: adding tag ${consumerTag} to the array.`);
-                this.consumersTags.push([c, consumerTag]);
+                this.consumersTags.push([confirmChannel, consumerTag]);
             }
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "3.2.2",
+  "version": "3.2.4-beta.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/index.ts

@@ -53,6 +53,10 @@ export interface IAfRabbitMq {
   redisClient?: any;
 }
 
+interface NackOptions {
+  skipRetry?: boolean;
+}
+
 export interface AfRabbitOptions {
   disableReconnect?: boolean;
 
@@ -194,7 +198,7 @@ class RabbitMq implements IAfRabbitMq {
     return false;
   }
 
-  public ack = (channel: ChannelWrapper, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp = false, releaseLock = null) => async (userMsg: ConsumeMessage) : Promise<any> => {
+  public ack = (channel: ConfirmChannel, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp = false, releaseLock = null) => async (userMsg: ConsumeMessage) : Promise<any> => {
     if (msg) {
       await channel.ack(msg);
       const { properties: { headers } } = msg;
@@ -209,7 +213,7 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   public nack = (
-    channel: ChannelWrapper,
+    channel: ConfirmChannel,
     queue: string,
     options: any,
     deadQueueOptions: Options.AssertQueue,
@@ -219,7 +223,7 @@ class RabbitMq implements IAfRabbitMq {
     userMsg: ConsumeMessageOrNull,
     {
       skipRetry = false,
-    }: any = { },
+    }: NackOptions = { },
   ) : Promise<any> => {
     await this.unlockRedisIfNeeded(releaseLock);
     if (channel && msg) {
@@ -248,7 +252,6 @@ class RabbitMq implements IAfRabbitMq {
       await channel.ack(msg);
     } else {
       logger.error('no channel or msg', {
-        channel: channel ? channel.name : '',
         msg,
       });
     }
@@ -280,6 +283,9 @@ class RabbitMq implements IAfRabbitMq {
       this.creatingConnection = true;
       let isResolved = false;
 
+      // It is import to use it as a function and not as a variable
+      // because of k8s changes the env variables
+      // and we want to use the new values
       const findServers = () => {
         const userName = process.env.RABBITMQ_USERNAME || 'guest';
         const password = process.env.RABBITMQ_PASSWORD || 'guest';
@@ -316,8 +322,6 @@ class RabbitMq implements IAfRabbitMq {
 
       this.connection.on('disconnect', ({ err }) => {
         debug('rabbit: connection closed');
-        this.exchanges = {};
-        this.queues = {};
         if (this.options?.disableReconnect) {
           logger.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
           this.blockReconnect = true;
@@ -327,7 +331,6 @@ class RabbitMq implements IAfRabbitMq {
       });
       this.connection.once('connect', async () => {
         debug('rabbit: connection established');
-        await this.loadConsumers();
         this.creatingConnection = false;
         this.em.emit(CONNECTION_CREATED_CONST, connection);
         isResolved = true;
@@ -344,7 +347,7 @@ class RabbitMq implements IAfRabbitMq {
 
       let isResolved = false;
       channel.on('error', (err) => {
-        logger.error(`rabbit: channel ${name} error`, { err });
+        logger.error(`rabbit: channel error ${name} error`, { err });
         if (!isResolved) {
           isResolved = true;
           reject(err);
@@ -396,9 +399,12 @@ class RabbitMq implements IAfRabbitMq {
 
   async getQueueLength(queue: string) {
     RabbitMq.validateName('queue', queue);
-    const channel: ChannelWrapper = await this.assertChannel();
+    const { channel } = this;
+    if (!channel) {
+      throw new Error('channel is not defined');
+    }
     debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
-    return channel.checkQueue(queue);
+    return channel?.checkQueue(queue);
   }
 
   private async deleteQueue(queue: string) {
@@ -456,21 +462,8 @@ class RabbitMq implements IAfRabbitMq {
     });
   }
 
-  private async loadConsumers() {
-    debug('rabbit: loading consumers', { consumers: this.consumers.length });
-    if (this.consumers.length > 0) {
-      await Promise.all(
-        this.consumers.map((consumer) => this
-          .consumeFromRabbit(consumer.queue, consumer.callback, consumer.options)),
-      );
-    }
-  }
-
   async consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
-    if (this.connection && !this.creatingConnection) {
-      this.consumeFromRabbit(queue, callback, options);
-    }
-    return this.saveConsumer(queue, callback, options);
+    return this.consumeFromRabbit(queue, callback, options);
   }
 
   private async lockRedisIfNeeded(msg: any, options: any) {
@@ -506,10 +499,10 @@ class RabbitMq implements IAfRabbitMq {
       logger.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
     }
     const channel: ChannelWrapper = await this.getNewChannel({ name: `consume-queue-${queue}` });
-    return channel.addSetup(async (c: ConfirmChannel) => {
-      await c.assertQueue(queue, options ? { messageTtl: options.messageTtl } : undefined);
-      await c.prefetch(limit, true);
-      const { consumerTag } = await c.consume(
+    return channel.addSetup(async (confirmChannel: ConfirmChannel) => {
+      await confirmChannel.assertQueue(queue, options ? { messageTtl: options.messageTtl } : undefined);
+      await confirmChannel.prefetch(limit, true);
+      const { consumerTag } = await confirmChannel.consume(
         queue,
         async (msg: ConsumeMessageOrNull) => {
           if (!msg) {
@@ -533,7 +526,7 @@ class RabbitMq implements IAfRabbitMq {
               ]);
             } catch (e) {
               logger.error('rabbit: failed to setRabbitTrace', { userId, e });
-              await this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
+              await this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
             }
           }
 
@@ -548,16 +541,36 @@ class RabbitMq implements IAfRabbitMq {
           const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
           if (!shouldConsume) {
             await this.unlockRedisIfNeeded(releaseLock);
-            return this.ack(channel, msg)(msg);
+            return this.ack(confirmChannel, msg)(msg);
           }
+
+          let messageAcked = false;
+          // setting the localAck function to be used in the callback
+
+          const localAck = async () => {
+            if (messageAcked) {
+              return;
+            }
+            messageAcked = true;
+            return this.ack(confirmChannel, msg, true, releaseLock)(msg);
+          };
+
+          const localNack = async (_: ConsumeMessageOrNull, nackOptions: NackOptions = {}) => {
+            if (messageAcked) {
+              return;
+            }
+            messageAcked = true;
+            return this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg, nackOptions);
+          };
+
           try {
             await callback(
               parsedMessage,
-              this.ack(channel, msg, true, releaseLock),
-              this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock),
+              localAck,
+              localNack,
             );
           } catch (e) {
-            await this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
+            await localNack(msg);
           }
         }, CONSUMER_DEFAULT_OPTIONS,
       );
@@ -565,7 +578,7 @@ class RabbitMq implements IAfRabbitMq {
         logger.error(`rabbit: failed to consume from queue ${queue}`);
       } else {
         logger.info(`rabbit: adding tag ${consumerTag} to the array.`);
-        this.consumersTags.push([c, consumerTag]);
+        this.consumersTags.push([confirmChannel, consumerTag]);
       }
     });
   }