@autofleet/rabbit 4.0.2-beta.8 → 4.1.0-beta.0

package/src/index.ts

@@ -1,4 +1,5 @@
-/* eslint-disable no-empty,consistent-return,no-async-promise-executor,@typescript-eslint/no-unused-vars,no-param-reassign */
+/* 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 moment from 'moment';
@@ -9,19 +10,19 @@ import {
 import {
   ConfirmChannel, ConsumeMessage, Options, Replies,
 } from 'amqplib';
-import { backOff } from 'exponential-backoff';
 import {
   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, getAssertVhostExponentialBackoffConfig, rand, wrapSetImmediate,
-} from './lib/utils';
+import { assertExchangeFanout, rand, wrapSetImmediate } from './lib/utils';
 import {
   AUTOMATION_ID_HEADER,
+  CONNECTION_CREATED_CONST,
+  CONNECTION_FAILED_CONST,
   DEFAULT_LOCK_TIMEOUT,
   DEFAULT_OPTIONS,
   RETRY_HEADER,
@@ -40,7 +41,6 @@ import {
   CONSUMER_DEFAULT_OPTIONS,
   QueueSetupPromisesDictionary,
   AssertExchangePromisesDictionary,
-  ConnectionData,
 } from './lib/types';
 
 // const debug = nodeDebug('af-rabbitmq')
@@ -48,12 +48,6 @@ const debug = logger.debug.bind(logger);
 
 const PUBLISH_TIMEOUT = 1000 * 10;
 
-// TODO: [QUORUM-PHASE-3] Delete this env var
-const {
-  DISABLE_QUORUM_QUEUES_CONSUME,
-  DISABLE_QUORUM_QUEUES_PUBLISH,
-} = process.env;
-
 export interface IAfRabbitMq {
   ack: any;
   nack: any;
@@ -95,13 +89,11 @@ 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 = {
@@ -154,15 +146,13 @@ class RabbitMq implements IAfRabbitMq {
 
   RECONNECT_MSG = 'rabbit: connection disconnect - reconnecting';
 
-  publishChannel: ChannelWrapper | null;
+  channel: ChannelWrapper | null;
 
   publishChannelSetupPromise: Promise<ChannelWrapper> | null;
 
   blockReconnect: boolean | null | undefined
 
-  publishConnection: ConnectionData
-
-  consumeConnection: ConnectionData
+  connection: AmqpConnectionManager | null | undefined
 
   em: EventEmitter;
 
@@ -176,33 +166,28 @@ class RabbitMq implements IAfRabbitMq {
 
   assertExchangePromises: AssertExchangePromisesDictionary;
 
-  options: AfRabbitOptions;
+  options: AfRabbitOptions | undefined;
 
   redisClient: any;
 
   redisLock?: RedisLockType;
 
   /** Array of consumers tags used for canceling consumption */
-  consumersTags: Map<string, { channel: ConfirmChannel; consumerTag: string }>;
+  consumersTags: Array<[ConfirmChannel, string]>;
 
-  private consumersToRegister: Array<AfConsumer> = [];
+  private consumers: Array<AfConsumer> = [];
 
-  private doesVHostExist = false;
+  private isVHostExist = false;
 
-  private vhost = 'quorum-vhost';
+  // TODO: DELETE OLD PROPERTIES
 
-  private gracefulShutdownStarted = false;
-
-  // TODO:[QUORUM-PHASE-3] Delete the old properties that we use for the old consumers and publishers
-  oldPublishChannel: ChannelWrapper | null;
+  oldChannel: ChannelWrapper | null;
 
   oldPublishChannelSetupPromise: Promise<ChannelWrapper> | null;
 
   oldBlockReconnect: boolean | null | undefined
 
-  oldPublishConnection: ConnectionData
-
-  oldConsumeConnection: ConnectionData
+  oldConnection: AmqpConnectionManager | null | undefined
 
   oldEm: EventEmitter;
 
