@autofleet/rabbit 4.1.0-beta.0 → 4.1.0

package/src/index.ts

@@ -1,99 +1,107 @@
-/* eslint-disable no-empty,consistent-return,no-async-promise-executor,@typescript-eslint/no-unused-vars */
-
-import { EventEmitter, once } from 'events';
-import { promisify } from 'util';
+import { env } from 'node:process';
+import { setImmediate } from 'node:timers/promises';
+import { EventEmitter, once } from 'node:events';
 import moment from 'moment';
 import RedisLock from 'redis-lock';
 import {
-  AmqpConnectionManager, ChannelWrapper, connect, CreateChannelOpts,
+  type AmqpConnectionManager, type ChannelWrapper, connect, type CreateChannelOpts,
 } from 'amqp-connection-manager';
+// eslint-disable-next-line import/no-unresolved
+import type { PublishOptions } from 'amqp-connection-manager/dist/types/ChannelWrapper';
 import {
   ConfirmChannel, ConsumeMessage, Options, Replies,
 } from 'amqplib';
+import { backOff } from 'exponential-backoff';
+import type { LoggerInstanceManager } from '@autofleet/logger';
 import {
-  getCurrentPayload, newTrace, traceTypes, createOrSetRabbitTrace, outbreak,
+  getUser, getCurrentPayload, newTrace, traceTypes, createOrSetRabbitTrace, outbreak,
 } from '@autofleet/zehut';
 import { randomUUID } from 'node:crypto';
-import axios from 'axios';
 import logger from './logger';
 import RabbitError from './lib/rabbitError';
 import getRedisInstance, { RedisConfig } from './lib/redis';
-import { assertExchangeFanout, rand, wrapSetImmediate } from './lib/utils';
+import {
+  assertExchangeFanout, createDeferredPromise, getAssertVhostExponentialBackoffConfig, rand,
+} from './lib/utils';
 import {
   AUTOMATION_ID_HEADER,
-  CONNECTION_CREATED_CONST,
-  CONNECTION_FAILED_CONST,
   DEFAULT_LOCK_TIMEOUT,
   DEFAULT_OPTIONS,
   RETRY_HEADER,
   TRACING_HEADER,
-  USER_OBJECT,
   USER_TRACING_HEADER,
 } from './lib/consts';
 import {
-  CallbackFunction,
-  ConsumeMessageOrNull,
-  ConsumeOptions,
-  CustomMessageHeaders,
-  QueuesCache,
-  RedisLockType,
-  ExchangesCache,
+  type AssertExchangePromisesDictionary,
+  type CallbackFunction,
+  type ConnectionData,
+  type ConsumeMessageOrNull,
+  type ConsumeOptions,
   CONSUMER_DEFAULT_OPTIONS,
-  QueueSetupPromisesDictionary,
-  AssertExchangePromisesDictionary,
+  type CustomMessageHeaders,
+  type ExchangesCache,
+  type Message,
+  type NackOptions,
+  type QueuesCache,
+  type QueueSetupPromisesDictionary,
 } from './lib/types';
 
-// const debug = nodeDebug('af-rabbitmq')
-const debug = logger.debug.bind(logger);
-
 const PUBLISH_TIMEOUT = 1000 * 10;
 
-export interface IAfRabbitMq {
-  ack: any;
-  nack: any;
-  assertChannel: any;
-  assertExchange: any;
-  assertQueue: any;
-  consume: any;
-  consumeFromExchange: any;
-  publish: any;
-  sendToQueue: any;
-  redisClient?: any;
-}
+// TODO: [QUORUM-PHASE-3] Delete these env vars
+const {
+  DISABLE_QUORUM_QUEUES_CONSUME,
+  DISABLE_QUORUM_QUEUES_PUBLISH,
+} = env;
 
