@autofleet/rabbit 3.1.2 → 3.2.2-2.beta-0

package/src/index.ts

@@ -1,16 +1,19 @@
 /* eslint-disable no-empty,consistent-return,no-async-promise-executor,@typescript-eslint/no-unused-vars */
 
-import { EventEmitter } from 'events';
+import { EventEmitter, once } from 'events';
 import { promisify } from 'util';
 import moment from 'moment';
 import RedisLock from 'redis-lock';
-import { AmqpConnectionManager, ChannelWrapper, connect } from 'amqp-connection-manager';
+import {
+  AmqpConnectionManager, ChannelWrapper, connect, CreateChannelOpts,
+} from 'amqp-connection-manager';
 import {
   ConfirmChannel, ConsumeMessage, Options, Replies,
 } from 'amqplib';
 import {
   getCurrentPayload, newTrace, traceTypes, createOrSetRabbitTrace, outbreak,
 } from '@autofleet/zehut';
+import { randomUUID } from 'node:crypto';
 import logger from './logger';
 import RabbitError from './lib/rabbitError';
 import getRedisInstance, { RedisConfig } from './lib/redis';
@@ -32,12 +35,15 @@ import {
   CustomMessageHeaders,
   QueuesCache,
   RedisLockType,
-  ExchangesCache, CONSUMER_DEFAULT_OPTIONS,
+  ExchangesCache, CONSUMER_DEFAULT_OPTIONS, QueueSetupPromisesDictionary,
+  ConnectionPurpose,
+  ConnectionData,
 } from './lib/types';
 
 // const debug = nodeDebug('af-rabbitmq')
-const debug = logger.info;
+const debug = logger.debug.bind(logger);
 