@@ -216,41 +201,32 @@ class RabbitMq implements IAfRabbitMq {
 
   oldAssertExchangePromises: AssertExchangePromisesDictionary;
 
-  oldConsumersTags: Map<string, { channel: ConfirmChannel; consumerTag: string }>;
+  oldConsumersTags: Array<[ConfirmChannel, string]>;
 
-  private oldConsumersToRegister: Array<AfConsumer> = [];
+  private oldConsumers: Array<AfConsumer> = [];
 
   constructor(options: AfRabbitOptions = {}, redisConfig?: RedisConfig) {
     this.em = new EventEmitter();
-    this.publishChannel = null;
+    this.channel = null;
     this.publishChannelSetupPromise = null;
-    this.publishConnection = {
-      amqpConnection: null,
-      creatingConnection: false,
-      connectionCreatedEventName: 'publishConnectionCreated',
-      connectionFailedEventName: 'publishConnectionFailed',
-      blockReconnect: false,
-    };
-    this.consumeConnection = {
-      amqpConnection: null,
-      creatingConnection: false,
-      connectionCreatedEventName: 'consumeConnectionCreated',
-      connectionFailedEventName: 'consumeConnectionFailed',
-      blockReconnect: false,
-    };
+    this.connection = null;
     this.creatingConnection = false;
     this.exchanges = {};
     this.queues = {};
     this.queueSetupPromises = {};
     this.assertExchangePromises = {};
-    this.consumersToRegister = [];
+    this.consumers = [];
     this.options = options;
 
+    if (!options?.vhost) {
+      this.options.vhost = process.env.VHOST_NAME || 'quorum-vhost';
+    }
+
     this.redisClient = redisConfig && getRedisInstance(redisConfig);
     if (this.redisClient) {
       this.redisLock = promisify(RedisLock(this.redisClient)) as RedisLockType;
     }
-    this.consumersTags = new Map<string, { channel: ConfirmChannel; consumerTag: string }>();
+    this.consumersTags = [];
     logger.info(`rabbit: [gracefully-shutdown] adding gracefully shutdown for process.pid ${process.pid}`);
     if (!this.options?.dontGracefulShutdown) {
       process.on('SIGTERM', async () => {
@@ -261,85 +237,72 @@ class RabbitMq implements IAfRabbitMq {
       });
     }
 
-    // TODO: [QUORUM-PHASE-3] Delete the old properties that we use for the old consumers and publishers
+    // TODO: DELETE OLD PROPERTIES
     this.oldEm = new EventEmitter();
-    this.oldPublishChannel = null;
+    this.oldChannel = null;
     this.oldPublishChannelSetupPromise = null;
-    this.oldPublishConnection = {
-      amqpConnection: null,
-      creatingConnection: false,
-      connectionCreatedEventName: 'oldPublishConnectionCreated',
-      connectionFailedEventName: 'oldPublishConnectionFailed',
-      blockReconnect: false,
-    };
-    this.oldConsumeConnection = {
-      amqpConnection: null,
-      creatingConnection: false,
-      connectionCreatedEventName: 'oldConsumeConnectionCreated',
-      connectionFailedEventName: 'oldConsumeConnectionFailed',
-      blockReconnect: false,
-    };
+    this.oldConnection = null;
     this.oldCreatingConnection = false;
     this.oldExchanges = {};
     this.oldQueues = {};
     this.oldQueueSetupPromises = {};
     this.oldAssertExchangePromises = {};
-    this.oldConsumersToRegister = [];
-    this.oldConsumersTags = new Map<string, { channel: ConfirmChannel; consumerTag: string }>();
+    this.oldConsumers = [];
+    this.oldConsumersTags = [];
   }
 
   private assertVHost = async () => {
-    if (this.doesVHostExist) {
+    if (this.isVHostExist) {
       return;
     }
 
-    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`;
+    if (!this.options?.vhost) {
+      throw new Error('vhost is not defined');
+    }
 
-    const url = `${rabbitHost}/api/vhosts/${encodeURIComponent(this.vhost)}`;
+    const { vhost } = this.options;
+    const auth = {
+      auth: {
+        username: process.env.RABBITMQ_USERNAME || 'guest',
+        password: process.env.RABBITMQ_PASSWORD || 'guest',
+      },
+    };
+    const rabbitHost = `http://${(this.options.rabbitHost || process.env.RABBITMQ_SERVICE_HOST || 'localhost').split(':')[0]}:15672`;
 
     try {
-      const response = await fetch(url, {
-        method: 'GET',
-        headers,
-      });
-
-      if (response.status === 200) {
-        this.doesVHostExist = true;
-        logger.info('Vhost exists', { vhost: this.vhost });
-        return;
-      }
+      const response = await axios.get(`${rabbitHost}/api/vhosts/${encodeURIComponent(vhost)}`, auth);
 
-      if (response.status !== 404) {
-        logger.error('Failed to check vhost', { response });
-        throw new RabbitError('Failed to check vhost');
+      if (response.status !== 200) {
+        throw new Error('Failed to check vhost');
       }
 
-      const createResponse = await fetch(url, {
-        method: 'PUT',
-        headers,
-        body: JSON.stringify({ default_queue_type: 'quorum' }),
-      });
+      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 (!createResponse.ok) {
-        logger.error('Failed to create vhost', { response: createResponse });
-        throw new RabbitError('Failed to create 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;
+        }
       }
 
-      this.doesVHostExist = true;
-      logger.info('Vhost created', { vhost: this.vhost });
-    } catch (error) {
-      logger.error('Failed to check or create vhost', { error });
+      logger.error('Failed to check vhost', { error });
       throw error;
     }
-  };
+  }
 
   private shouldConsumeMessageByTimestamp = async (msg: ConsumeMessageOrNull) => {
     if (msg) {
@@ -388,13 +351,13 @@ class RabbitMq implements IAfRabbitMq {
       if (
         !skipRetry
         && (
-          !msg.properties.headers?.[RETRY_HEADER]
+          !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]
+          [RETRY_HEADER]: msg.properties.headers[RETRY_HEADER]
             ? msg.properties.headers[RETRY_HEADER] + 1
             : 1,
         });
@@ -402,7 +365,7 @@ class RabbitMq implements IAfRabbitMq {
         const deadQueue = `${queue}-dead`;
         await this.sendToQueue(deadQueue, RabbitMq.parseMsg(msg).content, deadQueueOptions, {
           ...msg.properties.headers,
-          [RETRY_HEADER]: msg.properties.headers?.[RETRY_HEADER]
+          [RETRY_HEADER]: msg.properties.headers[RETRY_HEADER]
             ? msg.properties.headers[RETRY_HEADER] + 1
             : 1,
         });
@@ -416,38 +379,30 @@ class RabbitMq implements IAfRabbitMq {
     }
   }
 
-  async getConnection(connection: ConnectionData) {
+  async getConnection() {
     return new Promise<AmqpConnectionManager>(async (resolve, reject) => {
-      const {
-        amqpConnection: connectionLocal,
-        creatingConnection,
-        connectionCreatedEventName,
-        connectionFailedEventName,
-        blockReconnect,
-      } = connection;
-
-      if (blockReconnect) {
+      if (this.blockReconnect) {
         debug('rabbit: block reconnect');
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore
         return resolve();
       }
-      if (connectionLocal !== null) {
-        if (this.options?.disableReconnect || connectionLocal?.isConnected()) {
+      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(connectionLocal);
+          return resolve(this.connection);
         }
         debug('rabbit: connection - reconnecting');
       }
-      if (creatingConnection) {
+      if (this.creatingConnection) {
         debug('rabbit: creating connection emi');
-        this.em.once(connectionCreatedEventName, resolve);
-        this.em.once(connectionFailedEventName, reject);
+        this.em.once(CONNECTION_CREATED_CONST, resolve);
+        this.em.once(CONNECTION_FAILED_CONST, reject);
         return;
       }
-      connection.creatingConnection = true;
+      this.creatingConnection = true;
       let isResolved = false;
 
       // It is import to use it as a function and not as a variable
@@ -459,72 +414,65 @@ class RabbitMq implements IAfRabbitMq {
         const host = this.options?.rabbitHost || process.env.RABBITMQ_SERVICE_HOST || 'localhost';
 
         debug('rabbit: creating connection', { host, userName, HEARTBEAT });
-        return [`amqp://${userName}:${password}@${host}/${this.vhost}?heartbeat=${HEARTBEAT}`];
+        return [`amqp://${userName}:${password}@${host}/${this.options?.vhost}?heartbeat=${HEARTBEAT}`];
       };
 
       const defaultUrls = findServers();
-      const newConnection: AmqpConnectionManager = await connect(defaultUrls, {
+      const connection: AmqpConnectionManager = await connect(defaultUrls, {
         findServers,
       });
 
-      connection.amqpConnection = newConnection;
-      newConnection.on('error', (err) => {
+      this.connection = connection;
+      this.connection.on('error', (err) => {
         logger.error('rabbit: connection error', { err });
         if (!isResolved) {
           isResolved = true;
           reject(err);
-          this.em.emit(connectionFailedEventName, err);
+          this.em.emit(CONNECTION_FAILED_CONST, err);
         }
       });
 
-      newConnection.on('connectFailed', (err) => {
-        this.consumersTags.clear();
-        if (typeof err.url === 'string') {
-          err.url = this.maskURL(err.url);
-        }
-        logger.error('rabbit: connection connectFailed', { err, advice: 'Check if the vhost exist', vhost: this.vhost });
+      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(connectionFailedEventName, err);
+          this.em.emit(CONNECTION_FAILED_CONST, err);
         }
       });
 
-      newConnection.on('disconnect', ({ err }) => {
-        this.consumersTags.clear();
+      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}`}`);
-          connection.blockReconnect = true;
+          this.blockReconnect = true;
         } else {
           logger.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
         }
       });
 
-      newConnection.once('connect', async () => {
+      this.connection.once('connect', async () => {
         debug('rabbit: connection established');
-        connection.creatingConnection = false;
-        this.em.emit(connectionCreatedEventName, newConnection);
+        this.creatingConnection = false;
+        this.em.emit(CONNECTION_CREATED_CONST, connection);
         isResolved = true;
-        resolve(newConnection);
+        resolve(connection);
       });
     });
   }
 
-  async getNewChannel({
-    name = rand().toString(),
-    onClose = null,
-    options = {},
-    connection,
-  }: newChannelOpts) {
-    let localConnection!: AmqpConnectionManager;
+  async getNewChannel({ name = rand().toString(), onClose = null, options = {} }: newChannelOpts = {}) {
+    let connection!: AmqpConnectionManager;
     try {
-      localConnection = await this.getConnection(connection);
+      connection = await this.getConnection();
     } catch (e) {
       logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
       throw e;
     }
-    const channel = localConnection?.createChannel({ ...options });
+    const channel = connection.createChannel({ ...options });
     once(channel, 'close').then((args) => {
       logger.error(`rabbit: channel ${name} closed`);
       onClose?.(args);
@@ -539,21 +487,19 @@ class RabbitMq implements IAfRabbitMq {
     }
   }
 
-  async assertChannel({ force = false, connection }: assertChannelOpts): Promise<ChannelWrapper> {
+  async assertChannel({ force = false } : assertChannelOpts = {}): Promise<ChannelWrapper> {
     if (!this.publishChannelSetupPromise) {
       this.publishChannelSetupPromise = new Promise<ChannelWrapper>(async (resolve, reject) => {
-        if (this.publishChannel && !force) {
-          return resolve(this.publishChannel);
+        if (this.channel && !force) {
+          return resolve(this.channel);
         }
 
         try {
-          const channel = await this.getNewChannel({ connection });
+          const channel = await this.getNewChannel({});
           channel.on('error', (err) => {
             logger.error('rabbit: channel error', { err });
           });
-          if (this.publishConnection === connection) {
-            this.publishChannel = channel;
-          }
+          this.channel = channel;
           resolve(channel);
         } catch (e) {
           reject(e);
@@ -563,8 +509,8 @@ class RabbitMq implements IAfRabbitMq {
     return this.publishChannelSetupPromise;
   }
 
-  async assertExchange(exchangeName: string, connection: ConnectionData) {
-    const channel: ChannelWrapper = await this.assertChannel({ connection });
+  async assertExchange(exchangeName: string, options?: any) {
+    const channel: ChannelWrapper = await this.assertChannel();
 
     if (this.exchanges[exchangeName]) {
       delete this.assertExchangePromises[exchangeName];
@@ -582,17 +528,17 @@ class RabbitMq implements IAfRabbitMq {
 
   async getQueueLength(queue: string) {
     RabbitMq.validateName('queue', queue);
-    const { publishChannel: channel } = this;
+    const { channel } = this;
     if (!channel) {
-      throw new RabbitError('channel is not defined');
+      throw new Error('channel is not defined');
     }
-    debug('rabbit: getting queue length', { queue, connected: this.publishConnection.amqpConnection?.isConnected() });
+    debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
     return channel?.checkQueue(queue);
   }
 
-  private async deleteQueue(queue: string, connection: ConnectionData) {
+  private async deleteQueue(queue: string) {
     RabbitMq.validateName('queue', queue);
-    const channel: ChannelWrapper = await this.assertChannel({ connection });
+    const channel: ChannelWrapper = await this.assertChannel();
     logger.info('rabbit: deleting queue', { queue });
     const deleteQueueRes = await channel.deleteQueue(queue);
     debug('queue deleted', deleteQueueRes);
@@ -600,14 +546,13 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   async bindQueue(queue: string, exchange: string) {
-    const channel: ChannelWrapper = await this.assertChannel({ connection: this.publishConnection });
+    const channel: ChannelWrapper = await this.assertChannel();
     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,
@@ -618,7 +563,7 @@ class RabbitMq implements IAfRabbitMq {
       },
     };
     try {
-      const channel: ChannelWrapper = await this.assertChannel({ connection });
+      const channel: ChannelWrapper = await this.assertChannel();
       debug('assertQueue->channel.addSetup', { queueName });
       await channel.addSetup(async (setupChannel: ConfirmChannel) => {
         await setupChannel.assertQueue(queueName, localeOptions);
@@ -629,8 +574,8 @@ 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, connection });
-        await this.deleteQueue(queueName, connection);
+        const channel = await this.assertChannel({ force: true });
+        await this.deleteQueue(queueName);
 
         debug('retrying assertQueue->channel.addSetup', { queueName });
         await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, localeOptions));
@@ -645,7 +590,7 @@ class RabbitMq implements IAfRabbitMq {
     return queue;
   }
 
-  // TODO: [QUORUM-PHASE-3] Can be deleted after deleting the old consumers and publishers because all the queues are created us quorum queues
+  // TODO: Can be deleted after deleting the old consumers
   static shouldUseQuorum(queueName: string): boolean {
     const envQuorumQueuesWhitelist = process.env.QUORUM_QUEUES_WHITELIST;
 
@@ -677,10 +622,10 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   private saveConsumer(queue: string, callback: CallbackFunction, options: ConsumeOptions | undefined) {
-    const isConsumerExist: boolean = this.consumersToRegister.some((consumer) => consumer.queue === queue);
+    const isConsumerExist :boolean = this.consumers.some((consumer) => consumer.queue === queue);
     if (!isConsumerExist) {
       logger.info(`rabbit: consumer: ${queue} saved in consumer array`);
-      this.consumersToRegister.push({
+      this.consumers.push({
         queue,
         callback,
         options,
@@ -690,24 +635,21 @@ class RabbitMq implements IAfRabbitMq {
 
   // Used by the microservices to consume messages from the queue
   async consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
-    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);
+    // TODO: USE THE IMPLEMENTATION OF THE NEW CONSUME AND DELETE THE NEW AND OLD
+    if (options?.isQuorumQueue !== false) {
+      await this.assertVHost();
       await this.consumeNew(queue, callback, options);
     }
+
     await this.consumeOld(queue, callback, options);
   }
 
-  // TODO: [QUORUM-PHASE-3] Delete consumeNew we do not use it anymore
+  // TODO: DELETE
   async consumeNew(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
     await this.consumeFromRabbit(queue, callback, options);
   }
 
-  // TODO: [QUORUM-PHASE-3] Delete consumeOld we do not use it anymore
+  // TODO: DELETE
   async consumeOld(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
     await this.consumeFromRabbitOld(queue, callback, options);
   }
@@ -735,17 +677,18 @@ 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;
     if (useConsumeWithLock) {
       if (!this.redisLock) {
-        throw new RabbitError('Usage of consumeWithLock requires RedisInstance');
+        throw new Error('Usage of consumeWithLock requires RedisInstance');
       }
       logger.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
     }
-    const channel = await this.getNewChannel({ connection: this.consumeConnection });
+    const channel = await this.getNewChannel({});
     return channel.addSetup(async (confirmChannel: ConfirmChannel) => {
       const q = await this.assertQueue(queue, optionsWithDefaults);
       await confirmChannel.prefetch(limit, false);
@@ -756,9 +699,9 @@ 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 traceId = msg.properties.headers[TRACING_HEADER];
+          const userId = msg.properties.headers[USER_TRACING_HEADER];
+          const automationId = msg.properties.headers[AUTOMATION_ID_HEADER];
           const parsedMessage = RabbitMq.parseMsg(msg);
           const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
           const trace = newTrace(traceTypes.RABBIT);
@@ -830,7 +773,7 @@ class RabbitMq implements IAfRabbitMq {
         logger.error(`rabbit: failed to consume from queue ${queue}`);
       } else {
         logger.info(`rabbit: adding tag ${consumerTag} to the array.`);
-        this.consumersTags.set(queue, { channel: confirmChannel, consumerTag });
+        this.consumersTags.push([confirmChannel, consumerTag]);
       }
     });
   }
@@ -841,15 +784,10 @@ class RabbitMq implements IAfRabbitMq {
     RabbitMq.validateName('exchange', exchange);
     RabbitMq.validateName('queue', queue);
     const { limit, deadMessageTtl } = 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') {
+    if (options?.isQuorumQueue !== false) {
+      await this.assertVHost();
       await this.saveConsumer(queue, callback, options);
-      const backoffConfig = getAssertVhostExponentialBackoffConfig();
-      await backOff(() => this.assertVHost(), backoffConfig);
-      const channel: ChannelWrapper = await this.getNewChannel({
-        name: `consume-exchange-${exchange}-queue-${queue}`,
-        connection: this.consumeConnection,
-      });
+      const channel: ChannelWrapper = await this.getNewChannel({ name: `consume-exchange-${exchange}-queue-${queue}` });
 
       await channel.addSetup(async (c: ConfirmChannel) => {
         const assertExchange = await assertExchangeFanout(c, exchange);
@@ -866,12 +804,10 @@ class RabbitMq implements IAfRabbitMq {
         ]);
       });
     }
-    // TODO: [QUORUM-PHASE-3] Delete the old implementation
+
+    // TODO: DELETE OLD
     await this.saveConsumerOld(queue, callback, options);
-    const channelOld: ChannelWrapper = await this.getNewChannelOld({
-      name: `consume-exchange-${exchange}-queue-${queue}-old`,
-      connection: this.oldConsumeConnection,
-    });
+    const channelOld: ChannelWrapper = await this.getNewChannelOld({ name: `consume-exchange-${exchange}-queue-${queue}-old` });
     await channelOld.addSetup(async (c: ConfirmChannel) => {
       const assertExchange = await assertExchangeFanout(c, exchange);
       await c.assertQueue(queue);
@@ -889,25 +825,25 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   // Used by the microservices to publish messages to the exchange
-  // 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?: any, isQuorumQueue = true) : Promise<boolean> {
-    if (isQuorumQueue && DISABLE_QUORUM_QUEUES_PUBLISH !== 'true') {
+    // TODO: DELETE THE IF
+    if (isQuorumQueue) {
       return wrapSetImmediate(async () => {
         await this.assertVHost();
         RabbitMq.validateName('exchange', exchange);
-        const channel: ChannelWrapper = await this.assertChannel({ connection: this.publishConnection });
-        await this.assertExchange(exchange, this.publishConnection);
+        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] Delete the old implementation
+    // TODO: DELETE THE OLD
     return wrapSetImmediate(async () => {
       RabbitMq.validateName('exchange', exchange);
-      const channel: ChannelWrapper = await this.assertChannelOld({ connection: this.oldPublishConnection });
-      await this.assertExchangeOld(exchange, this.oldPublishConnection);
+      const channel: ChannelWrapper = await this.assertChannelOld();
+      await this.assertExchangeOld(exchange);
       await channel.publish(exchange, '',
         Buffer.from(JSON.stringify(content)),
         RabbitMq.getPublishOptions(customHeaders));
@@ -915,7 +851,6 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   // 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,
@@ -923,10 +858,11 @@ class RabbitMq implements IAfRabbitMq {
     customHeaders?: any,
     isQuorumQueue = true,
   ): Promise<boolean | undefined> {
-    if (isQuorumQueue && DISABLE_QUORUM_QUEUES_PUBLISH !== 'true') {
+    // TODO: DELETE THE IF AND THE OLD
+    if (isQuorumQueue) {
       try {
         await this.assertVHost();
-        await this.assertChannel({ connection: this.publishConnection });
+        await this.assertChannel();
       } catch (e) {
         logger.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
         throw e;
@@ -941,7 +877,7 @@ class RabbitMq implements IAfRabbitMq {
       }
 
       try {
-        const res = await this.publishChannel?.sendToQueue(queue,
+        const res = await this.channel?.sendToQueue(queue,
           Buffer.from(JSON.stringify(content)),
           RabbitMq.getPublishOptions(customHeaders));
         debug(`rabbit: sending to queue ${queue}`, { res });
@@ -953,97 +889,64 @@ class RabbitMq implements IAfRabbitMq {
       }
     } else {
       try {
-        await this.assertChannelOld({ connection: this.oldPublishConnection });
+        await this.assertChannelOld();
       } 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.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) {
+      logger.error(`rabbit sendToQueue: failed to assert queue ${queue}`, { e });
+      throw e;
+    }
 
-      try {
-        const res = await this.oldPublishChannel?.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.isConnectedOld();
-        logger.error(`rabbit sendToQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { 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;
     }
   }
 
-  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') {
-        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) {
-          logger.error('rabbit: isConnected - false');
-          return false;
-        }
-        try {
-          const unRegisteredConsumers = this.consumersToRegister.filter((c: AfConsumer) => {
-            const doesConsumerExist = this.consumersTags.get(c.queue);
-            return !doesConsumerExist;
-          });
-
-          if (unRegisteredConsumers.length > 0) {
-            const queueNames = unRegisteredConsumers.map((c) => c.queue);
-
-            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: AfConsumer) => channel.checkQueue(c.queue)),
-          );
-        } catch (e: RabbitError | any) {
-          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();
+  async isConnected() : Promise<boolean> {
+    const connection = await this.getConnection();
+    const isConnected = connection.isConnected();
+    if (!isConnected) {
+      logger.error('rabbit: isConnected - false');
+      return false;
     }
-
-    logger.debug(`rabbit: isConnected - ${isConnected}`);
-    return isConnected;
+    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;
+    }
+    logger.info('rabbit: isConnected - true');
+    return true;
   }
 
   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;
+    // 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, consumerTag }]) => channel.cancel(consumerTag),
-    );
-    const cancelTagPromisesOld = [...this.oldConsumersTags].map(
-      ([_, { channel, consumerTag }]) => channel.cancel(consumerTag),
-    );
+    const cancelTagPromises = this.consumersTags.map(([channel, tag]) => channel.cancel(tag));
+    const cancelTagPromisesOld = this.oldConsumersTags.map(([channel, tag]) => channel.cancel(tag));
     // Clean the array to avoid race
-    this.consumersTags.clear();
-    this.oldConsumersTags.clear();
+    this.consumersTags = [];
+    this.oldConsumersTags = [];
     const results = await Promise.allSettled([...cancelTagPromises, ...cancelTagPromisesOld]);
     const rejected = results.filter((p) => p.status === 'rejected');
     if (rejected.length > 0) {
@@ -1056,17 +959,18 @@ class RabbitMq implements IAfRabbitMq {
   private async consumeFromRabbitOld(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
     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 RabbitError('Usage of consumeWithLock requires RedisInstance');
+        throw new Error('Usage of consumeWithLock requires RedisInstance');
       }
       logger.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
     }
-    const channel = await this.getNewChannelOld({ connection: this.oldConsumeConnection });
+    const channel = await this.getNewChannelOld({});
     return channel.addSetup(async (confirmChannel: ConfirmChannel) => {
       const q = await this.assertQueueOld(queue, optionsWithDefaults);
       await confirmChannel.prefetch(limit, false);
@@ -1077,9 +981,9 @@ 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 traceId = msg.properties.headers[TRACING_HEADER];
+          const userId = msg.properties.headers[USER_TRACING_HEADER];
+          const automationId = msg.properties.headers[AUTOMATION_ID_HEADER];
           const parsedMessage = RabbitMq.parseMsg(msg);
           const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
           const trace = newTrace(traceTypes.RABBIT);
@@ -1148,34 +1052,24 @@ class RabbitMq implements IAfRabbitMq {
         }, CONSUMER_DEFAULT_OPTIONS,
       );
       if (!consumerTag) {
-        logger.error(`rabbit: failed to consume from queue ${queue} old`);
+        logger.error(`rabbit: failed to consume from queue ${queue}`);
       } else {
-        logger.info(`rabbit: adding tag ${consumerTag} to the array old`);
-        this.oldConsumersTags.set(queue, { channel: confirmChannel, consumerTag });
+        logger.info(`rabbit: adding tag ${consumerTag} to the array.`);
+        this.oldConsumersTags.push([confirmChannel, consumerTag]);
       }
     });
   }
 
-  // TODO: [QUORUM-PHASE-3] Delete all the function under this line.
-  async getNewChannelOld({
-    name = rand().toString(),
-    onClose = null,
-    options = {},
-    connection,
-  }: newChannelOpts) {
-    let localConnection!: AmqpConnectionManager;
+  // TODO: DELETE OLD PROPERTIES UNDER THIS LINE
+  async getNewChannelOld({ name = rand().toString(), onClose = null, options = {} }: newChannelOpts = {}) {
+    let connection!: AmqpConnectionManager;
     try {
-      localConnection = await this.getConnectionOld(connection);
+      connection = await this.getConnectionOld();
     } catch (e) {
       logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
       throw e;
     }
-
-    if (!localConnection) {
-      throw new Error(`rabbit: couldnt get connection for new channel ${name}`);
-    }
-
-    const channel = localConnection?.createChannel({ ...options });
+    const channel = connection.createChannel({ ...options });
     once(channel, 'close').then((args) => {
       logger.error(`rabbit: channel ${name} closed`);
       onClose?.(args);
@@ -1190,38 +1084,30 @@ class RabbitMq implements IAfRabbitMq {
     }
   }
 
-  async getConnectionOld(connection: ConnectionData) {
+  async getConnectionOld() {
     return new Promise<AmqpConnectionManager>(async (resolve, reject) => {
-      const {
-        amqpConnection: connectionLocal,
-        creatingConnection,
-        connectionCreatedEventName,
-        connectionFailedEventName,
-        blockReconnect,
-      } = connection;
-
-      if (blockReconnect) {
+      if (this.oldBlockReconnect) {
         debug('rabbit: block reconnect');
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore
         return resolve();
       }
-      if (connectionLocal !== null) {
-        if (this.options?.disableReconnect || connectionLocal?.isConnected()) {
+      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(connectionLocal);
+          return resolve(this.oldConnection);
         }
         debug('rabbit: connection - reconnecting');
       }
-      if (creatingConnection) {
+      if (this.oldCreatingConnection) {
         debug('rabbit: creating connection emi');
-        this.oldEm.once(connectionCreatedEventName, resolve);
-        this.oldEm.once(connectionFailedEventName, reject);
+        this.oldEm.once(CONNECTION_CREATED_CONST, resolve);
+        this.oldEm.once(CONNECTION_FAILED_CONST, reject);
         return;
       }
-      connection.creatingConnection = true;
+      this.oldCreatingConnection = true;
       let isResolved = false;
 
       // It is import to use it as a function and not as a variable
@@ -1238,59 +1124,56 @@ class RabbitMq implements IAfRabbitMq {
       };
 
       const defaultUrls = findServers();
-      const newConnection: AmqpConnectionManager = await connect(defaultUrls, {
+      const connection: AmqpConnectionManager = await connect(defaultUrls, {
         findServers,
       });
 
-      connection.amqpConnection = newConnection;
-      newConnection.on('error', (err) => {
+      this.oldConnection = connection;
+      this.oldConnection.on('error', (err) => {
         logger.error('rabbit: connection error', { err });
         if (!isResolved) {
           isResolved = true;
           reject(err);
-          this.oldEm.emit(connectionFailedEventName, err);
+          this.oldEm.emit(CONNECTION_FAILED_CONST, err);
         }
       });
 
-      newConnection.on('connectFailed', (err) => {
-        this.oldConsumersTags.clear();
-        if (typeof err.url === 'string') {
-          err.url = this.maskURL(err.url);
-        }
+      this.oldConnection.on('connectFailed', (err) => {
+        this.oldConsumersTags = [];
         logger.error('rabbit: connection connectFailed', { err });
         if (!isResolved) {
           isResolved = true;
           reject(err);
-          this.oldEm.emit(connectionFailedEventName, err);
+          this.oldEm.emit(CONNECTION_FAILED_CONST, err);
         }
       });
 
-      newConnection.on('disconnect', ({ err }) => {
-        this.oldConsumersTags.clear();
+      this.oldConnection.on('disconnect', ({ err }) => {
+        this.oldConsumersTags = [];
         debug('rabbit: connection closed');
         if (this.options?.disableReconnect) {
           logger.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
-          connection.blockReconnect = true;
+          this.oldBlockReconnect = true;
         } else {
           logger.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
         }
       });
 
-      newConnection.once('connect', async () => {
+      this.oldConnection.once('connect', async () => {
         debug('rabbit: connection established');
-        connection.creatingConnection = false;
-        this.oldEm.emit(connectionCreatedEventName, newConnection);
+        this.oldCreatingConnection = false;
+        this.oldEm.emit(CONNECTION_CREATED_CONST, connection);
         isResolved = true;
-        resolve(newConnection);
+        resolve(connection);
       });
     });
   }
 
   private saveConsumerOld(queue: string, callback: CallbackFunction, options: ConsumeOptions | undefined) {
-    const isConsumerExist: boolean = this.oldConsumersToRegister.some((consumer) => consumer.queue === queue);
+    const isConsumerExist :boolean = this.oldConsumers.some((consumer) => consumer.queue === queue);
     if (!isConsumerExist) {
       logger.info(`rabbit: consumer: ${queue} saved in consumer array`);
-      this.oldConsumersToRegister.push({
+      this.oldConsumers.push({
         queue,
         callback,
         options,
@@ -1315,7 +1198,6 @@ class RabbitMq implements IAfRabbitMq {
 
   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,
@@ -1327,7 +1209,7 @@ class RabbitMq implements IAfRabbitMq {
       },
     };
     try {
-      const channel: ChannelWrapper = await this.assertChannelOld({ connection });
+      const channel: ChannelWrapper = await this.assertChannelOld();
       debug('assertQueue->channel.addSetup', { queueName });
       await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, localeOptions));
       debug('assertQueue->channel.assertQueue', { queueName });
@@ -1336,8 +1218,8 @@ 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.assertChannelOld({ force: true, connection });
-        await this.deleteQueueOld(queueName, connection);
+        const channel = await this.assertChannelOld({ force: true });
+        await this.deleteQueueOld(queueName);
 
         debug('retrying assertQueue->channel.addSetup', { queueName });
         await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, localeOptions));
@@ -1352,21 +1234,19 @@ class RabbitMq implements IAfRabbitMq {
     return queue;
   }
 
-  async assertChannelOld({ force = false, connection }: assertChannelOpts): Promise<ChannelWrapper> {
+  async assertChannelOld({ force = false } : assertChannelOpts = {}): Promise<ChannelWrapper> {
     if (!this.oldPublishChannelSetupPromise) {
       this.oldPublishChannelSetupPromise = new Promise<ChannelWrapper>(async (resolve, reject) => {
-        if (this.oldPublishChannel && !force) {
-          return resolve(this.oldPublishChannel);
+        if (this.oldChannel && !force) {
+          return resolve(this.oldChannel);
         }
 
         try {
-          const channel = await this.getNewChannelOld({ connection });
+          const channel = await this.getNewChannelOld({});
           channel.on('error', (err) => {
             logger.error('rabbit: channel error', { err });
           });
-          if (this.oldPublishConnection === connection) {
-            this.oldPublishChannel = channel;
-          }
+          this.oldChannel = channel;
           resolve(channel);
         } catch (e) {
           reject(e);
@@ -1376,17 +1256,17 @@ class RabbitMq implements IAfRabbitMq {
     return this.oldPublishChannelSetupPromise;
   }
 
-  private async deleteQueueOld(queue: string, connection: ConnectionData) {
+  private async deleteQueueOld(queue: string) {
     RabbitMq.validateName('queue', queue);
-    const channel: ChannelWrapper = await this.assertChannelOld({ connection });
+    const channel: ChannelWrapper = await this.assertChannelOld();
     logger.info('rabbit: deleting queue', { queue });
     const deleteQueueRes = await channel.deleteQueue(queue);
     debug('queue deleted', deleteQueueRes);
     return deleteQueueRes;
   }
 
-  async assertExchangeOld(exchangeName: string, connection: ConnectionData) {
-    const channel: ChannelWrapper = await this.assertChannelOld({ connection });
+  async assertExchangeOld(exchangeName: string, options?: any) {
+    const channel: ChannelWrapper = await this.assertChannelOld();
 
     if (this.oldExchanges[exchangeName]) {
       delete this.oldAssertExchangePromises[exchangeName];
@@ -1401,60 +1281,6 @@ class RabbitMq implements IAfRabbitMq {
     this.oldExchanges[exchangeName] = await this.oldAssertExchangePromises[exchangeName];
     return this.oldExchanges[exchangeName];
   }
-
-  async isConnectedOld() : Promise<boolean> {
-    if (!this.gracefulShutdownStarted) {
-      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: AfConsumer) => {
-          const doesConsumerExist = this.consumersTags.get(c.queue);
-          return !doesConsumerExist;
-        });
-
-        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: any = 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;
-    }
-  }
 }
 
 export default RabbitMq;