@autofleet/rabbit 2.5.1 → 2.5.2

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { Options, ConsumeMessage } from 'amqplib';
+import { ConfirmChannel, Options, ConsumeMessage } from 'amqplib';
 import { AmqpConnectionManager, ChannelWrapper } from 'amqp-connection-manager';
 import { EventEmitter } from 'events';
 import { RedisConfig } from './redis';
@@ -62,6 +62,8 @@ declare class RabbitMq implements IAfRabbitMq {
     options: AfRabbitOptions | undefined;
     redisClient: any;
     redisLock?: RedisLockType;
+    /** Array of consumers tags used for canceling consumption */
+    consumersTags: Array<[ConfirmChannel, string]>;
     constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig);
     private shouldConsumeMessageByTimestamp;
     ack: (channel: ChannelWrapper, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp?: boolean, releaseLock?: null) => (userMsg: ConsumeMessage) => Promise<any>;
@@ -81,5 +83,6 @@ declare class RabbitMq implements IAfRabbitMq {
     publish(exchange: string, content: any, customHeaders?: any): Promise<boolean>;
     sendToQueue(queue: string, content: any, options?: any, customHeaders?: any): Promise<boolean>;
     isConnected(): Promise<boolean>;
+    gracefulShutdown(signal: string): Promise<void>;
 }
 export default RabbitMq;

package/dist/index.js

