@autofleet/rabbit 3.3.0-beta.11 → 3.3.0-beta.2

package/src/index.ts

@@ -20,8 +20,7 @@ import getRedisInstance, { RedisConfig } from './lib/redis';
 import { assertExchangeFanout, rand, wrapSetImmediate } from './lib/utils';
 import {
   AUTOMATION_ID_HEADER,
-  CONNECTION_CREATED_CONST,
-  CONNECTION_FAILED_CONST,
+  ConnectionPurpose,
   DEFAULT_LOCK_TIMEOUT,
   DEFAULT_OPTIONS,
   RETRY_HEADER,
@@ -40,13 +39,13 @@ import {
   CONSUMER_DEFAULT_OPTIONS,
   QueueSetupPromisesDictionary,
   AssertExchangePromisesDictionary,
+  ConnectionData,
 } 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;
@@ -86,11 +85,13 @@ type newChannelOpts = {
   name?: string;
   onClose?: null | ((args: any | null) => void);
   options?: CreateChannelOpts | undefined;
+  connectionPurpose?: ConnectionPurpose,
 };
 
 type assertChannelOpts = {
   channelName?: string;
   force?: boolean;
+  connectionPurpose?: ConnectionPurpose;
 }
 
 type AfConsumer = {
@@ -102,7 +103,7 @@ type AfConsumer = {
 const HEARTBEAT = '60';
 
 class RabbitMq implements IAfRabbitMq {
-  static parseMsg(msg: any) : any {
+  static parseMsg(msg: any): any {
     let { content } = msg;
     content = content.toString();
 
@@ -143,18 +144,19 @@ class RabbitMq implements IAfRabbitMq {
 
   RECONNECT_MSG = 'rabbit: connection disconnect - reconnecting';
 
-  channel: ChannelWrapper | null;
+  publishChannel: ChannelWrapper | null;
 
   publishChannelSetupPromise: Promise<ChannelWrapper> | null;
 
-  blockReconnect: boolean | null | undefined
+  blockReconnect: boolean | null | undefined;
 
-  connection: AmqpConnectionManager | null | undefined
+  connectionsMap: {
+    [ConnectionPurpose.Consume]: ConnectionData;
+    [ConnectionPurpose.Publish]: ConnectionData;
+  };
 
   em: EventEmitter;
 
-  creatingConnection: boolean;
-
   exchanges: ExchangesCache;
 
   queues: QueuesCache;
@@ -174,48 +176,30 @@ class RabbitMq implements IAfRabbitMq {
 
   private consumers: Array<AfConsumer> = [];
 
-  private doesVHostExist = false;
-
-  private vhost = 'quorum-vhost';
-
-  // TODO:[QUORUM-PHASE-3] Delete the old properties that we use for the old consumers and publishers
-  oldChannel: ChannelWrapper | null;
-
-  oldPublishChannelSetupPromise: Promise<ChannelWrapper> | null;
-
-  oldBlockReconnect: boolean | null | undefined
-
-  oldConnection: AmqpConnectionManager | null | undefined
-
-  oldEm: EventEmitter;
-
-  oldCreatingConnection: boolean;
-
-  oldExchanges: ExchangesCache;
-
-  oldQueues: QueuesCache;
-
-  oldQueueSetupPromises: QueueSetupPromisesDictionary;
-
-  oldAssertExchangePromises: AssertExchangePromisesDictionary;
-
-  oldConsumersTags: Array<[ConfirmChannel, string]>;
-
-  private oldConsumers: Array<AfConsumer> = [];
-
-  constructor(options: AfRabbitOptions = {}, redisConfig?: RedisConfig) {
+  constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig) {
     this.em = new EventEmitter();
-    this.channel = null;
+    this.publishChannel = null;
     this.publishChannelSetupPromise = null;
-    this.connection = null;
-    this.creatingConnection = false;
+    this.connectionsMap = {
+      [ConnectionPurpose.Consume]: {
+        connection: null,
+        creatingConnection: false,
+        connectionCreatedEventName: 'consumeConnectionCreated',
+        connectionFailedEventName: 'consumeConnectionFailed',
+      },
+      [ConnectionPurpose.Publish]: {
+        connection: null,
+        creatingConnection: false,
+        connectionCreatedEventName: 'publishConnectionCreated',
+        connectionFailedEventName: 'publishConnectionFailed',
+      },
+    };
     this.exchanges = {};
     this.queues = {};
     this.queueSetupPromises = {};
     this.assertExchangePromises = {};
     this.consumers = [];
     this.options = options;
-
     this.redisClient = redisConfig && getRedisInstance(redisConfig);
     if (this.redisClient) {
       this.redisLock = promisify(RedisLock(this.redisClient)) as RedisLockType;
@@ -230,74 +214,8 @@ class RabbitMq implements IAfRabbitMq {
         await this.gracefulShutdown('SIGINT');
       });
     }
-
-    // TODO: [QUORUM-PHASE-3] Delete the old properties that we use for the old consumers and publishers
-    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 assertVHost = async () => {
-    if (this.doesVHostExist) {
-      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`;
-
-    const url = `${rabbitHost}/api/vhosts/${encodeURIComponent(this.vhost)}`;
-
-    try {
-      const response = await fetch(url, {
-        method: 'GET',
-        headers,
-      });
-
-      if (response.status === 200) {
-        this.doesVHostExist = true;
-        logger.info('Vhost exists', { vhost: this.vhost });
-        return;
-      }
-
-      if (response.status !== 404) {
-        logger.error('Failed to check vhost', { response });
-        throw new RabbitError('Failed to check vhost');
-      }
-
-      const createResponse = await fetch(url, {
-        method: 'PUT',
-        headers,
-        body: JSON.stringify({ default_queue_type: 'quorum' }),
-      });
-
-      if (!createResponse.ok) {
-        logger.error('Failed to create vhost', { response: createResponse });
-        throw new RabbitError('Failed to create vhost');
-      }
-
-      this.doesVHostExist = true;
-      logger.info('Vhost created', { vhost: this.vhost });
-    } catch (error) {
-      logger.error('Failed to check or create vhost', { error });
-      throw error;
-    }
-  };
-
   private shouldConsumeMessageByTimestamp = async (msg: ConsumeMessageOrNull) => {
     if (msg) {
       const { properties: { headers } } = msg;
@@ -312,7 +230,7 @@ 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 = null) => async (userMsg: ConsumeMessage): Promise<any> => {
     if (msg) {
       debug('rabbit acking message', { deliveryTag: msg.fields.deliveryTag });
       await channel.ack(msg);
@@ -338,8 +256,8 @@ class RabbitMq implements IAfRabbitMq {
     userMsg: ConsumeMessageOrNull,
     {
       skipRetry = false,
-    }: NackOptions = { },
-  ) : Promise<any> => {
+    }: NackOptions = {},
+  ): Promise<any> => {
     await this.unlockRedisIfNeeded(releaseLock);
     if (channel && msg) {
       if (
@@ -373,30 +291,36 @@ class RabbitMq implements IAfRabbitMq {
     }
   }
 
-  async getConnection() {
-    return new Promise<AmqpConnectionManager>(async (resolve, reject) => {
+  async getConnection(connectionPurpose: ConnectionPurpose) {
+    return new Promise<AmqpConnectionManager | undefined | null>(async (resolve, reject) => {
+      const {
+        connection,
+        creatingConnection,
+        connectionCreatedEventName,
+        connectionFailedEventName,
+      } = this.connectionsMap[connectionPurpose];
       if (this.blockReconnect) {
         debug('rabbit: block reconnect');
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore
         return resolve();
       }
-      if (this.connection !== null) {
-        if (this.options?.disableReconnect || this.connection?.isConnected()) {
+      if (connection !== null) {
+        if (this.options?.disableReconnect || connection?.isConnected()) {
           debug('rabbit: connection - is connected');
           // eslint-disable-next-line @typescript-eslint/ban-ts-comment
           // @ts-ignore
-          return resolve(this.connection);
+          return resolve(connection);
         }
         debug('rabbit: connection - reconnecting');
       }
-      if (this.creatingConnection) {
+      if (creatingConnection) {
         debug('rabbit: creating connection emi');
-        this.em.once(CONNECTION_CREATED_CONST, resolve);
-        this.em.once(CONNECTION_FAILED_CONST, reject);
+        this.em.once(connectionCreatedEventName, resolve);
+        this.em.once(connectionFailedEventName, reject);
         return;
       }
-      this.creatingConnection = true;
+      this.connectionsMap[connectionPurpose].creatingConnection = true;
       let isResolved = false;
 
       // It is import to use it as a function and not as a variable
@@ -408,36 +332,38 @@ 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}?heartbeat=${HEARTBEAT}`];
       };
 
       const defaultUrls = findServers();
-      const connection: AmqpConnectionManager = await connect(defaultUrls, {
+      const newConnection: AmqpConnectionManager = await connect(defaultUrls, {
         findServers,
       });
 
-      this.connection = connection;
-      this.connection.on('error', (err) => {
+      this.connectionsMap[connectionPurpose].connection = newConnection;
+      logger.info(`rabbit: created new connection ${connectionPurpose}`);
+
+      newConnection.on('error', (err) => {
         logger.error('rabbit: connection error', { err });
         if (!isResolved) {
           isResolved = true;
           reject(err);
-          this.em.emit(CONNECTION_FAILED_CONST, err);
+          this.em.emit(connectionFailedEventName, err);
         }
       });
 
-      this.connection.on('connectFailed', (err) => {
+      newConnection.on('connectFailed', (err) => {
         this.consumersTags = [];
-        logger.error('rabbit: connection connectFailed', { err, advice: 'Check if the vhost exist', vhost: this.vhost });
+        logger.error('rabbit: connection connectFailed', { err });
         if (!isResolved) {
           isResolved = true;
           reject(err);
-          this.em.emit(CONNECTION_FAILED_CONST, err);
+          this.em.emit(connectionFailedEventName, err);
         }
       });
 
-      this.connection.on('disconnect', ({ err }) => {
-        // this.channel = null;
+      newConnection.on('disconnect', ({ err }) => {
         this.consumersTags = [];
         debug('rabbit: connection closed');
         if (this.options?.disableReconnect) {
@@ -447,25 +373,28 @@ class RabbitMq implements IAfRabbitMq {
           logger.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
         }
       });
-
-      this.connection.once('connect', async () => {
-        debug('rabbit: connection established');
-        this.creatingConnection = false;
-        this.em.emit(CONNECTION_CREATED_CONST, connection);
+      newConnection.once('connect', async () => {
+        this.connectionsMap[connectionPurpose].creatingConnection = false;
+        this.em.emit(connectionCreatedEventName, newConnection);
         isResolved = true;
-        resolve(connection);
+        resolve(newConnection);
       });
     });
   }
 
-  async getNewChannel({ name = rand().toString(), onClose = null, options = {} }: newChannelOpts = {}) {
-    let connection!: AmqpConnectionManager;
+  async getNewChannel({
+    name = rand().toString(), onClose = null, options = {}, connectionPurpose = ConnectionPurpose.Consume,
+  }: newChannelOpts): Promise<ChannelWrapper> {
+    let connection!: AmqpConnectionManager | undefined | null;
     try {
-      connection = await this.getConnection();
+      connection = await this.getConnection(connectionPurpose);
     } catch (e) {
       logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
       throw e;
     }
+    if (!connection) {
+      throw new Error(`rabbit: couldnt get connection for new channel ${name}`);
+    }
     const channel = connection.createChannel({ ...options });
     once(channel, 'close').then((args) => {
       logger.error(`rabbit: channel ${name} closed`);
@@ -481,19 +410,23 @@ class RabbitMq implements IAfRabbitMq {
     }
   }
 
-  async assertChannel({ force = false } : assertChannelOpts = {}): Promise<ChannelWrapper> {
+  async assertChannel({ force = false, connectionPurpose = ConnectionPurpose.Consume }: assertChannelOpts): Promise<ChannelWrapper> {
+    debug('rabbit: start assert channel', { connectionPurpose, publishPromise: this.publishChannelSetupPromise, channel: this.publishChannel });
     if (!this.publishChannelSetupPromise) {
       this.publishChannelSetupPromise = new Promise<ChannelWrapper>(async (resolve, reject) => {
-        if (this.channel && !force) {
-          return resolve(this.channel);
+        if (this.publishChannel && !force) {
+          return resolve(this.publishChannel);
         }
 
         try {
-          const channel = await this.getNewChannel({});
+          const channel = await this.getNewChannel({ connectionPurpose });
+          debug('rabbit: new channel got', { connectionPurpose, channel: this.publishChannel });
           channel.on('error', (err) => {
             logger.error('rabbit: channel error', { err });
           });
-          this.channel = channel;
+          if (connectionPurpose === ConnectionPurpose.Publish) {
+            this.publishChannel = channel;
+          }
           resolve(channel);
         } catch (e) {
           reject(e);
@@ -503,9 +436,8 @@ class RabbitMq implements IAfRabbitMq {
     return this.publishChannelSetupPromise;
   }
 
-  async assertExchange(exchangeName: string, options?: any) {
-    const channel: ChannelWrapper = await this.assertChannel();
-
+  async assertExchange(exchangeName: string, options: any = { connectionPurpose: ConnectionPurpose.Consume }) {
+    const channel: ChannelWrapper = await this.assertChannel({ connectionPurpose: options.connectionPurpose });
     if (this.exchanges[exchangeName]) {
       delete this.assertExchangePromises[exchangeName];
       return this.exchanges[exchangeName];
@@ -520,58 +452,57 @@ class RabbitMq implements IAfRabbitMq {
     return this.exchanges[exchangeName];
   }
 
-  // TODO: [QUORUM-PHASE-2] Change the implementation to the new one
-  async getQueueLength(queue: string) {
+  async getQueueLength(queue: string, connectionPurpose: ConnectionPurpose = ConnectionPurpose.Consume): Promise<Replies.AssertQueue> {
     RabbitMq.validateName('queue', queue);
-    const { oldChannel: channel } = this;
-    if (!channel) {
-      throw new RabbitError('channel is not defined');
+    const { connection } = this.connectionsMap[connectionPurpose];
+    const { publishChannel } = this;
+    if (!publishChannel) {
+      throw new Error('channel is not defined');
     }
-    debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
-    return channel?.checkQueue(queue);
+    debug('rabbit: getting queue length', { queue, connected: connection?.isConnected() });
+    return publishChannel?.checkQueue(queue);
   }
 
-  private async deleteQueue(queue: string) {
+  private async deleteQueue(queue: string, connectionPurpose: ConnectionPurpose) {
     RabbitMq.validateName('queue', queue);
-    const channel: ChannelWrapper = await this.assertChannel();
+    const channel: ChannelWrapper = await this.assertChannel({ connectionPurpose });
     logger.info('rabbit: deleting queue', { queue });
     const deleteQueueRes = await channel.deleteQueue(queue);
     debug('queue deleted', deleteQueueRes);
     return deleteQueueRes;
   }
 
-  // TODO: [QUORUM-PHASE-2] Change the implementation to the new one
   async bindQueue(queue: string, exchange: string) {
-    const channel: ChannelWrapper = await this.assertChannelOld();
+    const channel: ChannelWrapper = await this.assertChannel({ connectionPurpose: ConnectionPurpose.Publish });
     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 connectionPurpose = ConnectionPurpose.Publish;
+    const shouldUseQuorum = RabbitMq.shouldUseQuorum(queueName);
     const localeOptions = {
       ...options,
       durable: true,
       arguments: {
         ...options?.arguments,
         'x-consumer-timeout': 1000 * 60 * 60 * 24,
-        'x-queue-type': 'quorum',
+        'x-queue-type': shouldUseQuorum ? 'quorum' : 'classic',
       },
     };
     try {
-      const channel: ChannelWrapper = await this.assertChannel();
+      const channel: ChannelWrapper = await this.assertChannel({ connectionPurpose });
       debug('assertQueue->channel.addSetup', { queueName });
-      await channel.addSetup(async (setupChannel: ConfirmChannel) => {
-        await setupChannel.assertQueue(queueName, localeOptions);
-      });
+      await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, localeOptions));
       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.assertChannel({ force: true });
-        await this.deleteQueue(queueName);
+        const channel = await this.assertChannel({ force: true, connectionPurpose });
+        await this.deleteQueue(queueName, connectionPurpose);
 
         debug('retrying assertQueue->channel.addSetup', { queueName });
         await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, localeOptions));
@@ -586,7 +517,6 @@ 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
   static shouldUseQuorum(queueName: string): boolean {
     const envQuorumQueuesWhitelist = process.env.QUORUM_QUEUES_WHITELIST;
 
@@ -602,7 +532,8 @@ class RabbitMq implements IAfRabbitMq {
     return false;
   }
 
-  async assertQueue(queueName: string, options?: Options.AssertQueue): Promise<any> {
+  async assertQueue(queueName: string, options?: Options.AssertQueue) {
+    debug('rabbit: start assert queue', { queueName });
     RabbitMq.validateName('queue', queueName);
     if (this.queues[queueName]) {
       delete this.queueSetupPromises[queueName];
@@ -614,11 +545,12 @@ class RabbitMq implements IAfRabbitMq {
     }
 
     this.queueSetupPromises[queueName] = this.setupQueue(queueName, options);
+    debug('rabbit: done assert queue', { queueName });
     return this.queueSetupPromises[queueName];
   }
 
   private saveConsumer(queue: string, callback: CallbackFunction, options: ConsumeOptions | undefined) {
-    const isConsumerExist :boolean = this.consumers.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.consumers.push({
@@ -629,27 +561,10 @@ 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: [QUORUM-PHASE-3] Use only the implementation of consumeNew and delete consumeNew and consumeOld
-    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
-  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
-  async consumeOld(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
-    await this.consumeFromRabbitOld(queue, callback, options);
-  }
-
   private async lockRedisIfNeeded(msg: any, options: any) {
     const { properties: { headers } } = msg;
     const timestamp = headers?.creationTimestamp;
@@ -680,13 +595,12 @@ class RabbitMq implements IAfRabbitMq {
     } = 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({});
+    const channel = await this.getNewChannel({ connectionPurpose: ConnectionPurpose.Consume });
     return channel.addSetup(async (confirmChannel: ConfirmChannel) => {
-      throw new Error('Dummy assertQueue error');
       const q = await this.assertQueue(queue, optionsWithDefaults);
       await confirmChannel.prefetch(limit, false);
       const { consumerTag } = await confirmChannel.consume(
@@ -775,45 +689,22 @@ class RabbitMq implements IAfRabbitMq {
     });
   }
 
-  // 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<any> {
     const optionsWithDefaults = { ...DEFAULT_OPTIONS, ...options };
     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) {
-      await this.assertVHost();
-      await this.saveConsumer(queue, callback, options);
-      const channel: ChannelWrapper = await this.getNewChannel({ name: `consume-exchange-${exchange}-queue-${queue}` });
-
-      await channel.addSetup(async (c: ConfirmChannel) => {
-        const assertExchange = await assertExchangeFanout(c, exchange);
-        await c.assertQueue(queue);
-        this.exchanges[exchange] = assertExchange;
-        await c.prefetch(limit, false);
-        return Promise.all([
-          c.bindQueue(queue, exchange, ''),
-          this.consumeNew(
-            queue,
-            callback,
-            options,
-          ),
-        ]);
-      });
-    }
+    await this.saveConsumer(queue, callback, options);
+    const channel: ChannelWrapper = await this.getNewChannel({ name: `consume-exchange-${exchange}-queue-${queue}` });
 
-    // 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` });
-    await channelOld.addSetup(async (c: ConfirmChannel) => {
+    return channel.addSetup(async (c: ConfirmChannel) => {
       const assertExchange = await assertExchangeFanout(c, exchange);
       await c.assertQueue(queue);
-      this.oldExchanges[exchange] = assertExchange;
+      this.exchanges[exchange] = assertExchange;
       await c.prefetch(limit, false);
       return Promise.all([
         c.bindQueue(queue, exchange, ''),
-        this.consumeOld(
+        this.consume(
           queue,
           callback,
           options,
@@ -822,21 +713,18 @@ class RabbitMq implements IAfRabbitMq {
     });
   }
 
-  // Used by the microservices to publish messages to the exchange
-  // TODO: [QUORUM-PHASE-2] Change the implementation to the new one
-  async publish(exchange: string, content: any, customHeaders?: any) : Promise<boolean> {
+  async publish(exchange: string, content: any, customHeaders?: any): Promise<boolean> {
+    debug('rabbit: start publish msg');
     return wrapSetImmediate(async () => {
       RabbitMq.validateName('exchange', exchange);
-      const channel: ChannelWrapper = await this.assertChannelOld();
-      await this.assertExchangeOld(exchange);
+      const channel: ChannelWrapper = await this.assertChannel({ connectionPurpose: ConnectionPurpose.Publish });
+      await this.assertExchange(exchange, { connectionPurpose: ConnectionPurpose.Publish });
       await channel.publish(exchange, '',
         Buffer.from(JSON.stringify(content)),
         RabbitMq.getPublishOptions(customHeaders));
     });
   }
 
-  // Used by the microservices to send messages to the queue
-  // TODO: [QUORUM-PHASE-2] Change the implementation to the new one
   async sendToQueue(
     queue: string,
     content: any,
@@ -844,7 +732,7 @@ class RabbitMq implements IAfRabbitMq {
     customHeaders?: any,
   ): Promise<boolean | undefined> {
     try {
-      await this.assertChannelOld();
+      await this.assertChannel({ connectionPurpose: ConnectionPurpose.Publish });
     } catch (e) {
       logger.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
       throw e;
@@ -852,57 +740,62 @@ class RabbitMq implements IAfRabbitMq {
 
     try {
       RabbitMq.validateName('queue', queue);
-      await this.assertQueueOld(queue, options);
+      await this.assertQueue(queue, options);
     } catch (e) {
       logger.error(`rabbit sendToQueue: failed to assert queue ${queue}`, { e });
       throw e;
     }
 
     try {
-      const res = await this.oldChannel?.sendToQueue(queue,
+      const res = await this.publishChannel?.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 });
+      logger.error(`rabbit sendToQueue: failed to send to queue ${queue}`, { e });
       throw e;
     }
   }
 
-  // TODO: [QUORUM-PHASE-2] After changing the publish from old to new change from the old to the new implementation
-  async isConnected() : Promise<boolean> {
-    const connection = await this.getConnectionOld();
-    const isConnected = connection.isConnected();
-    if (!isConnected) {
-      logger.error('rabbit: isConnected - false');
-      return false;
-    }
-    const channel: any = await this.assertChannelOld();
-    try {
-      await Promise.all([
-        channel.waitForConnect(),
-        ...this.oldConsumers.map((c: AfConsumer) => channel.checkQueue(c.queue)),
-      ]);
-    } catch (e) {
-      logger.error('rabbit: isConnected - false');
-      return false;
-    }
-    logger.info('rabbit: isConnected - true');
-    return true;
+  async isConnected(): Promise<boolean> {
+    debug('rabbit: start is connected');
+    const isEachConnectionConnected = await Promise.all(
+      Object.entries(this.connectionsMap).map(async ([connectionPurpose, connectionData]) => {
+        const { connection } = connectionData;
+        const isConnected = connection?.isConnected();
+        if (!isConnected) {
+          logger.error('rabbit: isConnected - false', { connectionPurpose });
+          return false;
+        }
+        logger.info('rabbit: isConnected - true', { connectionPurpose });
+
+        if (connectionPurpose === ConnectionPurpose.Publish) {
+          const channel: any = await this.assertChannel({ connectionPurpose: connectionPurpose as ConnectionPurpose });
+          try {
+            await Promise.all([
+              channel.waitForConnect(),
+              ...this.consumers.map((c: AfConsumer) => channel.checkQueue(c.queue)),
+            ]);
+          } catch (e) {
+            logger.error('rabbit: isConnected - false');
+            return false;
+          }
+        }
+
+        return true;
+      }),
+    );
+    return isEachConnectionConnected.every((isConnected) => isConnected === true);
   }
 
-  async gracefulShutdown(signal: string) : Promise<void> {
-    // TODO: [QUORUM-PHASE-2] After changing the publish from old to new change from the old to the new implementation
-    const tagsNumber = this.consumersTags.length + this.oldConsumersTags.length;
+  async gracefulShutdown(signal: string): Promise<void> {
+    const tagsNumber = this.consumersTags.length;
     logger.info(`rabbit: [gracefully-shutdown] received ${signal}! canceling #${tagsNumber} tags...`);
     const cancelTagPromises = this.consumersTags.map(([channel, tag]) => channel.cancel(tag));
-    const cancelTagPromisesOld = this.oldConsumersTags.map(([channel, tag]) => channel.cancel(tag));
     // Clean the array to avoid race
     this.consumersTags = [];
-    this.oldConsumersTags = [];
-    const results = await Promise.allSettled([...cancelTagPromises, ...cancelTagPromisesOld]);
+    const results = await Promise.allSettled(cancelTagPromises);
     const rejected = results.filter((p) => p.status === 'rejected');
     if (rejected.length > 0) {
       logger.warn(`rabbit: [gracefully-shutdown] #${rejected.length}/${tagsNumber} tags failed to cancel: ${rejected}`);
@@ -910,332 +803,6 @@ class RabbitMq implements IAfRabbitMq {
       logger.info('rabbit: [gracefully-shutdown] all tags successfully canceled.');
     }
   }
-
-  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');
-      }
-      logger.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
-    }
-    const channel = await this.getNewChannelOld({});
-    return channel.addSetup(async (confirmChannel: ConfirmChannel) => {
-      const q = await this.assertQueueOld(queue, optionsWithDefaults);
-      await confirmChannel.prefetch(limit, false);
-      const { consumerTag } = await confirmChannel.consume(
-        queue,
-        async (msg: ConsumeMessageOrNull) => {
-          if (!msg) {
-            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 parsedMessage = RabbitMq.parseMsg(msg);
-          const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
-          const trace = newTrace(traceTypes.RABBIT);
-          // setting also outbreak trace as part of legacy code
-          const outbreakTrace = outbreak.newTrace(traceTypes.RABBIT);
-          // enableRabbitTrace is a flag to protect from different flows that doesn't work with permission
-          // and we don't want to fail the flow because of it
-          if (userId && enableRabbitTrace) {
-            try {
-              await Promise.all([
-                createOrSetRabbitTrace(trace, userId),
-                createOrSetRabbitTrace(outbreakTrace, userId),
-              ]);
-            } catch (e) {
-              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);
-            (outbreakTrace as any)?.context.set(TRACING_HEADER, traceId);
-          }
-
-          if (auditContext) {
-            await auditContext(queue, {
-              userId,
-              automationId,
-            });
-          }
-          const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
-          if (!shouldConsume) {
-            await this.unlockRedisIfNeeded(releaseLock);
-            return this.ack(confirmChannel, msg)(msg);
-          }
-
-          let messageAcked = false;
-          // setting the localAck function to be used in the callback
-
-          const localAck = async () => {
-            if (messageAcked) {
-              return;
-            }
-            messageAcked = true;
-            return this.ack(confirmChannel, msg, true, releaseLock)(msg);
-          };
-
-          const localNack = async (_: ConsumeMessageOrNull, nackOptions: NackOptions = {}) => {
-            if (messageAcked) {
-              return;
-            }
-            debug('rabbit localNack', { messageAcked, uniqueId, deliveryTag: msg.fields.deliveryTag });
-            messageAcked = true;
-            return this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg, nackOptions);
-          };
-
-          try {
-            await callback(
-              parsedMessage,
-              localAck,
-              localNack,
-            );
-          } catch (e) {
-            await localNack(msg);
-          }
-        }, CONSUMER_DEFAULT_OPTIONS,
-      );
-      if (!consumerTag) {
-        logger.error(`rabbit: failed to consume from queue ${queue}`);
-      } else {
-        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 (getNewChannelOld, getConnectionOld, assertQueueOld, setupQueueOld, saveConsumerOld)
-  async getNewChannelOld({ name = rand().toString(), onClose = null, options = {} }: newChannelOpts = {}) {
-    let connection!: AmqpConnectionManager;
-    try {
-      connection = await this.getConnectionOld();
-    } catch (e) {
-      logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
-      throw e;
-    }
-    const channel = connection.createChannel({ ...options });
-    once(channel, 'close').then((args) => {
-      logger.error(`rabbit: channel ${name} closed`);
-      onClose?.(args);
-    });
-    try {
-      await once(channel, 'connect');
-      debug(`rabbit: channel ${name} CONNECTED`);
-      return channel;
-    } catch (err) {
-      logger.error(`rabbit: channel error ${name} error`, { err });
-      throw err;
-    }
-  }
-
-  async getConnectionOld() {
-    return new Promise<AmqpConnectionManager>(async (resolve, reject) => {
-      if (this.oldBlockReconnect) {
-        debug('rabbit: block reconnect');
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        return resolve();
-      }
-      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.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';
-
-        debug('rabbit: creating connection', { host, userName, HEARTBEAT });
-
-        return [`amqp://${userName}:${password}@${host}?heartbeat=${HEARTBEAT}`];
-      };
-
-      const defaultUrls = findServers();
-      const connection: AmqpConnectionManager = await connect(defaultUrls, {
-        findServers,
-      });
-
-      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);
-        }
-      });
-
-      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);
-        }
-      });
-
-      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}`}`);
-        }
-      });
-
-      this.oldConnection.once('connect', async () => {
-        debug('rabbit: connection established');
-        this.oldCreatingConnection = false;
-        this.oldEm.emit(CONNECTION_CREATED_CONST, connection);
-        isResolved = true;
-        resolve(connection);
-      });
-    });
-  }
-
-  private saveConsumerOld(queue: string, callback: CallbackFunction, options: ConsumeOptions | undefined) {
-    const isConsumerExist :boolean = this.oldConsumers.some((consumer) => consumer.queue === queue);
-    if (!isConsumerExist) {
-      logger.info(`rabbit: consumer: ${queue} saved in consumer array`);
-      this.oldConsumers.push({
-        queue,
-        callback,
-        options,
-      });
-    }
-  }
-
-  async assertQueueOld(queueName: string, options?: Options.AssertQueue): Promise<any> {
-    RabbitMq.validateName('queue', queueName);
-    if (this.oldQueues[queueName]) {
-      delete this.oldQueueSetupPromises[queueName];
-      return this.oldQueues[queueName];
-    }
-
-    if (this.oldQueueSetupPromises[queueName]) {
-      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 shouldUseQuorum = RabbitMq.shouldUseQuorum(queueName);
-    const localeOptions = {
-      ...options,
-      durable: true,
-      arguments: {
-        ...options?.arguments,
-        'x-consumer-timeout': 1000 * 60 * 60 * 24,
-        'x-queue-type': shouldUseQuorum ? 'quorum' : 'classic',
-      },
-    };
-    try {
-      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 });
-      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);
-
-        debug('retrying assertQueue->channel.addSetup', { queueName });
-        await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, localeOptions));
-        debug('retrying assertQueue->channel.assertQueue', { queueName });
-        queue = await channel.assertQueue(queueName, localeOptions);
-      } else {
-        throw e;
-      }
-    }
-
-    this.oldQueues[queueName] = queue;
-    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);
-        }
-
-        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);
-        }
-      });
-    }
-    return this.oldPublishChannelSetupPromise;
-  }
-
-  private async deleteQueueOld(queue: string) {
-    RabbitMq.validateName('queue', queue);
-    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, options?: any) {
-    const channel: ChannelWrapper = await this.assertChannelOld();
-
-    if (this.oldExchanges[exchangeName]) {
-      delete this.oldAssertExchangePromises[exchangeName];
-      return this.oldExchanges[exchangeName];
-    }
-
-    if (this.oldAssertExchangePromises[exchangeName]) {
-      return this.oldAssertExchangePromises[exchangeName];
-    }
-
-    this.oldAssertExchangePromises[exchangeName] = assertExchangeFanout(channel, exchangeName);
-    this.oldExchanges[exchangeName] = await this.oldAssertExchangePromises[exchangeName];
-    return this.oldExchanges[exchangeName];
-  }
 }
 
 export default RabbitMq;