+const PUBLISH_TIMEOUT = 1000 * 10;
 export interface IAfRabbitMq {
   ack: any;
   nack: any;
@@ -51,6 +57,10 @@ export interface IAfRabbitMq {
   redisClient?: any;
 }
 
+interface NackOptions {
+  skipRetry?: boolean;
+}
+
 export interface AfRabbitOptions {
   disableReconnect?: boolean;
 
@@ -65,16 +75,21 @@ export interface AfRabbitOptions {
    * @default false
    */
   dontRetryAssert?: boolean;
+
+  rabbitHost?: string;
 }
 
 type newChannelOpts = {
   name?: string;
   onClose?: null | ((args: any | null) => void);
+  options?: CreateChannelOpts | undefined;
+  connectionPurpose: ConnectionPurpose,
 };
 
 type assertChannelOpts = {
   channelName?: string;
   force?: boolean;
+  connectionPurpose: ConnectionPurpose;
 }
 
 type AfConsumer = {
@@ -83,16 +98,10 @@ type AfConsumer = {
   options: ConsumeOptions | undefined;
 }
 
-const USERNAME: string = process.env.RABBITMQ_USERNAME || 'guest';
-
-const PASSWORD: string = process.env.RABBITMQ_PASSWORD || 'guest';
-
-const HOST: string = process.env.RABBITMQ_SERVICE_HOST || 'localhost';
-
 const HEARTBEAT = '60';
 
 class RabbitMq implements IAfRabbitMq {
-  static parseMsg(msg: any) : any {
+  static parseMsg(msg: any): any {
     let { content } = msg;
     content = content.toString();
 
@@ -106,7 +115,7 @@ class RabbitMq implements IAfRabbitMq {
     };
   }
 
-  static validateName(type: string, name: string) {
+  static validateName(type: string, name: string): void {
     if (!name || name === '') {
       throw new RabbitError(`error while using ${type} with no name`);
     }
@@ -119,6 +128,7 @@ class RabbitMq implements IAfRabbitMq {
     const outbreakTrace = outbreak.getCurrentContext();
     return {
       timestamp: moment().unix(),
+      timeout: PUBLISH_TIMEOUT,
       headers: {
         creationTimestamp: moment().valueOf(),
         ...customHeaders,
@@ -128,28 +138,29 @@ class RabbitMq implements IAfRabbitMq {
     };
   }
 
-  // PUBLISH_TIMEOUT = Number(process.env.RABBITMQ_PUBLISH_TIMEOUT) || 60000;
-
-  // PUBLISH_ERROR_MSG = `rabbit: publish timeout(${this.PUBLISH_TIMEOUT}ms) has pass, exchange: `;
-
   DISCONNECT_MSG = 'rabbit: connection disconnect';
 
   RECONNECT_MSG = 'rabbit: connection disconnect - reconnecting';
 
   channel: ChannelWrapper | null;
 
-  blockReconnect: boolean | null | undefined
+  publishChannelSetupPromise: Promise<ChannelWrapper> | null;
 
-  connection: AmqpConnectionManager | null | undefined
+  blockReconnect: boolean | null | undefined;
 
-  em: EventEmitter;
+  connectionsMap: {
+    [ConnectionPurpose.Consume]: ConnectionData;
+    [ConnectionPurpose.Publish]: ConnectionData;
+  };
 
-  creatingConnection: boolean;
+  em: EventEmitter;
 
   exchanges: ExchangesCache;
 
   queues: QueuesCache;
 
+  queueSetupPromises: QueueSetupPromisesDictionary;
+
   options: AfRabbitOptions | undefined;
 
   redisClient: any;
@@ -164,10 +175,15 @@ class RabbitMq implements IAfRabbitMq {
   constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig) {
     this.em = new EventEmitter();
     this.channel = null;
-    this.connection = null;
-    this.creatingConnection = false;
+    this.publishChannelSetupPromise = null;
+    this.connectionsMap = {
+      [ConnectionPurpose.Consume]: { connection: null, creatingConnection: false },
+      [ConnectionPurpose.Publish]: { connection: null, creatingConnection: false },
+    };
     this.exchanges = {};
     this.queues = {};
+    this.queueSetupPromises = {};
+    this.consumers = [];
     this.options = options;
     this.redisClient = redisConfig && getRedisInstance(redisConfig);
     if (this.redisClient) {
@@ -199,8 +215,9 @@ 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) {
+      debug('rabbit acking message', { deliveryTag: msg.fields.deliveryTag });
       await channel.ack(msg);
       const { properties: { headers } } = msg;
       const timestamp = headers?.creationTimestamp;
@@ -214,7 +231,7 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   public nack = (
-    channel: ChannelWrapper,
+    channel: ConfirmChannel,
     queue: string,
     options: any,
     deadQueueOptions: Options.AssertQueue,
@@ -224,8 +241,8 @@ class RabbitMq implements IAfRabbitMq {
     userMsg: ConsumeMessageOrNull,
     {
       skipRetry = false,
-    }: any = { },
-  ) : Promise<any> => {
+    }: NackOptions = {},
+  ): Promise<any> => {
     await this.unlockRedisIfNeeded(releaseLock);
     if (channel && msg) {
       if (
@@ -250,44 +267,68 @@ class RabbitMq implements IAfRabbitMq {
             : 1,
         });
       }
+      debug('rabbit nacking message', { deliveryTag: msg.fields.deliveryTag });
       await channel.ack(msg);
     } else {
       logger.error('no channel or msg', {
-        channel: channel ? channel.name : '',
         msg,
       });
     }
   }
 
-  async getConnection() {
-    return new Promise<AmqpConnectionManager>(async (resolve, reject) => {
+  async getConnection(connectionPurpose: ConnectionPurpose) {
+    return new Promise<AmqpConnectionManager | undefined | null>(async (resolve, reject) => {
+      let { connection, creatingConnection } = this.connectionsMap[connectionPurpose];
       if (this.blockReconnect) {
         debug('rabbit: block reconnect');
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore
         return resolve();
       }
-      if (this.connection !== null) {
-        if (this.options?.disableReconnect || this.connection?.isConnected()) {
+      if (connection !== null) {
+        if (this.options?.disableReconnect || connection?.isConnected()) {
           debug('rabbit: connection - is connected');
           // eslint-disable-next-line @typescript-eslint/ban-ts-comment
           // @ts-ignore
-          return resolve(this.connection);
+          return resolve(connection);
         }
         debug('rabbit: connection - reconnecting');
       }
-      if (this.creatingConnection) {
+      if (creatingConnection) {
         debug('rabbit: creating connection emi');
         this.em.once(CONNECTION_CREATED_CONST, resolve);
         this.em.once(CONNECTION_FAILED_CONST, reject);
         return;
       }
-      this.creatingConnection = true;
+      this.connectionsMap[connectionPurpose].creatingConnection = true;
       let isResolved = false;
-      debug('rabbit: creating connection', { HOST, USERNAME, HEARTBEAT });
-      const connection: AmqpConnectionManager = await connect([`amqp://${USERNAME}:${PASSWORD}@${HOST}?heartbeat=${HEARTBEAT}}`]);
-      this.connection = connection;
-      this.connection.on('error', (err) => {
+
+      // 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';
+        const host = this.options?.rabbitHost || process.env.RABBITMQ_SERVICE_HOST || 'localhost';
+
+        debug('rabbit: creating connection', { host, userName, HEARTBEAT });
+
+        return [`amqp://${userName}:${password}@${host}?heartbeat=${HEARTBEAT}`];
+      };
+
+      const defaultUrls = findServers();
+      const newConnection: AmqpConnectionManager = await connect(defaultUrls, {
+        findServers,
+      });
+
+      if (!newConnection) {
+        logger.error('rabbit: couldnt create a connection');
+        return resolve(connection);
+      }
+
+      this.connectionsMap[connectionPurpose].connection = newConnection;
+
+      newConnection.on('error', (err) => {
         logger.error('rabbit: connection error', { err });
         if (!isResolved) {
           isResolved = true;
@@ -296,7 +337,8 @@ class RabbitMq implements IAfRabbitMq {
         }
       });
 
-      this.connection.on('connectFailed', (err) => {
+      newConnection.on('connectFailed', (err) => {
+        this.consumersTags = [];
         logger.error('rabbit: connection connectFailed', { err });
         if (!isResolved) {
           isResolved = true;
@@ -305,12 +347,9 @@ class RabbitMq implements IAfRabbitMq {
         }
       });
 
-      this.connection.on('disconnect', ({ err }) => {
+      newConnection.on('disconnect', ({ err }) => {
+        this.consumersTags = [];
         debug('rabbit: connection closed');
-        this.exchanges = {};
-        this.queues = {};
-        this.connection = null;
-        this.channel = null;
         if (this.options?.disableReconnect) {
           logger.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
           this.blockReconnect = true;
@@ -318,66 +357,68 @@ class RabbitMq implements IAfRabbitMq {
           logger.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
         }
       });
-      this.connection.once('connect', async () => {
+      newConnection.once('connect', async () => {
         debug('rabbit: connection established');
-        await this.loadConsumers();
-        this.creatingConnection = false;
-        this.em.emit(CONNECTION_CREATED_CONST, connection);
+        this.connectionsMap[connectionPurpose].creatingConnection = false;
+        this.em.emit(CONNECTION_CREATED_CONST, newConnection);
         isResolved = true;
-        resolve(connection);
+        resolve(newConnection);
       });
     });
   }
 
-  async getNewChannel({ name = rand().toString(), onClose = null }: newChannelOpts = {}) {
-    return new Promise<ChannelWrapper>(async (resolve, reject) => {
-      const connection: AmqpConnectionManager = await this.getConnection();
-      const channel = connection.createChannel({});
-
-      let isResolved = false;
-      channel.on('error', (err) => {
-        logger.error(`rabbit: channel ${name} error`, { err });
-        if (!isResolved) {
-          isResolved = true;
-          reject(err);
-        }
-      });
-      channel.on('close', (...args) => {
-        logger.error(`rabbit: channel ${name} closed`, { args });
-        if (onClose) {
-          onClose(args);
-        }
-      });
-      channel.once('connect', () => {
-        debug(`rabbit: channel ${name} CONNECTED`);
-        isResolved = true;
-        resolve(channel);
-      });
+  async getNewChannel({
+    name = rand().toString(), onClose = null, options = {}, connectionPurpose = ConnectionPurpose.Consume,
+  }: newChannelOpts): Promise<ChannelWrapper> {
+    let connection!: AmqpConnectionManager | undefined | null;
+    try {
+      connection = await this.getConnection(connectionPurpose);
+    } catch (e) {
+      logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
+      throw e;
+    }
+    if (!connection) {
+      throw new Error(`rabbit: couldnt get connection for new channel ${name}`);
+    }
+    const channel = connection.createChannel({ ...options });
+    once(channel, 'close').then((args) => {
+      logger.error(`rabbit: channel ${name} closed`);
+      onClose?.(args);
     });
+    try {
+      await once(channel, 'connect');
+      debug(`rabbit: channel ${name} CONNECTED`);
+      return channel;
+    } catch (err) {
+      logger.error(`rabbit: channel error ${name} error`, { err });
+      throw err;
+    }
   }
 
-  async assertChannel({ force = false } : assertChannelOpts = {}): Promise<ChannelWrapper> {
-    return new Promise<ChannelWrapper>(async (resolve, reject) => {
-      if (this.channel && !force) {
-        return resolve(this.channel);
-      }
+  async assertChannel({ force = false, connectionPurpose = ConnectionPurpose.Consume }: assertChannelOpts): Promise<ChannelWrapper> {
+    if (!this.publishChannelSetupPromise) {
+      this.publishChannelSetupPromise = new Promise<ChannelWrapper>(async (resolve, reject) => {
+        if (this.channel && !force) {
+          return resolve(this.channel);
+        }
 
-      try {
-        const channel = await this.getNewChannel({
-          onClose: () => {
-            this.channel = null;
-          },
-        });
-        this.channel = channel;
-        resolve(channel);
-      } catch (e) {
-        reject(e);
-      }
-    });
+        try {
+          const channel = await this.getNewChannel({ connectionPurpose });
+          channel.on('error', (err) => {
+            logger.error('rabbit: channel error', { err });
+          });
+          this.channel = channel;
+          resolve(channel);
+        } catch (e) {
+          reject(e);
+        }
+      });
+    }
+    return this.publishChannelSetupPromise;
   }
 
   async assertExchange(exchangeName: string, options?: any) {
-    const channel: ChannelWrapper = await this.assertChannel();
+    const channel: ChannelWrapper = await this.assertChannel({ connectionPurpose: options.connectionPurpose });
     if (this.exchanges[exchangeName]) {
       return this.exchanges[exchangeName];
     }
@@ -386,36 +427,36 @@ class RabbitMq implements IAfRabbitMq {
     return exchange;
   }
 
-  async getQueueLength(queue: string) {
+  async getQueueLength(queue: string, connectionPurpose: ConnectionPurpose = ConnectionPurpose.Consume): Promise<Replies.AssertQueue> {
     RabbitMq.validateName('queue', queue);
-    const channel: ChannelWrapper = await this.assertChannel();
-    debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
-    return channel.checkQueue(queue);
+    let { connection } = this.connectionsMap[connectionPurpose];
+    const { channel } = this;
+    if (!channel) {
+      throw new Error('channel is not defined');
+    }
+    debug('rabbit: getting queue length', { queue, connected: connection?.isConnected() });
+    return channel?.checkQueue(queue);
   }
 
-  private async deleteQueue(queue: string) {
+  private async deleteQueue(queue: string, connectionPurpose: ConnectionPurpose) {
     RabbitMq.validateName('queue', queue);
-    const channel: ChannelWrapper = await this.assertChannel();
+    const channel: ChannelWrapper = await this.assertChannel({ connectionPurpose });
     logger.info('rabbit: deleting queue', { queue });
     const deleteQueueRes = await channel.deleteQueue(queue);
     debug('queue deleted', deleteQueueRes);
     return deleteQueueRes;
   }
 
-  async bindQueue(queue: string, exchange: string) {
-    const channel: ChannelWrapper = await this.assertChannel();
+  async bindQueue(queue: string, exchange: string, connectionPurpose: ConnectionPurpose) {
+    const channel: ChannelWrapper = await this.assertChannel({ connectionPurpose });
     await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.bindQueue(queue, exchange, ''));
     return channel.bindQueue(queue, exchange, '');
   }
 
-  async assertQueue(queueName: string, options?: Options.AssertQueue) {
-    let queue: Replies.AssertQueue | null = null;
-    RabbitMq.validateName('queue', queueName);
-    if (this.queues[queueName]) {
-      return this.queues[queueName];
-    }
+  async setupQueue(queueName: string, connectionPurpose: ConnectionPurpose, options?: Options.AssertQueue): Promise<Replies.AssertQueue> {
+    let queue: Replies.AssertQueue;
     try {
-      const channel: ChannelWrapper = await this.assertChannel();
+      const channel: ChannelWrapper = await this.assertChannel({ connectionPurpose });
       debug('assertQueue->channel.addSetup', { queueName });
       await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, options));
       debug('assertQueue->channel.assertQueue', { queueName });
@@ -424,12 +465,12 @@ class RabbitMq implements IAfRabbitMq {
       logger.error('rabbit: assertQueue error', { queueName, options, error: e });
       if (!this.options?.dontRetryAssert) {
         debug('retrying assertQueue', { queueName });
-        const channel = await this.assertChannel({ force: true });
-        await this.deleteQueue(queueName);
+        const channel = await this.assertChannel({ force: true, connectionPurpose });
+        await this.deleteQueue(queueName, connectionPurpose);
 
-        debug('1assertQueue->channel.addSetup', { queueName });
+        debug('retrying assertQueue->channel.addSetup', { queueName });
         await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, options));
-        debug('1assertQueue->channel.assertQueue', { queueName });
+        debug('retrying assertQueue->channel.assertQueue', { queueName });
         queue = await channel.assertQueue(queueName, options);
       } else {
         throw e;
@@ -440,29 +481,35 @@ class RabbitMq implements IAfRabbitMq {
     return queue;
   }
 
-  private saveConsumer(queue: string, callback: CallbackFunction, options: ConsumeOptions | undefined) {
-    this.consumers.push({
-      queue,
-      callback,
-      options,
-    });
+  async assertQueue(queueName: string, connectionPurpose: ConnectionPurpose, options?: Options.AssertQueue) {
+    RabbitMq.validateName('queue', queueName);
+    if (this.queues[queueName]) {
+      delete this.queueSetupPromises[queueName];
+      return this.queues[queueName];
+    }
+
+    if (this.queueSetupPromises[queueName]) {
+      return this.queueSetupPromises[queueName];
+    }
+
+    this.queueSetupPromises[queueName] = this.setupQueue(queueName, connectionPurpose, options);
+    return this.queueSetupPromises[queueName];
   }
 
-  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)),
-      );
+  private saveConsumer(queue: string, callback: CallbackFunction, options: ConsumeOptions | undefined) {
+    const isConsumerExist: boolean = this.consumers.some((consumer) => consumer.queue === queue);
+    if (!isConsumerExist) {
+      logger.info(`rabbit: consumer: ${queue} saved in consumer array`);
+      this.consumers.push({
+        queue,
+        callback,
+        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);
+    await this.consumeFromRabbit(queue, callback, options);
   }
 
   private async lockRedisIfNeeded(msg: any, options: any) {
@@ -488,6 +535,8 @@ class RabbitMq implements IAfRabbitMq {
   private async consumeFromRabbit(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
     const optionsWithDefaults = { ...DEFAULT_OPTIONS, ...options };
     RabbitMq.validateName('queue', queue);
+    this.saveConsumer(queue, callback, options);
+    const uniqueId = randomUUID();
     const {
       limit, deadMessageTtl, useConsumeWithLock, lockTimeout, auditContext, enableRabbitTrace,
     } = optionsWithDefaults;
@@ -497,11 +546,11 @@ 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(
+    const channel = await this.getNewChannel({ connectionPurpose: ConnectionPurpose.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) {
@@ -525,7 +574,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);
+              return this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
             }
           }
 
@@ -540,16 +589,37 @@ 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;
+            }
+            debug('rabbit localNack', { messageAcked, uniqueId, deliveryTag: msg.fields.deliveryTag });
+            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,
       );
@@ -557,17 +627,18 @@ 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]);
       }
     });
   }
 
-  async consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions) : Promise<any> {
+  async consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
     const optionsWithDefaults = { ...DEFAULT_OPTIONS, ...options };
     RabbitMq.validateName('exchange', exchange);
     RabbitMq.validateName('queue', queue);
     const { limit, deadMessageTtl } = optionsWithDefaults;
-    const channel: ChannelWrapper = await this.getNewChannel({ name: `consume-exchange-${exchange}-queue-${queue}` });
+    await this.saveConsumer(queue, callback, options);
+    const channel: ChannelWrapper = await this.getNewChannel({ name: `consume - exchange - ${exchange} -queue - ${queue}`, connectionPurpose: ConnectionPurpose.Consume });
 
     return channel.addSetup(async (c: ConfirmChannel) => {
       const assertExchange = await assertExchangeFanout(c, exchange);
@@ -585,11 +656,11 @@ class RabbitMq implements IAfRabbitMq {
     });
   }
 
-  async publish(exchange: string, content: any, customHeaders?: any) : Promise<boolean> {
+  async publish(exchange: string, content: any, customHeaders?: any): Promise<boolean> {
     return wrapSetImmediate(async () => {
       RabbitMq.validateName('exchange', exchange);
-      const channel: ChannelWrapper = await this.assertChannel();
-      await this.assertExchange(exchange);
+      const channel: ChannelWrapper = await this.assertChannel({ connectionPurpose: ConnectionPurpose.Publish });
+      await this.assertExchange(exchange, { connectionPurpose: ConnectionPurpose.Publish });
       await channel.publish(exchange, '',
         Buffer.from(JSON.stringify(content)),
         RabbitMq.getPublishOptions(customHeaders));
@@ -601,30 +672,61 @@ class RabbitMq implements IAfRabbitMq {
     content: any,
     options?: any,
     customHeaders?: any,
-    isBlocking?: boolean,
   ): Promise<boolean | undefined> {
-    const callback = async (): Promise<boolean | undefined> => {
+    try {
+      await this.assertChannel({ connectionPurpose: ConnectionPurpose.Publish });
+    } catch (e) {
+      logger.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
+      throw e;
+    }
+
+    try {
       RabbitMq.validateName('queue', queue);
-      await this.assertChannel();
-      await this.assertQueue(queue, options);
+      await this.assertQueue(queue, ConnectionPurpose.Publish, options);
+    } catch (e) {
+      logger.error(`rabbit sendToQueue: failed to assert queue ${queue}`, { e });
+      throw e;
+    }
+
+    try {
       const res = await this.channel?.sendToQueue(queue,
         Buffer.from(JSON.stringify(content)),
         RabbitMq.getPublishOptions(customHeaders));
       debug(`rabbit: sending to queue ${queue}`, { res });
       return res;
-    };
-    if (isBlocking) {
-      return callback();
+    } catch (e) {
+      const isConnected = await this.isConnected(ConnectionPurpose.Publish);
+      logger.error(`rabbit sendToQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
+      throw e;
     }
-    return wrapSetImmediate(callback);
   }
 
-  async isConnected() : Promise<boolean> {
-    const connection = await this.getConnection();
-    return connection.isConnected();
+  async isConnected(connectionPurpose: ConnectionPurpose): Promise<boolean> {
+    const connection = await this.getConnection(connectionPurpose);
+    if (!connection) {
+      logger.error('rabbit: isConnected - false');
+      return false;
+    }
+    const isConnected = connection.isConnected();
+    if (!isConnected) {
+      logger.error('rabbit: isConnected - false');
+      return false;
+    }
+    const channel: any = await this.assertChannel({ connectionPurpose });
+    try {
+      await Promise.all([
+        channel.waitForConnect(),
+        ...this.consumers.map((c: AfConsumer) => channel.checkQueue(c.queue)),
+      ]);
+    } catch (e) {
+      logger.error('rabbit: isConnected - false');
+      return false;
+    }
+    logger.info('rabbit: isConnected - true');
+    return true;
   }
 
-  async gracefulShutdown(signal: string) : Promise<void> {
+  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));