@@ -105,6 +105,14 @@ class RabbitMq {
         if (this.redisClient) {
             this.redisLock = util_1.promisify(redis_lock_1.default(this.redisClient));
         }
+        this.consumersTags = [];
+        logger_1.default.info(`rabbit: [gracefully-shutdown] adding gracefully shutdown for process.pid ${process.pid}`);
+        process.on('SIGTERM', async () => {
+            await this.gracefulShutdown('SIGTERM');
+        });
+        process.on('SIGINT', async () => {
+            await this.gracefulShutdown('SIGINT');
+        });
     }
     static parseMsg(msg) {
         let { content } = msg;
@@ -244,37 +252,42 @@ class RabbitMq {
             if (!this.redisLock) {
                 throw new Error('Usage of consumeWithLock requires RedisInstance');
             }
-            logger_1.default.info(`Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
+            logger_1.default.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
         }
         const channel = await this.getNewChannel();
         return channel.addSetup(async (c) => {
             await c.assertQueue(queue);
             await c.prefetch(limit, true);
-            return Promise.all([
-                c.consume(queue, async (msg) => {
-                    if (!msg) {
-                        return null;
-                    }
-                    const traceId = msg.properties.headers[TRACING_HEADER];
-                    if (traceId) {
-                        const trace = outbreak_1.newTrace(outbreak_1.traceTypes.RABBIT);
-                        trace?.context?.set(TRACING_HEADER, traceId);
-                    }
-                    const parsedMessage = RabbitMq.parseMsg(msg);
-                    const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
-                    const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
-                    if (!shouldConsume) {
-                        await this.unlockRedisIfNeeded(releaseLock);
-                        return this.ack(channel, msg)(msg);
-                    }
-                    try {
-                        await callback(parsedMessage, this.ack(channel, msg, true, releaseLock), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock));
-                    }
-                    catch (e) {
-                        await this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
-                    }
-                }),
-            ]);
+            const { consumerTag } = await c.consume(queue, async (msg) => {
+                if (!msg) {
+                    return null;
+                }
+                const traceId = msg.properties.headers[TRACING_HEADER];
+                if (traceId) {
+                    const trace = outbreak_1.newTrace(outbreak_1.traceTypes.RABBIT);
+                    trace?.context?.set(TRACING_HEADER, traceId);
+                }
+                const parsedMessage = RabbitMq.parseMsg(msg);
+                const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
+                const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
+                if (!shouldConsume) {
+                    await this.unlockRedisIfNeeded(releaseLock);
+                    return this.ack(channel, msg)(msg);
+                }
+                try {
+                    await callback(parsedMessage, this.ack(channel, msg, true, releaseLock), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock));
+                }
+                catch (e) {
+                    await this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
+                }
+            });
+            if (!consumerTag) {
+                logger_1.default.error(`rabbit: failed to consume from queue ${queue}`);
+            }
+            else {
+                logger_1.default.info(`rabbit: adding tag ${consumerTag} to the array.`);
+                this.consumersTags.push([c, consumerTag]);
+            }
         });
     }
     async consumeFromExchange(queue, exchange, callback, options) {
@@ -314,5 +327,20 @@ class RabbitMq {
         const connection = await this.getConnection();
         return connection.isConnected();
     }
+    async gracefulShutdown(signal) {
+        const tagsNumber = this.consumersTags.length;
+        logger_1.default.info(`rabbit: [gracefully-shutdown] received ${signal}! canceling #${tagsNumber} tags...`);
+        const cancelTagPromises = this.consumersTags.map(([channel, tag]) => channel.cancel(tag));
+        // Clean the array to avoid race
+        this.consumersTags = [];
+        const results = await Promise.allSettled(cancelTagPromises);
+        const rejected = results.filter((p) => p.status === 'rejected');
+        if (rejected.length > 0) {
+            logger_1.default.warn(`rabbit: [gracefully-shutdown] #${rejected.length}/${tagsNumber} tags failed to cancel: ${rejected}`);
+        }
+        else {
+            logger_1.default.info('rabbit: [gracefully-shutdown] all tags successfully canceled.');
+        }
+    }
 }
 exports.default = RabbitMq;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "2.5.1",
+  "version": "2.5.2",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/index.ts

@@ -66,7 +66,7 @@ const defaultOptions = {
   useConsumeWithLock: DEFAULT_USE_CONSUME_WITH_LOCK,
 };
 
-const assertExchangeFanout = async (c: any, exchangeName: string) => c.assertExchange(exchangeName, 'fanout');
+const assertExchangeFanout = async (c: ChannelWrapper | ConfirmChannel, exchangeName: string) => c.assertExchange(exchangeName, 'fanout');
 
 const connectionCreatedConst = 'connectionCreated';
 
@@ -140,6 +140,9 @@ class RabbitMq implements IAfRabbitMq {
 
   redisLock?: RedisLockType;
 
+  /** Array of consumers tags used for canceling consumption */
+  consumersTags: Array<[ConfirmChannel, string]>;
+
   constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig) {
     this.em = new EventEmitter();
     this.channel = null;
@@ -152,6 +155,14 @@ class RabbitMq implements IAfRabbitMq {
     if (this.redisClient) {
       this.redisLock = promisify(RedisLock(this.redisClient)) as RedisLockType;
     }
+    this.consumersTags = [];
+    logger.info(`rabbit: [gracefully-shutdown] adding gracefully shutdown for process.pid ${process.pid}`);
+    process.on('SIGTERM', async () => {
+      await this.gracefulShutdown('SIGTERM');
+    });
+    process.on('SIGINT', async () => {
+      await this.gracefulShutdown('SIGINT');
+    });
   }
 
   private shouldConsumeMessageByTimestamp = async (msg: ConsumeMessageOrNull) => {
@@ -349,45 +360,49 @@ class RabbitMq implements IAfRabbitMq {
       if (!this.redisLock) {
         throw new Error('Usage of consumeWithLock requires RedisInstance');
       }
-      logger.info(`Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
+      logger.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
     }
     const channel: ChannelWrapper = await this.getNewChannel();
     return channel.addSetup(async (c: ConfirmChannel) => {
       await c.assertQueue(queue);
       await c.prefetch(limit, true);
-      return Promise.all([
-        c.consume(
-          queue,
-          async (msg: ConsumeMessageOrNull) => {
-            if (!msg) {
-              return null;
-            }
-
-            const traceId = msg.properties.headers[TRACING_HEADER];
-            if (traceId) {
-              const trace = newTrace(traceTypes.RABBIT);
-              (trace as any)?.context?.set(TRACING_HEADER, traceId);
-            }
-
-            const parsedMessage = RabbitMq.parseMsg(msg);
-            const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
-            const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
-            if (!shouldConsume) {
-              await this.unlockRedisIfNeeded(releaseLock);
-              return this.ack(channel, msg)(msg);
-            }
-            try {
-              await callback(
-                parsedMessage,
-                this.ack(channel, msg, true, releaseLock),
-                this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock),
-              );
-            } catch (e) {
-              await this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
-            }
-          },
-        ),
-      ]);
+      const { consumerTag } = await c.consume(
+        queue,
+        async (msg: ConsumeMessageOrNull) => {
+          if (!msg) {
+            return null;
+          }
+
+          const traceId = msg.properties.headers[TRACING_HEADER];
+          if (traceId) {
+            const trace = newTrace(traceTypes.RABBIT);
+            (trace as any)?.context?.set(TRACING_HEADER, traceId);
+          }
+
+          const parsedMessage = RabbitMq.parseMsg(msg);
+          const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
+          const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
+          if (!shouldConsume) {
+            await this.unlockRedisIfNeeded(releaseLock);
+            return this.ack(channel, msg)(msg);
+          }
+          try {
+            await callback(
+              parsedMessage,
+              this.ack(channel, msg, true, releaseLock),
+              this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock),
+            );
+          } catch (e) {
+            await this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
+          }
+        },
+      );
+      if (!consumerTag) {
+        logger.error(`rabbit: failed to consume from queue ${queue}`);
+      } else {
+        logger.info(`rabbit: adding tag ${consumerTag} to the array.`);
+        this.consumersTags.push([c, consumerTag]);
+      }
     });
   }
 
@@ -440,6 +455,21 @@ class RabbitMq implements IAfRabbitMq {
     const connection = await this.getConnection();
     return connection.isConnected();
   }
+
+  async gracefulShutdown(signal: string) : Promise<void> {
+    const tagsNumber = this.consumersTags.length;
+    logger.info(`rabbit: [gracefully-shutdown] received ${signal}! canceling #${tagsNumber} tags...`);
+    const cancelTagPromises = this.consumersTags.map(([channel, tag]) => channel.cancel(tag));
+    // Clean the array to avoid race
+    this.consumersTags = [];
+    const results = await Promise.allSettled(cancelTagPromises);
+    const rejected = results.filter((p) => p.status === 'rejected');
+    if (rejected.length > 0) {
+      logger.warn(`rabbit: [gracefully-shutdown] #${rejected.length}/${tagsNumber} tags failed to cancel: ${rejected}`);
+    } else {
+      logger.info('rabbit: [gracefully-shutdown] all tags successfully canceled.');
+    }
+  }
 }
 
 export default RabbitMq;