-interface NackOptions {
-  skipRetry?: boolean;
+export interface IAfRabbitMq {
+  ack(channel: ConfirmChannel, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp?: boolean, releaseLock?: (() => Promise<void>) | null): (userMsg: ConsumeMessage) => Promise<void>;
+  nack(
+    channel: ConfirmChannel,
+    queue: string,
+    options: ConsumeOptions,
+    deadQueueOptions: Options.AssertQueue,
+    msg: ConsumeMessageOrNull,
+    releaseLock?: () => Promise<void>,
+  ): (userMsg: ConsumeMessageOrNull, nackOptions?: NackOptions) => Promise<void> ;
+  assertChannel(options?: assertChannelOpts): Promise<ChannelWrapper>;
+  assertExchange(exchangeName: string, connection: ConnectionData): Promise<Replies.AssertExchange>
+  assertQueue(queueName: string, options?: Options.AssertQueue | null): Promise<Replies.AssertQueue>;
+  consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void>;
+  consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void>
+  publish(exchange: string, content: any, customHeaders?: PublishOptions['headers']): Promise<void>
+  sendToQueue(queue: string, content: any, options?: Options.AssertQueue | null, customHeaders?: PublishOptions['headers']): Promise<boolean | undefined>;
+  redisClient?: ReturnType<typeof getRedisInstance>;
 }
 
 export interface AfRabbitOptions {
   disableReconnect?: boolean;
-
   /**
    * When you want your own grace-full shutdown, set this to true.
    * @default false
    */
   dontGracefulShutdown?: boolean;
-
   /**
-   * dont retry on creation error
+   * don't retry on creation error
    * @default false
    */
   dontRetryAssert?: boolean;
-
   rabbitHost?: string;
-
   vhost?: string;
+  logger?: LoggerInstanceManager;
 }
 
 type newChannelOpts = {
   name?: string;
   onClose?: null | ((args: any | null) => void);
   options?: CreateChannelOpts | undefined;
+  connection: ConnectionData;
 };
 
 type assertChannelOpts = {
   channelName?: string;
   force?: boolean;
+  connection: ConnectionData;
 }
 
 type AfConsumer = {
@@ -105,13 +113,12 @@ type AfConsumer = {
 const HEARTBEAT = '60';
 
 class RabbitMq implements IAfRabbitMq {
-  static parseMsg(msg: any) : any {
-    let { content } = msg;
-    content = content.toString();
+  static parseMsg(msg: ConsumeMessage): Message {
+    let content = msg.content.toString();
 
     try {
       content = JSON.parse(content);
-    } catch (e) { }
+    } catch { /* ignore error */ }
 
     return {
       ...msg,
@@ -125,11 +132,10 @@ class RabbitMq implements IAfRabbitMq {
     }
   }
 
-  static getPublishOptions(customHeaders: CustomMessageHeaders = {}) {
-    const trace = getCurrentPayload();
-    const user = trace?.context?.get(USER_OBJECT);
-    const traceId = trace?.context?.get(TRACING_HEADER);
-    const outbreakTrace = outbreak.getCurrentContext();
+  static getPublishOptions(customHeaders: CustomMessageHeaders = {}): PublishOptions {
+    const user = getUser();
+    const traceId = getCurrentPayload()?.context?.get(TRACING_HEADER) || outbreak.getCurrentContext()?.context?.get(TRACING_HEADER);
+
     return {
       timestamp: moment().unix(),
       timeout: PUBLISH_TIMEOUT,
@@ -137,97 +143,110 @@ class RabbitMq implements IAfRabbitMq {
         creationTimestamp: moment().valueOf(),
         ...customHeaders,
         [USER_TRACING_HEADER]: user?.id,
-        [TRACING_HEADER]: traceId || outbreakTrace?.context?.get(TRACING_HEADER),
+        [TRACING_HEADER]: traceId,
       },
     };
   }
 
-  DISCONNECT_MSG = 'rabbit: connection disconnect';
-
-  RECONNECT_MSG = 'rabbit: connection disconnect - reconnecting';
-
-  channel: ChannelWrapper | null;
+  readonly DISCONNECT_MSG = 'rabbit: connection disconnect';
 
-  publishChannelSetupPromise: Promise<ChannelWrapper> | null;
+  readonly RECONNECT_MSG = 'rabbit: connection disconnect - reconnecting';
 
-  blockReconnect: boolean | null | undefined
+  publishChannel: ChannelWrapper | null = null;
 
-  connection: AmqpConnectionManager | null | undefined
+  publishChannelSetupPromise: Promise<ChannelWrapper> | null = null;
 
-  em: EventEmitter;
+  readonly publishConnection: ConnectionData = {
+    amqpConnection: null,
+    creatingConnection: false,
+    connectionCreatedEventName: 'publishConnectionCreated',
+    connectionFailedEventName: 'publishConnectionFailed',
+    blockReconnect: false,
+  };
 
-  creatingConnection: boolean;
+  readonly consumeConnection: ConnectionData = {
+    amqpConnection: null,
+    creatingConnection: false,
+    connectionCreatedEventName: 'consumeConnectionCreated',
+    connectionFailedEventName: 'consumeConnectionFailed',
+    blockReconnect: false,
+  };
 
-  exchanges: ExchangesCache;
+  readonly em: EventEmitter = new EventEmitter();
 
-  queues: QueuesCache;
+  readonly exchanges: ExchangesCache = {};
 
-  queueSetupPromises: QueueSetupPromisesDictionary;
+  readonly queues: QueuesCache = {};
 
-  assertExchangePromises: AssertExchangePromisesDictionary;
+  readonly queueSetupPromises: QueueSetupPromisesDictionary = {};
 
-  options: AfRabbitOptions | undefined;
+  readonly assertExchangePromises: AssertExchangePromisesDictionary = {};
 
-  redisClient: any;
+  readonly redisClient?: ReturnType<typeof getRedisInstance>;
 
-  redisLock?: RedisLockType;
+  readonly redisLock?: ReturnType<typeof RedisLock>;
 
   /** Array of consumers tags used for canceling consumption */
-  consumersTags: Array<[ConfirmChannel, string]>;
+  readonly consumersTags: Map<string, { channel: ConfirmChannel; consumerTag: string }> = new Map<string, { channel: ConfirmChannel; consumerTag: string }>();
 
-  private consumers: Array<AfConsumer> = [];
+  private readonly consumersToRegister: Array<AfConsumer> = [];
 
-  private isVHostExist = false;
+  private doesVHostExist = false;
 
-  // TODO: DELETE OLD PROPERTIES
+  private readonly vhost = 'quorum-vhost';
 
-  oldChannel: ChannelWrapper | null;
+  private gracefulShutdownStarted = false;
 
-  oldPublishChannelSetupPromise: Promise<ChannelWrapper> | null;
+  // TODO:[QUORUM-PHASE-3] Delete the old properties that we use for the old consumers and publishers
+  oldPublishChannel: ChannelWrapper | null = null;
 
-  oldBlockReconnect: boolean | null | undefined
+  oldPublishChannelSetupPromise: Promise<ChannelWrapper> | null = null;
 
-  oldConnection: AmqpConnectionManager | null | undefined
+  readonly oldPublishConnection: ConnectionData = {
+    amqpConnection: null,
+    creatingConnection: false,
+    connectionCreatedEventName: 'oldPublishConnectionCreated',
+    connectionFailedEventName: 'oldPublishConnectionFailed',
+    blockReconnect: false,
+  };
 
-  oldEm: EventEmitter;
+  readonly oldConsumeConnection: ConnectionData = {
+    amqpConnection: null,
+    creatingConnection: false,
+    connectionCreatedEventName: 'oldConsumeConnectionCreated',
+    connectionFailedEventName: 'oldConsumeConnectionFailed',
+    blockReconnect: false,
+  };
 
-  oldCreatingConnection: boolean;
+  readonly oldEm: EventEmitter = new EventEmitter();
 
-  oldExchanges: ExchangesCache;
+  readonly oldExchanges: ExchangesCache = {};
 
-  oldQueues: QueuesCache;
+  readonly oldQueues: QueuesCache = {};
 
-  oldQueueSetupPromises: QueueSetupPromisesDictionary;
+  readonly oldQueueSetupPromises: QueueSetupPromisesDictionary = {};
 
-  oldAssertExchangePromises: AssertExchangePromisesDictionary;
+  readonly oldAssertExchangePromises: AssertExchangePromisesDictionary = {};
 
-  oldConsumersTags: Array<[ConfirmChannel, string]>;
+  readonly oldConsumersTags: Map<string, { channel: ConfirmChannel; consumerTag: string }> = new Map<string, { channel: ConfirmChannel; consumerTag: string }>();
 
-  private oldConsumers: Array<AfConsumer> = [];
+  private readonly oldConsumersToRegister: Array<AfConsumer> = [];
 
-  constructor(options: AfRabbitOptions = {}, redisConfig?: RedisConfig) {
-    this.em = new EventEmitter();
-    this.channel = null;
-    this.publishChannelSetupPromise = null;
-    this.connection = null;
-    this.creatingConnection = false;
-    this.exchanges = {};
-    this.queues = {};
-    this.queueSetupPromises = {};
-    this.assertExchangePromises = {};
-    this.consumers = [];
-    this.options = options;
+  #logger: LoggerInstanceManager;
 
-    if (!options?.vhost) {
-      this.options.vhost = process.env.VHOST_NAME || 'quorum-vhost';
-    }
+  constructor(public readonly options: AfRabbitOptions = {}, private readonly redisConfig?: RedisConfig) {
+    this.#logger = options?.logger || logger;
 
-    this.redisClient = redisConfig && getRedisInstance(redisConfig);
-    if (this.redisClient) {
-      this.redisLock = promisify(RedisLock(this.redisClient)) as RedisLockType;
+    if (redisConfig) {
+      this.redisClient = getRedisInstance(redisConfig).on('error', (err) => {
+        this.#logger.error('rabbit: Redis error', { err, redisConfig });
+      });
+      this.redisClient.connect().catch((err) => {
+        this.#logger.error('rabbit: Failed to connect to Redis', { err, redisConfig });
+      });
+      this.redisLock = RedisLock(this.redisClient);
     }
-    this.consumersTags = [];
-    logger.info(`rabbit: [gracefully-shutdown] adding gracefully shutdown for process.pid ${process.pid}`);
+    this.#logger.info(`rabbit: [gracefully-shutdown] adding gracefully shutdown for process.pid ${process.pid}`);
     if (!this.options?.dontGracefulShutdown) {
       process.on('SIGTERM', async () => {
         await this.gracefulShutdown('SIGTERM');
@@ -236,81 +255,73 @@ class RabbitMq implements IAfRabbitMq {
         await this.gracefulShutdown('SIGINT');
       });
     }
+  }
 
-    // TODO: DELETE OLD PROPERTIES
-    this.oldEm = new EventEmitter();
-    this.oldChannel = null;
-    this.oldPublishChannelSetupPromise = null;
-    this.oldConnection = null;
-    this.oldCreatingConnection = false;
-    this.oldExchanges = {};
-    this.oldQueues = {};
-    this.oldQueueSetupPromises = {};
-    this.oldAssertExchangePromises = {};
-    this.oldConsumers = [];
-    this.oldConsumersTags = [];
+  private getRedisKey(key: string): string {
+    return `${this.redisConfig?.prefix || ''}${key}`;
   }
 
   private assertVHost = async () => {
-    if (this.isVHostExist) {
+    if (this.doesVHostExist) {
       return;
     }
 
-    if (!this.options?.vhost) {
-      throw new Error('vhost is not defined');
-    }
-
-    const { vhost } = this.options;
-    const auth = {
-      auth: {
-        username: process.env.RABBITMQ_USERNAME || 'guest',
-        password: process.env.RABBITMQ_PASSWORD || 'guest',
-      },
+    const username = process.env.RABBITMQ_USERNAME || 'guest';
+    const password = process.env.RABBITMQ_PASSWORD || 'guest';
+    const credentials = Buffer.from(`${username}:${password}`).toString('base64');
+    const headers = {
+      Authorization: `Basic ${credentials}`,
+      'Content-Type': 'application/json',
     };
-    const rabbitHost = `http://${(this.options.rabbitHost || process.env.RABBITMQ_SERVICE_HOST || 'localhost').split(':')[0]}:15672`;
+
+    const rabbitHost = `http://${(this.options?.rabbitHost || process.env.RABBITMQ_SERVICE_HOST || 'localhost').split(':')[0]}:15672`;
+
+    const url = `${rabbitHost}/api/vhosts/${encodeURIComponent(this.vhost)}`;
 
     try {
-      const response = await axios.get(`${rabbitHost}/api/vhosts/${encodeURIComponent(vhost)}`, auth);
+      const response = await fetch(url, {
+        method: 'GET',
+        headers,
+      });
 
-      if (response.status !== 200) {
-        throw new Error('Failed to check vhost');
+      if (response.status === 200) {
+        this.doesVHostExist = true;
+        this.#logger.info('Vhost exists', { vhost: this.vhost });
+        return;
       }
 
-      this.isVHostExist = true;
-      logger.info('Vhost exists', { vhost });
-    } catch (error) {
-      // If the vhost does not exist, create it
-      if (error instanceof axios.AxiosError && error.response?.status === 404) {
-        try {
-          await axios.put(
-            `${rabbitHost}/api/vhosts/${encodeURIComponent(vhost)}`,
-            {
-              default_queue_type: 'quorum',
-            },
-            auth,
-          );
+      if (response.status !== 404) {
+        this.#logger.error('Failed to check vhost', { response });
+        throw new RabbitError('Failed to check vhost');
+      }
 
-          this.isVHostExist = true;
-          logger.info('Vhost created', { vhost: this.options?.vhost });
-          return;
-        } catch (createError) {
-          logger.error('Failed to create vhost', { error: createError });
-          throw createError;
-        }
+      const createResponse = await fetch(url, {
+        method: 'PUT',
+        headers,
+        body: JSON.stringify({ default_queue_type: 'quorum' }),
+      });
+
+      if (!createResponse.ok) {
+        this.#logger.error('Failed to create vhost', { response: createResponse });
+        throw new RabbitError('Failed to create vhost');
       }
 
-      logger.error('Failed to check vhost', { error });
+      this.doesVHostExist = true;
+      this.#logger.info('Vhost created', { vhost: this.vhost });
+    } catch (error) {
+      this.#logger.error('Failed to check or create vhost', { error });
       throw error;
     }
-  }
+  };
 
   private shouldConsumeMessageByTimestamp = async (msg: ConsumeMessageOrNull) => {
     if (msg) {
-      const { properties: { headers } } = msg;
+      const { headers } = msg.properties;
       const timestamp = headers?.creationTimestamp;
 
       if (timestamp && headers?.redisTimestampValidationKey && this.redisClient) {
-        const lastMessageTimestamp = await this.redisClient.getAsync(headers.redisTimestampValidationKey);
+        const key = this.getRedisKey(headers.redisTimestampValidationKey);
+        const lastMessageTimestamp = await this.redisClient.get(key);
         return !lastMessageTimestamp || (parseInt(lastMessageTimestamp, 10) <= parseInt(timestamp, 10));
       }
       return true;
@@ -318,16 +329,22 @@ class RabbitMq implements IAfRabbitMq {
     return false;
   }
 
-  public ack = (channel: ConfirmChannel, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp = false, releaseLock = null) => async (userMsg: ConsumeMessage) : Promise<any> => {
+  public ack = (
+    channel: ConfirmChannel,
+    msg: ConsumeMessageOrNull,
+    shouldUpdateRedisTimestamp = false,
+    releaseLock: (() => Promise<void>) | null = null,
+  ) => async (userMsg: ConsumeMessage) : Promise<void> => { // eslint-disable-line @typescript-eslint/no-unused-vars
     if (msg) {
-      debug('rabbit acking message', { deliveryTag: msg.fields.deliveryTag });
+      this.#logger.debug('rabbit acking message', { deliveryTag: msg.fields.deliveryTag });
       await channel.ack(msg);
-      const { properties: { headers } } = msg;
+      const { headers } = msg.properties;
       const timestamp = headers?.creationTimestamp;
 
       if (shouldUpdateRedisTimestamp && timestamp && headers?.redisTimestampValidationKey && this.redisClient) {
         const parsedTimestamp = parseInt(timestamp, 10);
-        await this.redisClient.setAsync(headers.redisTimestampValidationKey, parsedTimestamp, 'EX', 3600);
+        const key = this.getRedisKey(headers.redisTimestampValidationKey);
+        await this.redisClient.set(key, parsedTimestamp, { EX: 3600 });
         await this.unlockRedisIfNeeded(releaseLock);
       }
     }
@@ -336,223 +353,224 @@ class RabbitMq implements IAfRabbitMq {
   public nack = (
     channel: ConfirmChannel,
     queue: string,
-    options: any,
+    options: ConsumeOptions,
     deadQueueOptions: Options.AssertQueue,
     msg: ConsumeMessageOrNull,
-    releaseLock: any,
+    releaseLock?: (() => Promise<void>) | null,
   ) => async (
     userMsg: ConsumeMessageOrNull,
     {
       skipRetry = false,
     }: NackOptions = { },
-  ) : Promise<any> => {
+  ): Promise<void> => {
     await this.unlockRedisIfNeeded(releaseLock);
-    if (channel && msg) {
-      if (
-        !skipRetry
-        && (
-          !msg.properties.headers[RETRY_HEADER]
-          || parseInt(msg.properties.headers[RETRY_HEADER], 10) < options.retries
-        )
-      ) {
-        await this.sendToQueue(queue, RabbitMq.parseMsg(msg).content, options, {
-          ...msg.properties.headers,
-          [RETRY_HEADER]: msg.properties.headers[RETRY_HEADER]
-            ? msg.properties.headers[RETRY_HEADER] + 1
-            : 1,
-        });
-      } else {
-        const deadQueue = `${queue}-dead`;
-        await this.sendToQueue(deadQueue, RabbitMq.parseMsg(msg).content, deadQueueOptions, {
-          ...msg.properties.headers,
-          [RETRY_HEADER]: msg.properties.headers[RETRY_HEADER]
-            ? msg.properties.headers[RETRY_HEADER] + 1
-            : 1,
-        });
-      }
-      debug('rabbit nacking message', { deliveryTag: msg.fields.deliveryTag });
-      await channel.ack(msg);
-    } else {
-      logger.error('no channel or msg', {
-        msg,
-      });
+    if (!channel || !msg) {
+      this.#logger.error('no channel or msg', { msg });
+      return;
     }
+    const currentRetryHeader = Number.parseInt(msg.properties.headers?.[RETRY_HEADER] || '0', 10) || 0;
+    const sendToDeadQueue = skipRetry || currentRetryHeader >= options.retries!;
+    await this.sendToQueue(`${queue}${sendToDeadQueue ? '-dead' : ''}`, RabbitMq.parseMsg(msg).content, sendToDeadQueue ? deadQueueOptions : options, {
+      ...msg.properties.headers,
+      [RETRY_HEADER]: currentRetryHeader + 1,
+    });
+    this.#logger.debug('rabbit nacking message', { deliveryTag: msg.fields.deliveryTag });
+    await channel.ack(msg);
   }
 
-  async getConnection() {
-    return new Promise<AmqpConnectionManager>(async (resolve, reject) => {
-      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()) {
-          debug('rabbit: connection - is connected');
-          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-          // @ts-ignore
-          return resolve(this.connection);
-        }
-        debug('rabbit: connection - reconnecting');
+  async getConnection(connection: ConnectionData): Promise<AmqpConnectionManager> {
+    const {
+      amqpConnection: connectionLocal,
+      creatingConnection,
+      connectionCreatedEventName,
+      connectionFailedEventName,
+      blockReconnect,
+    } = connection;
+
+    if (blockReconnect) {
+      this.#logger.debug('rabbit: block reconnect');
+      // @ts-expect-error we are returning undefined while the function clearly expects a connection.
+      return undefined;
+    }
+
+    if (connectionLocal !== null) {
+      if (this.options?.disableReconnect || connectionLocal?.isConnected()) {
+        this.#logger.debug('rabbit: connection - is connected');
+        return connectionLocal;
       }
-      if (this.creatingConnection) {
-        debug('rabbit: creating connection emi');
-        this.em.once(CONNECTION_CREATED_CONST, resolve);
-        this.em.once(CONNECTION_FAILED_CONST, reject);
-        return;
+      this.#logger.debug('rabbit: connection - reconnecting');
+    }
+    if (creatingConnection) {
+      this.#logger.debug('rabbit: creating connection emi');
+      const [event, value] = await Promise.race([connectionCreatedEventName, connectionFailedEventName].map((e) => once(this.em, e).then(([result]) => [e, result] as const)));
+      if (event === connectionCreatedEventName) {
+        return value;
       }
-      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';
-        const host = this.options?.rabbitHost || process.env.RABBITMQ_SERVICE_HOST || 'localhost';
-
-        debug('rabbit: creating connection', { host, userName, HEARTBEAT });
-        return [`amqp://${userName}:${password}@${host}/${this.options?.vhost}?heartbeat=${HEARTBEAT}`];
-      };
-
-      const defaultUrls = findServers();
-      const connection: AmqpConnectionManager = await connect(defaultUrls, {
-        findServers,
-      });
-
-      this.connection = connection;
-      this.connection.on('error', (err) => {
-        logger.error('rabbit: connection error', { err });
-        if (!isResolved) {
-          isResolved = true;
-          reject(err);
-          this.em.emit(CONNECTION_FAILED_CONST, err);
-        }
-      });
+      throw value;
+    }
+    connection.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';
+      const host = this.options?.rabbitHost || process.env.RABBITMQ_SERVICE_HOST || 'localhost';
+
+      this.#logger.debug('rabbit: creating connection', { host, userName, HEARTBEAT });
+      return [`amqp://${userName}:${password}@${host}/${this.vhost}?heartbeat=${HEARTBEAT}`];
+    };
 
-      this.connection.on('connectFailed', (err) => {
-        this.consumersTags = [];
-        logger.error('rabbit: connection connectFailed', { err, advice: 'Check if the vhost exist', vhost: this.options?.vhost });
-        if (!isResolved) {
-          isResolved = true;
-          reject(err);
-          this.em.emit(CONNECTION_FAILED_CONST, err);
-        }
-      });
+    const defaultUrls = findServers();
+    const newConnection: AmqpConnectionManager = connect(defaultUrls, { findServers });
+    connection.amqpConnection = newConnection;
 
-      this.connection.on('disconnect', ({ err }) => {
-        // this.channel = null;
-        this.consumersTags = [];
-        debug('rabbit: connection closed');
-        if (this.options?.disableReconnect) {
-          logger.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
-          this.blockReconnect = true;
-        } else {
-          logger.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
-        }
-      });
+    const { promise, reject, resolve } = createDeferredPromise<AmqpConnectionManager>();
+    newConnection.on('error', (err) => {
+      this.#logger.error('rabbit: connection error', { err });
+      if (!isResolved) {
+        isResolved = true;
+        reject(err);
+        this.em.emit(connectionFailedEventName, err);
+      }
+    });
 
-      this.connection.once('connect', async () => {
-        debug('rabbit: connection established');
-        this.creatingConnection = false;
-        this.em.emit(CONNECTION_CREATED_CONST, connection);
+    newConnection.on('connectFailed', (err) => {
+      this.consumersTags.clear();
+      if (typeof err.url === 'string') {
+        err.url = this.maskURL(err.url);
+      }
+      this.#logger.error('rabbit: connection connectFailed', { err, advice: 'Check if the vhost exist', vhost: this.vhost });
+      if (!isResolved) {
         isResolved = true;
-        resolve(connection);
-      });
+        reject(err);
+        this.em.emit(connectionFailedEventName, err);
+      }
     });
+
+    newConnection.on('disconnect', ({ err }) => {
+      this.consumersTags.clear();
+      this.#logger.debug('rabbit: connection closed');
+      if (this.options?.disableReconnect) {
+        this.#logger.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
+        connection.blockReconnect = true;
+      } else {
+        this.#logger.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
+      }
+    });
+
+    newConnection.once('connect', async () => {
+      this.#logger.debug('rabbit: connection established');
+      connection.creatingConnection = false;
+      this.em.emit(connectionCreatedEventName, newConnection);
+      isResolved = true;
+      resolve(newConnection);
+    });
+
+    return promise;
   }
 
-  async getNewChannel({ name = rand().toString(), onClose = null, options = {} }: newChannelOpts = {}) {
-    let connection!: AmqpConnectionManager;
+  async getNewChannel({
+    name = rand().toString(),
+    onClose = null,
+    options = {},
+    connection,
+  }: newChannelOpts): Promise<ChannelWrapper> {
+    let localConnection!: AmqpConnectionManager;
     try {
-      connection = await this.getConnection();
+      localConnection = await this.getConnection(connection);
     } catch (e) {
-      logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
+      this.#logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
       throw e;
     }
-    const channel = connection.createChannel({ ...options });
+    const channel = localConnection?.createChannel({ ...options });
     once(channel, 'close').then((args) => {
-      logger.error(`rabbit: channel ${name} closed`);
+      this.#logger.error(`rabbit: channel ${name} closed`);
       onClose?.(args);
     });
     try {
       await once(channel, 'connect');
-      debug(`rabbit: channel ${name} CONNECTED`);
+      this.#logger.debug(`rabbit: channel ${name} CONNECTED`);
       return channel;
     } catch (err) {
-      logger.error(`rabbit: channel error ${name} error`, { err });
+      this.#logger.error(`rabbit: channel error ${name} error`, { err });
       throw err;
     }
   }
 
-  async assertChannel({ force = false } : assertChannelOpts = {}): Promise<ChannelWrapper> {
-    if (!this.publishChannelSetupPromise) {
-      this.publishChannelSetupPromise = new Promise<ChannelWrapper>(async (resolve, reject) => {
-        if (this.channel && !force) {
-          return resolve(this.channel);
-        }
+  async assertChannel({ force = false, connection }: assertChannelOpts): Promise<ChannelWrapper> {
+    if (this.publishChannelSetupPromise) {
+      return this.publishChannelSetupPromise;
+    }
+    const { promise, resolve, reject } = createDeferredPromise<ChannelWrapper>();
+    this.publishChannelSetupPromise = promise;
+    if (this.publishChannel && !force) {
+      resolve(this.publishChannel);
+      return promise;
+    }
 
-        try {
-          const channel = await this.getNewChannel({});
-          channel.on('error', (err) => {
-            logger.error('rabbit: channel error', { err });
-          });
-          this.channel = channel;
-          resolve(channel);
-        } catch (e) {
-          reject(e);
-        }
+    try {
+      const channel = await this.getNewChannel({ connection });
+      channel.on('error', (err) => {
+        this.#logger.error('rabbit: channel error', { err });
       });
+      if (this.publishConnection === connection) {
+        this.publishChannel = channel;
+      }
+      resolve(channel);
+    } catch (e) {
+      reject(e);
     }
-    return this.publishChannelSetupPromise;
+    return promise;
   }
 
-  async assertExchange(exchangeName: string, options?: any) {
-    const channel: ChannelWrapper = await this.assertChannel();
+  async assertExchange(exchangeName: string, connection: ConnectionData): Promise<Replies.AssertExchange> {
+    const channel: ChannelWrapper = await this.assertChannel({ connection });
 
     if (this.exchanges[exchangeName]) {
       delete this.assertExchangePromises[exchangeName];
-      return this.exchanges[exchangeName];
+      return this.exchanges[exchangeName]!;
     }
 
     if (this.assertExchangePromises[exchangeName]) {
-      return this.assertExchangePromises[exchangeName];
+      return this.assertExchangePromises[exchangeName]!;
     }
 
     this.assertExchangePromises[exchangeName] = assertExchangeFanout(channel, exchangeName);
     this.exchanges[exchangeName] = await this.assertExchangePromises[exchangeName];
-    return this.exchanges[exchangeName];
+    return this.exchanges[exchangeName]!;
   }
 
-  async getQueueLength(queue: string) {
+  async getQueueLength(queue: string): Promise<Replies.AssertQueue> {
     RabbitMq.validateName('queue', queue);
-    const { channel } = this;
+    const { publishChannel: channel } = this;
     if (!channel) {
-      throw new Error('channel is not defined');
+      throw new RabbitError('channel is not defined');
     }
-    debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
+    this.#logger.debug('rabbit: getting queue length', { queue, connected: this.publishConnection.amqpConnection?.isConnected() });
     return channel?.checkQueue(queue);
   }
 
-  private async deleteQueue(queue: string) {
+  private async deleteQueue(queue: string, connection: ConnectionData): Promise<Replies.DeleteQueue> {
     RabbitMq.validateName('queue', queue);
-    const channel: ChannelWrapper = await this.assertChannel();
-    logger.info('rabbit: deleting queue', { queue });
+    const channel: ChannelWrapper = await this.assertChannel({ connection });
+    this.#logger.info('rabbit: deleting queue', { queue });
     const deleteQueueRes = await channel.deleteQueue(queue);
-    debug('queue deleted', deleteQueueRes);
+    this.#logger.debug('queue deleted', deleteQueueRes);
     return deleteQueueRes;
   }
 
-  async bindQueue(queue: string, exchange: string) {
-    const channel: ChannelWrapper = await this.assertChannel();
+  async bindQueue(queue: string, exchange: string): Promise<void> {
+    const channel: ChannelWrapper = await this.assertChannel({ connection: this.publishConnection });
     await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.bindQueue(queue, exchange, ''));
     return channel.bindQueue(queue, exchange, '');
   }
 
   async setupQueue(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue> {
     let queue: Replies.AssertQueue;
+    const connection = this.publishConnection;
     const localeOptions = {
       ...options,
       durable: true,
@@ -563,23 +581,23 @@ class RabbitMq implements IAfRabbitMq {
       },
     };
     try {
-      const channel: ChannelWrapper = await this.assertChannel();
-      debug('assertQueue->channel.addSetup', { queueName });
+      const channel: ChannelWrapper = await this.assertChannel({ connection });
+      this.#logger.debug('assertQueue->channel.addSetup', { queueName });
       await channel.addSetup(async (setupChannel: ConfirmChannel) => {
         await setupChannel.assertQueue(queueName, localeOptions);
       });
-      debug('assertQueue->channel.assertQueue', { queueName });
+      this.#logger.debug('assertQueue->channel.assertQueue', { queueName });
       queue = await channel.assertQueue(queueName, localeOptions);
     } catch (e) {
-      logger.error('rabbit: assertQueue error', { queueName, options, error: e });
+      this.#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);
+        this.#logger.debug('retrying assertQueue', { queueName });
+        const channel = await this.assertChannel({ force: true, connection });
+        await this.deleteQueue(queueName, connection);
 
-        debug('retrying assertQueue->channel.addSetup', { queueName });
+        this.#logger.debug('retrying assertQueue->channel.addSetup', { queueName });
         await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, localeOptions));
-        debug('retrying assertQueue->channel.assertQueue', { queueName });
+        this.#logger.debug('retrying assertQueue->channel.assertQueue', { queueName });
         queue = await channel.assertQueue(queueName, localeOptions);
       } else {
         throw e;
@@ -590,7 +608,7 @@ class RabbitMq implements IAfRabbitMq {
     return queue;
   }
 
-  // TODO: Can be deleted after deleting the old consumers
+  // TODO: [QUORUM-PHASE-3] Can be deleted after deleting the old consumers and publishers because all the queues are created us quorum queues
   static shouldUseQuorum(queueName: string): boolean {
     const envQuorumQueuesWhitelist = process.env.QUORUM_QUEUES_WHITELIST;
 
@@ -606,26 +624,22 @@ class RabbitMq implements IAfRabbitMq {
     return false;
   }
 
-  async assertQueue(queueName: string, options?: Options.AssertQueue): Promise<any> {
+  async assertQueue(queueName: string, options?: Options.AssertQueue): Promise<Replies.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];
+      return this.queues[queueName]!;
     }
 
-    this.queueSetupPromises[queueName] = this.setupQueue(queueName, options);
-    return this.queueSetupPromises[queueName];
+    this.queueSetupPromises[queueName] ||= this.setupQueue(queueName, options);
+    return this.queueSetupPromises[queueName]!;
   }
 
-  private saveConsumer(queue: string, callback: CallbackFunction, options: ConsumeOptions | undefined) {
-    const isConsumerExist :boolean = this.consumers.some((consumer) => consumer.queue === queue);
+  private saveConsumer(queue: string, callback: CallbackFunction, options: ConsumeOptions | undefined): void {
+    const isConsumerExist: boolean = this.consumersToRegister.some((consumer) => consumer.queue === queue);
     if (!isConsumerExist) {
-      logger.info(`rabbit: consumer: ${queue} saved in consumer array`);
-      this.consumers.push({
+      this.#logger.info(`rabbit: consumer: ${queue} saved in consumer array`);
+      this.consumersToRegister.push({
         queue,
         callback,
         options,
@@ -634,27 +648,30 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   // Used by the microservices to consume messages from the queue
-  async consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
-    // TODO: USE THE IMPLEMENTATION OF THE NEW CONSUME AND DELETE THE NEW AND OLD
-    if (options?.isQuorumQueue !== false) {
-      await this.assertVHost();
+  async consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void> {
+    this.saveConsumerOld(queue, callback, options);
+
+    // TODO: [QUORUM-PHASE-3] Use only the implementation of consumeNew and delete consumeNew and consumeOld
+    if (options?.isQuorumQueue !== false && DISABLE_QUORUM_QUEUES_CONSUME !== 'true') {
+      this.saveConsumer(queue, callback, options);
+      const backoffConfig = getAssertVhostExponentialBackoffConfig();
+      await backOff(() => this.assertVHost(), backoffConfig);
       await this.consumeNew(queue, callback, options);
     }
-
     await this.consumeOld(queue, callback, options);
   }
 
-  // TODO: DELETE
-  async consumeNew(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
+  // TODO: [QUORUM-PHASE-3] Delete consumeNew we do not use it anymore
+  async consumeNew(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void> {
     await this.consumeFromRabbit(queue, callback, options);
   }
 
-  // TODO: DELETE
-  async consumeOld(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
+  // TODO: [QUORUM-PHASE-3] Delete consumeOld we do not use it anymore
+  async consumeOld(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void> {
     await this.consumeFromRabbitOld(queue, callback, options);
   }
 
-  private async lockRedisIfNeeded(msg: any, options: any) {
+  private async lockRedisIfNeeded(msg: ReturnType<typeof RabbitMq.parseMsg>, options: ConsumeOptions): Promise<(() => Promise<void>) | null> {
     const { properties: { headers } } = msg;
     const timestamp = headers?.creationTimestamp;
     let releaseLock = null;
@@ -668,29 +685,28 @@ class RabbitMq implements IAfRabbitMq {
     return releaseLock;
   }
 
-  private async unlockRedisIfNeeded(releaseLock: any) {
+  private async unlockRedisIfNeeded(releaseLock?: (() => Promise<void>) | null): Promise<void> {
     if (this.redisLock && releaseLock) {
       await releaseLock();
     }
   }
 
-  private async consumeFromRabbit(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
+  private async consumeFromRabbit(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void> {
     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;
     if (useConsumeWithLock) {
       if (!this.redisLock) {
-        throw new Error('Usage of consumeWithLock requires RedisInstance');
+        throw new RabbitError('Usage of consumeWithLock requires RedisInstance');
       }
-      logger.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
+      this.#logger.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
     }
-    const channel = await this.getNewChannel({});
+    const channel = await this.getNewChannel({ connection: this.consumeConnection });
     return channel.addSetup(async (confirmChannel: ConfirmChannel) => {
-      const q = await this.assertQueue(queue, optionsWithDefaults);
+      await this.assertQueue(queue, optionsWithDefaults);
       await confirmChannel.prefetch(limit, false);
       const { consumerTag } = await confirmChannel.consume(
         queue,
@@ -699,9 +715,7 @@ class RabbitMq implements IAfRabbitMq {
             return null;
           }
 
-          const traceId = msg.properties.headers[TRACING_HEADER];
-          const userId = msg.properties.headers[USER_TRACING_HEADER];
-          const automationId = msg.properties.headers[AUTOMATION_ID_HEADER];
+          const { [TRACING_HEADER]: traceId, [USER_TRACING_HEADER]: userId, [AUTOMATION_ID_HEADER]: automationId } = msg.properties.headers ?? {};
           const parsedMessage = RabbitMq.parseMsg(msg);
           const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
           const trace = newTrace(traceTypes.RABBIT);
@@ -716,13 +730,13 @@ class RabbitMq implements IAfRabbitMq {
                 createOrSetRabbitTrace(outbreakTrace, userId),
               ]);
             } catch (e) {
-              logger.error('rabbit: failed to setRabbitTrace', { userId, e });
+              this.#logger.error('rabbit: failed to setRabbitTrace', { userId, e });
               return this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
             }
           }
 
           if (traceId) {
-            (trace as any)?.context?.set(TRACING_HEADER, traceId);
+            trace?.context?.set(TRACING_HEADER, traceId);
             (outbreakTrace as any)?.context.set(TRACING_HEADER, traceId);
           }
 
@@ -746,48 +760,53 @@ class RabbitMq implements IAfRabbitMq {
               return;
             }
             messageAcked = true;
-            return this.ack(confirmChannel, msg, true, releaseLock)(msg);
+            await 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 });
+            this.#logger.debug('rabbit localNack', { messageAcked, uniqueId, deliveryTag: msg.fields.deliveryTag });
             messageAcked = true;
-            return this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg, nackOptions);
+            await this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg, nackOptions);
           };
 
           try {
-            await callback(
+            return await callback(
               parsedMessage,
               localAck,
               localNack,
             );
           } catch (e) {
-            await localNack(msg);
+            return localNack(msg);
           }
         }, CONSUMER_DEFAULT_OPTIONS,
       );
       if (!consumerTag) {
-        logger.error(`rabbit: failed to consume from queue ${queue}`);
+        this.#logger.error(`rabbit: failed to consume from queue ${queue}`);
       } else {
-        logger.info(`rabbit: adding tag ${consumerTag} to the array.`);
-        this.consumersTags.push([confirmChannel, consumerTag]);
+        this.#logger.info(`rabbit: adding tag ${consumerTag} to the array.`);
+        this.consumersTags.set(queue, { channel: confirmChannel, consumerTag });
       }
     });
   }
 
   // Used by the microservices to consume messages from the exchange
-  async consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions) : Promise<any> {
+  async consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions) : Promise<void> {
     const optionsWithDefaults = { ...DEFAULT_OPTIONS, ...options };
     RabbitMq.validateName('exchange', exchange);
     RabbitMq.validateName('queue', queue);
-    const { limit, deadMessageTtl } = optionsWithDefaults;
-    if (options?.isQuorumQueue !== false) {
-      await this.assertVHost();
+    const { limit } = optionsWithDefaults;
+    // TODO: [QUORUM-PHASE-3] Delete the if statement after all the queues are created as quorum queues
+    if (options?.isQuorumQueue !== false && DISABLE_QUORUM_QUEUES_CONSUME !== 'true') {
       await this.saveConsumer(queue, callback, options);
-      const channel: ChannelWrapper = await this.getNewChannel({ name: `consume-exchange-${exchange}-queue-${queue}` });
+      const backoffConfig = getAssertVhostExponentialBackoffConfig();
+      await backOff(() => this.assertVHost(), backoffConfig);
+      const channel: ChannelWrapper = await this.getNewChannel({
+        name: `consume-exchange-${exchange}-queue-${queue}`,
+        connection: this.consumeConnection,
+      });
 
       await channel.addSetup(async (c: ConfirmChannel) => {
         const assertExchange = await assertExchangeFanout(c, exchange);
@@ -804,10 +823,12 @@ class RabbitMq implements IAfRabbitMq {
         ]);
       });
     }
-
-    // TODO: DELETE OLD
+    // TODO: [QUORUM-PHASE-3] Delete the old implementation
     await this.saveConsumerOld(queue, callback, options);
-    const channelOld: ChannelWrapper = await this.getNewChannelOld({ name: `consume-exchange-${exchange}-queue-${queue}-old` });
+    const channelOld: ChannelWrapper = await this.getNewChannelOld({
+      name: `consume-exchange-${exchange}-queue-${queue}-old`,
+      connection: this.oldConsumeConnection,
+    });
     await channelOld.addSetup(async (c: ConfirmChannel) => {
       const assertExchange = await assertExchangeFanout(c, exchange);
       await c.assertQueue(queue);
@@ -825,46 +846,40 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   // Used by the microservices to publish messages to the exchange
-  async publish(exchange: string, content: any, customHeaders?: any, isQuorumQueue = true) : Promise<boolean> {
-    // TODO: DELETE THE IF
-    if (isQuorumQueue) {
-      return wrapSetImmediate(async () => {
-        await this.assertVHost();
-        RabbitMq.validateName('exchange', exchange);
-        const channel: ChannelWrapper = await this.assertChannel();
-        await this.assertExchange(exchange);
-        await channel.publish(exchange, '',
-          Buffer.from(JSON.stringify(content)),
-          RabbitMq.getPublishOptions(customHeaders));
-      });
+  // TODO: [QUORUM-PHASE-3] isQuorumQueue flag is not needed anymore because all the queues are created as quorum queues
+  async publish(exchange: string, content: any, customHeaders?: PublishOptions['headers'], isQuorumQueue = true): Promise<void> {
+    await setImmediate();
+    if (isQuorumQueue && DISABLE_QUORUM_QUEUES_PUBLISH !== 'true') {
+      await this.assertVHost();
+      RabbitMq.validateName('exchange', exchange);
+      const channel: ChannelWrapper = await this.assertChannel({ connection: this.publishConnection });
+      await this.assertExchange(exchange, this.publishConnection);
+      await channel.publish(exchange, '', Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
+      return;
     }
 
-    // TODO: DELETE THE OLD
-    return wrapSetImmediate(async () => {
-      RabbitMq.validateName('exchange', exchange);
-      const channel: ChannelWrapper = await this.assertChannelOld();
-      await this.assertExchangeOld(exchange);
-      await channel.publish(exchange, '',
-        Buffer.from(JSON.stringify(content)),
-        RabbitMq.getPublishOptions(customHeaders));
-    });
+    // TODO: [QUORUM-PHASE-3] Delete the old implementation
+    RabbitMq.validateName('exchange', exchange);
+    const channel: ChannelWrapper = await this.assertChannelOld({ connection: this.oldPublishConnection });
+    await this.assertExchangeOld(exchange, this.oldPublishConnection);
+    await channel.publish(exchange, '', Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
   }
 
   // Used by the microservices to send messages to the queue
+  // TODO: [QUORUM-PHASE-3] isQuorumQueue flag is not needed anymore because all the queues are created as quorum queues
   async sendToQueue(
     queue: string,
     content: any,
-    options?: any,
-    customHeaders?: any,
+    options?: Options.AssertQueue,
+    customHeaders?: PublishOptions['headers'],
     isQuorumQueue = true,
   ): Promise<boolean | undefined> {
-    // TODO: DELETE THE IF AND THE OLD
-    if (isQuorumQueue) {
+    if (isQuorumQueue && DISABLE_QUORUM_QUEUES_PUBLISH !== 'true') {
       try {
         await this.assertVHost();
-        await this.assertChannel();
+        await this.assertChannel({ connection: this.publishConnection });
       } catch (e) {
-        logger.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
+        this.#logger.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
         throw e;
       }
 
@@ -872,107 +887,132 @@ class RabbitMq implements IAfRabbitMq {
         RabbitMq.validateName('queue', queue);
         await this.assertQueue(queue, options);
       } catch (e) {
-        logger.error(`rabbit sendToQueue: failed to assert queue ${queue}`, { e });
+        this.#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 });
+        const res = await this.publishChannel?.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
+        this.#logger.debug(`rabbit: sending to queue ${queue}`, { res });
         return res;
       } catch (e) {
         const isConnected = await this.isConnected();
-        logger.error(`rabbit sendToQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
+        this.#logger.error(`rabbit sendToQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
         throw e;
       }
     } else {
       try {
-        await this.assertChannelOld();
+        await this.assertChannelOld({ connection: this.oldPublishConnection });
       } catch (e) {
-        logger.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
+        this.#logger.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
         throw e;
       }
-    }
 
-    try {
-      RabbitMq.validateName('queue', queue);
-      await this.assertQueueOld(queue, options);
-    } catch (e) {
-      logger.error(`rabbit sendToQueue: failed to assert queue ${queue}`, { e });
-      throw e;
-    }
+      try {
+        RabbitMq.validateName('queue', queue);
+        await this.assertQueueOld(queue, options);
+      } catch (e) {
+        this.#logger.error(`rabbit sendToQueue: failed to assert queue ${queue}`, { e });
+        throw e;
+      }
 
-    try {
-      const res = await this.oldChannel?.sendToQueue(queue,
-        Buffer.from(JSON.stringify(content)),
-        RabbitMq.getPublishOptions(customHeaders));
-      debug(`rabbit: sending to queue ${queue}`, { res });
-      return res;
-    } catch (e) {
-      const isConnected = await this.isConnected();
-      logger.error(`rabbit sendToQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
-      throw e;
+      try {
+        const res = await this.oldPublishChannel?.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
+        this.#logger.debug(`rabbit: sending to queue ${queue}`, { res });
+        return res;
+      } catch (e) {
+        const isConnected = await this.isConnectedOld();
+        this.#logger.error(`rabbit sendToQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
+        throw e;
+      }
     }
   }
 
-  async isConnected() : Promise<boolean> {
-    const connection = await this.getConnection();
-    const isConnected = connection.isConnected();
-    if (!isConnected) {
-      logger.error('rabbit: isConnected - false');
-      return false;
-    }
-    const channel: any = await this.assertChannel();
-    try {
-      await Promise.all([
-        channel.waitForConnect(),
-        ...this.consumers.map((c: AfConsumer) => channel.checkQueue(c.queue)),
-      ]);
-    } catch (e) {
-      logger.error('rabbit: isConnected - false');
-      return false;
+  async isConnected(): Promise<boolean> {
+    let isConnected = true;
+    // TODO:[QUORUM-PHASE-3] Remove the condition
+    if (!this.gracefulShutdownStarted) {
+      if (DISABLE_QUORUM_QUEUES_CONSUME !== 'true' || DISABLE_QUORUM_QUEUES_PUBLISH !== 'true') {
+        this.#logger.debug('rabbit: start is connected');
+        const [consumeConnection, publishConnection] = await Promise.all([
+          this.getConnection(this.consumeConnection),
+          this.getConnection(this.publishConnection),
+        ]);
+        isConnected = consumeConnection.isConnected() && publishConnection.isConnected();
+        if (!isConnected) {
+          this.#logger.error('rabbit: isConnected - false');
+          return false;
+        }
+        try {
+          const unRegisteredConsumers = this.consumersToRegister.filter((c) => !this.consumersTags.get(c.queue));
+
+          if (unRegisteredConsumers.length > 0) {
+            const queueNames = unRegisteredConsumers.map((c) => c.queue);
+
+            this.#logger.error('rabbit: found unregistered consumers for queues', {
+              count: queueNames.length,
+              queues: queueNames,
+            });
+            throw new RabbitError('Found unregistered consumers');
+          }
+          const channel: ChannelWrapper = await this.assertChannel({ connection: this.publishConnection });
+          await channel.waitForConnect();
+
+          await Promise.all(
+            this.consumersToRegister.map((c) => channel.checkQueue(c.queue)),
+          );
+        } catch (e: RabbitError | any) {
+          this.#logger.error('rabbit: isConnected - false', { msg: e.message });
+          return false;
+        }
+      }
+      // TODO:[QUORUM-PHASE-3] Delete the old is connected and adjust the return value to return true
+      isConnected = await this.isConnectedOld();
     }
-    logger.info('rabbit: isConnected - true');
-    return true;
+
+    this.#logger.debug(`rabbit: isConnected - ${isConnected}`);
+    return isConnected;
   }
 
-  async gracefulShutdown(signal: string) : Promise<void> {
-    // TODO: DELETE OLD
-    const tagsNumber = this.consumersTags.length + this.oldConsumersTags.length;
-    logger.info(`rabbit: [gracefully-shutdown] received ${signal}! canceling #${tagsNumber} tags...`);
-    const cancelTagPromises = this.consumersTags.map(([channel, tag]) => channel.cancel(tag));
-    const cancelTagPromisesOld = this.oldConsumersTags.map(([channel, tag]) => channel.cancel(tag));
+  async gracefulShutdown(signal: string): Promise<void> {
+    // TODO: [QUORUM-PHASE-3] Delete the old implementation they are not needed anymore
+    this.gracefulShutdownStarted = true;
+    const tagsNumber = this.consumersTags.size + this.oldConsumersTags.size;
+    this.#logger.info(`rabbit: [gracefully-shutdown] received ${signal}! canceling #${tagsNumber} tags...`);
+    const cancelTagPromises = [...this.consumersTags].map(
+      ([, { channel, consumerTag }]) => channel.cancel(consumerTag),
+    );
+    const cancelTagPromisesOld = [...this.oldConsumersTags].map(
+      ([, { channel, consumerTag }]) => channel.cancel(consumerTag),
+    );
     // Clean the array to avoid race
-    this.consumersTags = [];
-    this.oldConsumersTags = [];
+    this.consumersTags.clear();
+    this.oldConsumersTags.clear();
     const results = await Promise.allSettled([...cancelTagPromises, ...cancelTagPromisesOld]);
     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}`);
+      this.#logger.warn(`rabbit: [gracefully-shutdown] #${rejected.length}/${tagsNumber} tags failed to cancel: ${rejected}`);
     } else {
-      logger.info('rabbit: [gracefully-shutdown] all tags successfully canceled.');
+      this.#logger.info('rabbit: [gracefully-shutdown] all tags successfully canceled.');
     }
   }
 
-  private async consumeFromRabbitOld(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
+  private async consumeFromRabbitOld(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void> {
     const optionsWithDefaults = { ...DEFAULT_OPTIONS, ...options };
     RabbitMq.validateName('queue', queue);
-    this.saveConsumerOld(queue, callback, options);
     const uniqueId = randomUUID();
     const {
       limit, deadMessageTtl, useConsumeWithLock, lockTimeout, auditContext, enableRabbitTrace,
     } = optionsWithDefaults;
     if (useConsumeWithLock) {
       if (!this.redisLock) {
-        throw new Error('Usage of consumeWithLock requires RedisInstance');
+        throw new RabbitError('Usage of consumeWithLock requires RedisInstance');
       }
-      logger.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
+      this.#logger.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
     }
-    const channel = await this.getNewChannelOld({});
+    const channel = await this.getNewChannelOld({ connection: this.oldConsumeConnection });
     return channel.addSetup(async (confirmChannel: ConfirmChannel) => {
-      const q = await this.assertQueueOld(queue, optionsWithDefaults);
+      await this.assertQueueOld(queue, optionsWithDefaults);
       await confirmChannel.prefetch(limit, false);
       const { consumerTag } = await confirmChannel.consume(
         queue,
@@ -981,9 +1021,7 @@ class RabbitMq implements IAfRabbitMq {
             return null;
           }
 
-          const traceId = msg.properties.headers[TRACING_HEADER];
-          const userId = msg.properties.headers[USER_TRACING_HEADER];
-          const automationId = msg.properties.headers[AUTOMATION_ID_HEADER];
+          const { [TRACING_HEADER]: traceId, [USER_TRACING_HEADER]: userId, [AUTOMATION_ID_HEADER]: automationId } = msg.properties.headers ?? {};
           const parsedMessage = RabbitMq.parseMsg(msg);
           const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
           const trace = newTrace(traceTypes.RABBIT);
@@ -998,13 +1036,13 @@ class RabbitMq implements IAfRabbitMq {
                 createOrSetRabbitTrace(outbreakTrace, userId),
               ]);
             } catch (e) {
-              logger.error('rabbit: failed to setRabbitTrace', { userId, e });
+              this.#logger.error('rabbit: failed to setRabbitTrace', { userId, e });
               return this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
             }
           }
 
           if (traceId) {
-            (trace as any)?.context?.set(TRACING_HEADER, traceId);
+            trace?.context?.set(TRACING_HEADER, traceId);
             (outbreakTrace as any)?.context.set(TRACING_HEADER, traceId);
           }
 
@@ -1028,152 +1066,173 @@ class RabbitMq implements IAfRabbitMq {
               return;
             }
             messageAcked = true;
-            return this.ack(confirmChannel, msg, true, releaseLock)(msg);
+            await 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 });
+            this.#logger.debug('rabbit localNack', { messageAcked, uniqueId, deliveryTag: msg.fields.deliveryTag });
             messageAcked = true;
-            return this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg, nackOptions);
+            await this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg, nackOptions);
           };
 
           try {
-            await callback(
+            return await callback(
               parsedMessage,
               localAck,
               localNack,
             );
           } catch (e) {
-            await localNack(msg);
+            return localNack(msg);
           }
         }, CONSUMER_DEFAULT_OPTIONS,
       );
       if (!consumerTag) {
-        logger.error(`rabbit: failed to consume from queue ${queue}`);
+        this.#logger.error(`rabbit: failed to consume from queue ${queue} old`);
       } else {
-        logger.info(`rabbit: adding tag ${consumerTag} to the array.`);
-        this.oldConsumersTags.push([confirmChannel, consumerTag]);
+        this.#logger.info(`rabbit: adding tag ${consumerTag} to the array old`);
+        this.oldConsumersTags.set(queue, { channel: confirmChannel, consumerTag });
       }
     });
   }
 
-  // TODO: DELETE OLD PROPERTIES UNDER THIS LINE
-  async getNewChannelOld({ name = rand().toString(), onClose = null, options = {} }: newChannelOpts = {}) {
-    let connection!: AmqpConnectionManager;
+  // TODO: [QUORUM-PHASE-3] Delete all the function under this line.
+  async getNewChannelOld({
+    name = rand().toString(),
+    onClose = null,
+    options = {},
+    connection,
+  }: newChannelOpts): Promise<ChannelWrapper> {
+    let localConnection!: AmqpConnectionManager;
     try {
-      connection = await this.getConnectionOld();
+      localConnection = await this.getConnectionOld(connection);
     } catch (e) {
-      logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
+      this.#logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
       throw e;
     }
-    const channel = connection.createChannel({ ...options });
+
+    if (!localConnection) {
+      throw new Error(`rabbit: couldnt get connection for new channel ${name}`);
+    }
+
+    const channel = localConnection?.createChannel({ ...options });
     once(channel, 'close').then((args) => {
-      logger.error(`rabbit: channel ${name} closed`);
+      this.#logger.error(`rabbit: channel ${name} closed`);
       onClose?.(args);
     });
     try {
       await once(channel, 'connect');
-      debug(`rabbit: channel ${name} CONNECTED`);
+      this.#logger.debug(`rabbit: channel ${name} CONNECTED`);
       return channel;
     } catch (err) {
-      logger.error(`rabbit: channel error ${name} error`, { err });
+      this.#logger.error(`rabbit: channel error ${name} error`, { err });
       throw err;
     }
   }
 
-  async getConnectionOld() {
-    return new Promise<AmqpConnectionManager>(async (resolve, reject) => {
-      if (this.oldBlockReconnect) {
-        debug('rabbit: block reconnect');
+  async getConnectionOld(connection: ConnectionData): Promise<AmqpConnectionManager> {
+    const {
+      amqpConnection: connectionLocal,
+      creatingConnection,
+      connectionCreatedEventName,
+      connectionFailedEventName,
+      blockReconnect,
+    } = connection;
+
+    if (blockReconnect) {
+      this.#logger.debug('rabbit: block reconnect');
+      // @ts-expect-error we are returning undefined while the function clearly expects a connection.
+      return undefined;
+    }
+    if (connectionLocal !== null) {
+      if (this.options?.disableReconnect || connectionLocal?.isConnected()) {
+        this.#logger.debug('rabbit: connection - is connected');
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore
-        return resolve();
+        return connectionLocal;
       }
-      if (this.oldConnection !== null) {
-        if (this.options?.disableReconnect || this.oldConnection?.isConnected()) {
-          debug('rabbit: connection - is connected');
-          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-          // @ts-ignore
-          return resolve(this.oldConnection);
-        }
-        debug('rabbit: connection - reconnecting');
-      }
-      if (this.oldCreatingConnection) {
-        debug('rabbit: creating connection emi');
-        this.oldEm.once(CONNECTION_CREATED_CONST, resolve);
-        this.oldEm.once(CONNECTION_FAILED_CONST, reject);
-        return;
+      this.#logger.debug('rabbit: connection - reconnecting');
+    }
+    if (creatingConnection) {
+      const [event, value] = await Promise.race([connectionCreatedEventName, connectionFailedEventName].map((e) => once(this.oldEm, e).then(([result]) => [e, result] as const)));
+      if (event === connectionCreatedEventName) {
+        return value;
       }
-      this.oldCreatingConnection = 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';
-        const host = this.options?.rabbitHost || process.env.RABBITMQ_SERVICE_HOST || 'localhost';
+      throw value;
+    }
+    connection.creatingConnection = true;
+    let isResolved = false;
 
-        debug('rabbit: creating connection', { host, userName, HEARTBEAT });
+    // 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';
 
-        return [`amqp://${userName}:${password}@${host}?heartbeat=${HEARTBEAT}`];
-      };
+      this.#logger.debug('rabbit: creating connection', { host, userName, HEARTBEAT });
 
-      const defaultUrls = findServers();
-      const connection: AmqpConnectionManager = await connect(defaultUrls, {
-        findServers,
-      });
+      return [`amqp://${userName}:${password}@${host}?heartbeat=${HEARTBEAT}`];
+    };
 
-      this.oldConnection = connection;
-      this.oldConnection.on('error', (err) => {
-        logger.error('rabbit: connection error', { err });
-        if (!isResolved) {
-          isResolved = true;
-          reject(err);
-          this.oldEm.emit(CONNECTION_FAILED_CONST, err);
-        }
-      });
+    const defaultUrls = findServers();
+    const newConnection: AmqpConnectionManager = await connect(defaultUrls, { findServers });
 
-      this.oldConnection.on('connectFailed', (err) => {
-        this.oldConsumersTags = [];
-        logger.error('rabbit: connection connectFailed', { err });
-        if (!isResolved) {
-          isResolved = true;
-          reject(err);
-          this.oldEm.emit(CONNECTION_FAILED_CONST, err);
-        }
-      });
+    connection.amqpConnection = newConnection;
+    const { promise, reject, resolve } = createDeferredPromise<AmqpConnectionManager>();
 
-      this.oldConnection.on('disconnect', ({ err }) => {
-        this.oldConsumersTags = [];
-        debug('rabbit: connection closed');
-        if (this.options?.disableReconnect) {
-          logger.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
-          this.oldBlockReconnect = true;
-        } else {
-          logger.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
-        }
-      });
+    newConnection.on('error', (err) => {
+      this.#logger.error('rabbit: connection error', { err });
+      if (!isResolved) {
+        isResolved = true;
+        reject(err);
+        this.oldEm.emit(connectionFailedEventName, err);
+      }
+    });
 
-      this.oldConnection.once('connect', async () => {
-        debug('rabbit: connection established');
-        this.oldCreatingConnection = false;
-        this.oldEm.emit(CONNECTION_CREATED_CONST, connection);
+    newConnection.on('connectFailed', (err) => {
+      this.oldConsumersTags.clear();
+      if (typeof err.url === 'string') {
+        err.url = this.maskURL(err.url);
+      }
+      logger.error('rabbit: connection connectFailed', { err });
+      if (!isResolved) {
         isResolved = true;
-        resolve(connection);
-      });
+        reject(err);
+        this.oldEm.emit(connectionFailedEventName, err);
+      }
+    });
+
+    newConnection.on('disconnect', ({ err }) => {
+      this.oldConsumersTags.clear();
+      this.#logger.debug('rabbit: connection closed');
+      if (this.options?.disableReconnect) {
+        logger.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
+        connection.blockReconnect = true;
+      } else {
+        logger.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
+      }
+    });
+
+    newConnection.once('connect', async () => {
+      this.#logger.debug('rabbit: connection established');
+      connection.creatingConnection = false;
+      this.oldEm.emit(connectionCreatedEventName, newConnection);
+      isResolved = true;
+      resolve(newConnection);
     });
+
+    return promise;
   }
 
-  private saveConsumerOld(queue: string, callback: CallbackFunction, options: ConsumeOptions | undefined) {
-    const isConsumerExist :boolean = this.oldConsumers.some((consumer) => consumer.queue === queue);
+  private saveConsumerOld(queue: string, callback: CallbackFunction, options: ConsumeOptions | undefined): void {
+    const isConsumerExist: boolean = this.oldConsumersToRegister.some((consumer) => consumer.queue === queue);
     if (!isConsumerExist) {
       logger.info(`rabbit: consumer: ${queue} saved in consumer array`);
-      this.oldConsumers.push({
+      this.oldConsumersToRegister.push({
         queue,
         callback,
         options,
@@ -1181,23 +1240,20 @@ class RabbitMq implements IAfRabbitMq {
     }
   }
 
-  async assertQueueOld(queueName: string, options?: Options.AssertQueue): Promise<any> {
+  async assertQueueOld(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue> {
     RabbitMq.validateName('queue', queueName);
     if (this.oldQueues[queueName]) {
       delete this.oldQueueSetupPromises[queueName];
-      return this.oldQueues[queueName];
-    }
-
-    if (this.oldQueueSetupPromises[queueName]) {
-      return this.oldQueueSetupPromises[queueName];
+      return this.oldQueues[queueName]!;
     }
 
-    this.oldQueueSetupPromises[queueName] = this.setupQueueOld(queueName, options);
-    return this.oldQueueSetupPromises[queueName];
+    this.oldQueueSetupPromises[queueName] ||= this.setupQueueOld(queueName, options);
+    return this.oldQueueSetupPromises[queueName]!;
   }
 
   async setupQueueOld(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue> {
     let queue: Replies.AssertQueue;
+    const connection = this.oldPublishConnection;
     const shouldUseQuorum = RabbitMq.shouldUseQuorum(queueName);
     const localeOptions = {
       ...options,
@@ -1209,21 +1265,21 @@ class RabbitMq implements IAfRabbitMq {
       },
     };
     try {
-      const channel: ChannelWrapper = await this.assertChannelOld();
-      debug('assertQueue->channel.addSetup', { queueName });
+      const channel: ChannelWrapper = await this.assertChannelOld({ connection });
+      this.#logger.debug('assertQueue->channel.addSetup', { queueName });
       await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, localeOptions));
-      debug('assertQueue->channel.assertQueue', { queueName });
+      this.#logger.debug('assertQueue->channel.assertQueue', { queueName });
       queue = await channel.assertQueue(queueName, localeOptions);
     } catch (e) {
       logger.error('rabbit: assertQueue error', { queueName, options, error: e });
       if (!this.options?.dontRetryAssert) {
-        debug('retrying assertQueue', { queueName });
-        const channel = await this.assertChannelOld({ force: true });
-        await this.deleteQueueOld(queueName);
+        this.#logger.debug('retrying assertQueue', { queueName });
+        const channel = await this.assertChannelOld({ force: true, connection });
+        await this.deleteQueueOld(queueName, connection);
 
-        debug('retrying assertQueue->channel.addSetup', { queueName });
+        this.#logger.debug('retrying assertQueue->channel.addSetup', { queueName });
         await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, localeOptions));
-        debug('retrying assertQueue->channel.assertQueue', { queueName });
+        this.#logger.debug('retrying assertQueue->channel.assertQueue', { queueName });
         queue = await channel.assertQueue(queueName, localeOptions);
       } else {
         throw e;
@@ -1234,52 +1290,107 @@ class RabbitMq implements IAfRabbitMq {
     return queue;
   }
 
-  async assertChannelOld({ force = false } : assertChannelOpts = {}): Promise<ChannelWrapper> {
-    if (!this.oldPublishChannelSetupPromise) {
-      this.oldPublishChannelSetupPromise = new Promise<ChannelWrapper>(async (resolve, reject) => {
-        if (this.oldChannel && !force) {
-          return resolve(this.oldChannel);
-        }
+  async assertChannelOld({ force = false, connection }: assertChannelOpts): Promise<ChannelWrapper> {
+    if (this.oldPublishChannelSetupPromise) {
+      return this.oldPublishChannelSetupPromise;
+    }
+    const { promise, resolve, reject } = createDeferredPromise<ChannelWrapper>();
+    this.oldPublishChannelSetupPromise = promise;
+    if (this.oldPublishChannel && !force) {
+      resolve(this.oldPublishChannel);
+      return promise;
+    }
 
-        try {
-          const channel = await this.getNewChannelOld({});
-          channel.on('error', (err) => {
-            logger.error('rabbit: channel error', { err });
-          });
-          this.oldChannel = channel;
-          resolve(channel);
-        } catch (e) {
-          reject(e);
-        }
+    try {
+      const channel = await this.getNewChannelOld({ connection });
+      channel.on('error', (err) => {
+        logger.error('rabbit: channel error', { err });
       });
+      if (this.oldPublishConnection === connection) {
+        this.oldPublishChannel = channel;
+      }
+      resolve(channel);
+    } catch (e) {
+      reject(e);
     }
-    return this.oldPublishChannelSetupPromise;
+    return promise;
   }
 
-  private async deleteQueueOld(queue: string) {
+  private async deleteQueueOld(queue: string, connection: ConnectionData): Promise<Replies.DeleteQueue> {
     RabbitMq.validateName('queue', queue);
-    const channel: ChannelWrapper = await this.assertChannelOld();
+    const channel: ChannelWrapper = await this.assertChannelOld({ connection });
     logger.info('rabbit: deleting queue', { queue });
     const deleteQueueRes = await channel.deleteQueue(queue);
-    debug('queue deleted', deleteQueueRes);
+    this.#logger.debug('queue deleted', deleteQueueRes);
     return deleteQueueRes;
   }
 
-  async assertExchangeOld(exchangeName: string, options?: any) {
-    const channel: ChannelWrapper = await this.assertChannelOld();
+  async assertExchangeOld(exchangeName: string, connection: ConnectionData): Promise<Replies.AssertExchange> {
+    const channel: ChannelWrapper = await this.assertChannelOld({ connection });
 
     if (this.oldExchanges[exchangeName]) {
       delete this.oldAssertExchangePromises[exchangeName];
-      return this.oldExchanges[exchangeName];
+      return this.oldExchanges[exchangeName]!;
     }
 
     if (this.oldAssertExchangePromises[exchangeName]) {
-      return this.oldAssertExchangePromises[exchangeName];
+      return this.oldAssertExchangePromises[exchangeName]!;
     }
 
     this.oldAssertExchangePromises[exchangeName] = assertExchangeFanout(channel, exchangeName);
     this.oldExchanges[exchangeName] = await this.oldAssertExchangePromises[exchangeName];
-    return this.oldExchanges[exchangeName];
+    return this.oldExchanges[exchangeName]!;
+  }
+
+  async isConnectedOld(): Promise<boolean> {
+    if (!this.gracefulShutdownStarted) {
+      this.#logger.debug('rabbit: start is connected old');
+      const [oldConsumeConnection, oldPublishConnection] = await Promise.all([
+        this.getConnectionOld(this.oldConsumeConnection),
+        this.getConnectionOld(this.oldPublishConnection),
+      ]);
+      const isConnected = oldConsumeConnection.isConnected() && oldPublishConnection.isConnected();
+      if (!isConnected) {
+        logger.error('rabbit: isConnected old - false');
+        return false;
+      }
+
+      try {
+        const unRegisteredConsumersOld = this.consumersToRegister.filter((c) => !this.consumersTags.get(c.queue));
+
+        if (unRegisteredConsumersOld.length > 0) {
+          const queueNames = unRegisteredConsumersOld.map((c) => c.queue);
+
+          logger.error('rabbit: found unregistered consumers for queues old', {
+            count: queueNames.length,
+            queues: queueNames,
+          });
+          throw new RabbitError('Found unregistered consumers old');
+        }
+
+        const channelOld = await this.assertChannelOld({ connection: this.oldPublishConnection });
+        await channelOld.waitForConnect();
+
+        await Promise.all(
+          this.oldConsumersToRegister.map((c: AfConsumer) => channelOld.checkQueue(c.queue)),
+        );
+      } catch (e: RabbitError | any) {
+        logger.error('rabbit: isConnected - false old', { msg: e.message });
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private maskURL = (url: string): string => {
+    try {
+      const urlObj = new URL(url);
+      urlObj.username = '***';
+      urlObj.password = '***';
+      return urlObj.toString();
+    } catch {
+      return url;
+    }
   }
 }