@autofleet/rabbit 3.3.0-beta.0 → 3.3.0-beta.10

package/src/index.ts

@@ -19,6 +19,7 @@ import RabbitError from './lib/rabbitError';
 import getRedisInstance, { RedisConfig } from './lib/redis';
 import { assertExchangeFanout, rand, wrapSetImmediate } from './lib/utils';
 import {
+  AUTOMATION_ID_HEADER,
   CONNECTION_CREATED_CONST,
   CONNECTION_FAILED_CONST,
   DEFAULT_LOCK_TIMEOUT,
@@ -35,7 +36,10 @@ import {
   CustomMessageHeaders,
   QueuesCache,
   RedisLockType,
-  ExchangesCache, CONSUMER_DEFAULT_OPTIONS, QueueSetupPromisesDictionary,
+  ExchangesCache,
+  CONSUMER_DEFAULT_OPTIONS,
+  QueueSetupPromisesDictionary,
+  AssertExchangePromisesDictionary,
 } from './lib/types';
 
 // const debug = nodeDebug('af-rabbitmq')
@@ -76,10 +80,6 @@ export interface AfRabbitOptions {
   dontRetryAssert?: boolean;
 
   rabbitHost?: string;
-
-  serviceName: string;
-
-  podIp?: string;
 }
 
 type newChannelOpts = {
@@ -145,14 +145,14 @@ class RabbitMq implements IAfRabbitMq {
 
   channel: ChannelWrapper | null;
 
+  publishChannelSetupPromise: Promise<ChannelWrapper> | null;
+
   blockReconnect: boolean | null | undefined
 
   connection: AmqpConnectionManager | null | undefined
 
   em: EventEmitter;
 
-  podId: string;
-
   creatingConnection: boolean;
 
   exchanges: ExchangesCache;
@@ -161,6 +161,8 @@ class RabbitMq implements IAfRabbitMq {
 
   queueSetupPromises: QueueSetupPromisesDictionary;
 
+  assertExchangePromises: AssertExchangePromisesDictionary;
+
   options: AfRabbitOptions | undefined;
 
   redisClient: any;
@@ -172,17 +174,48 @@ class RabbitMq implements IAfRabbitMq {
 
   private consumers: Array<AfConsumer> = [];
 
-  constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig) {
+  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) {
     this.em = new EventEmitter();
     this.channel = null;
+    this.publishChannelSetupPromise = null;
     this.connection = null;
     this.creatingConnection = false;
     this.exchanges = {};
     this.queues = {};
     this.queueSetupPromises = {};
+    this.assertExchangePromises = {};
     this.consumers = [];
     this.options = options;
-    this.podId = `${options?.serviceName}${options?.podIp ? `-${options.podIp}` : ''}`;
+
     this.redisClient = redisConfig && getRedisInstance(redisConfig);
     if (this.redisClient) {
       this.redisLock = promisify(RedisLock(this.redisClient)) as RedisLockType;
@@ -197,8 +230,74 @@ 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;
@@ -246,13 +345,13 @@ class RabbitMq implements IAfRabbitMq {
       if (
         !skipRetry
         && (
-          !msg.properties.headers[RETRY_HEADER]
-          || parseInt(msg.properties.headers[RETRY_HEADER], 10) < options.retries
+          !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,
         });
@@ -260,7 +359,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,
         });
@@ -309,8 +408,7 @@ 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}?heartbeat=${HEARTBEAT}`];
+        return [`amqp://${userName}:${password}@${host}/${this.vhost}?heartbeat=${HEARTBEAT}`];
       };
 
       const defaultUrls = findServers();
@@ -330,7 +428,7 @@ class RabbitMq implements IAfRabbitMq {
 
       this.connection.on('connectFailed', (err) => {
         this.consumersTags = [];
-        logger.error('rabbit: connection connectFailed', { err });
+        logger.error('rabbit: connection connectFailed', { err, advice: 'Check if the vhost exist', vhost: this.vhost });
         if (!isResolved) {
           isResolved = true;
           reject(err);
@@ -339,6 +437,7 @@ class RabbitMq implements IAfRabbitMq {
       });
 
       this.connection.on('disconnect', ({ err }) => {
+        // this.channel = null;
         this.consumersTags = [];
         debug('rabbit: connection closed');
         if (this.options?.disableReconnect) {
@@ -348,6 +447,7 @@ class RabbitMq implements IAfRabbitMq {
           logger.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
         }
       });
+
       this.connection.once('connect', async () => {
         debug('rabbit: connection established');
         this.creatingConnection = false;
@@ -366,7 +466,7 @@ class RabbitMq implements IAfRabbitMq {
       logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
       throw e;
     }
-    const channel = connection.createChannel({ ...options, name });
+    const channel = connection.createChannel({ ...options });
     once(channel, 'close').then((args) => {
       logger.error(`rabbit: channel ${name} closed`);
       onClose?.(args);
@@ -382,39 +482,50 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   async assertChannel({ force = false } : assertChannelOpts = {}): Promise<ChannelWrapper> {
-    return new Promise<ChannelWrapper>(async (resolve, reject) => {
-      if (this.channel && !force) {
-        return resolve(this.channel);
-      }
+    if (!this.publishChannelSetupPromise) {
+      this.publishChannelSetupPromise = new Promise<ChannelWrapper>(async (resolve, reject) => {
+        if (this.channel && !force) {
+          return resolve(this.channel);
+        }
 
-      try {
-        const channel = await this.getNewChannel({});
-        channel.on('error', (err) => {
-          logger.error('rabbit: channel error', { err });
-        });
-        this.channel = channel;
-        resolve(channel);
-      } catch (e) {
-        reject(e);
-      }
-    });
+        try {
+          const channel = await this.getNewChannel({});
+          channel.on('error', (err) => {
+            logger.error('rabbit: channel error', { err });
+          });
+          this.channel = channel;
+          resolve(channel);
+        } catch (e) {
+          reject(e);
+        }
+      });
+    }
+    return this.publishChannelSetupPromise;
   }
 
   async assertExchange(exchangeName: string, options?: any) {
     const channel: ChannelWrapper = await this.assertChannel();
+
     if (this.exchanges[exchangeName]) {
+      delete this.assertExchangePromises[exchangeName];
       return this.exchanges[exchangeName];
     }
-    const exchange = await assertExchangeFanout(channel, exchangeName);
-    this.exchanges[exchangeName] = exchange;
-    return exchange;
+
+    if (this.assertExchangePromises[exchangeName]) {
+      return this.assertExchangePromises[exchangeName];
+    }
+
+    this.assertExchangePromises[exchangeName] = assertExchangeFanout(channel, exchangeName);
+    this.exchanges[exchangeName] = await this.assertExchangePromises[exchangeName];
+    return this.exchanges[exchangeName];
   }
 
+  // TODO: [QUORUM-PHASE-2] Change the implementation to the new one
   async getQueueLength(queue: string) {
     RabbitMq.validateName('queue', queue);
-    const { channel } = this;
+    const { oldChannel: channel } = this;
     if (!channel) {
-      throw new Error('channel is not defined');
+      throw new RabbitError('channel is not defined');
     }
     debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
     return channel?.checkQueue(queue);
@@ -429,20 +540,32 @@ class RabbitMq implements IAfRabbitMq {
     return deleteQueueRes;
   }
 
+  // TODO: [QUORUM-PHASE-2] Change the implementation to the new one
   async bindQueue(queue: string, exchange: string) {
-    const channel: ChannelWrapper = await this.assertChannel();
+    const channel: ChannelWrapper = await this.assertChannelOld();
     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 localeOptions = {
+      ...options,
+      durable: true,
+      arguments: {
+        ...options?.arguments,
+        'x-consumer-timeout': 1000 * 60 * 60 * 24,
+        'x-queue-type': 'quorum',
+      },
+    };
     try {
       const channel: ChannelWrapper = await this.assertChannel();
       debug('assertQueue->channel.addSetup', { queueName });
-      await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, options));
+      await channel.addSetup(async (setupChannel: ConfirmChannel) => {
+        await setupChannel.assertQueue(queueName, localeOptions);
+      });
       debug('assertQueue->channel.assertQueue', { queueName });
-      queue = await channel.assertQueue(queueName, options);
+      queue = await channel.assertQueue(queueName, localeOptions);
     } catch (e) {
       logger.error('rabbit: assertQueue error', { queueName, options, error: e });
       if (!this.options?.dontRetryAssert) {
@@ -451,19 +574,34 @@ class RabbitMq implements IAfRabbitMq {
         await this.deleteQueue(queueName);
 
         debug('retrying assertQueue->channel.addSetup', { queueName });
-        await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, options));
+        await channel.addSetup((setupChannel: ConfirmChannel) => setupChannel.assertQueue(queueName, localeOptions));
         debug('retrying assertQueue->channel.assertQueue', { queueName });
-        queue = await channel.assertQueue(queueName, options);
+        queue = await channel.assertQueue(queueName, localeOptions);
       } else {
         throw e;
       }
     }
-
-    this.queues[queueName] = queueName;
+    this.queues[queueName] = queue;
     return queue;
   }
 
-  async assertQueue(queueName: string, options?: Options.AssertQueue) {
+  // 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;
+
+    if (envQuorumQueuesWhitelist === '*') {
+      return true;
+    }
+
+    if (envQuorumQueuesWhitelist) {
+      const whitelist = envQuorumQueuesWhitelist.split(',');
+      return whitelist.includes(queueName);
+    }
+
+    return false;
+  }
+
+  async assertQueue(queueName: string, options?: Options.AssertQueue): Promise<any> {
     RabbitMq.validateName('queue', queueName);
     if (this.queues[queueName]) {
       delete this.queueSetupPromises[queueName];
@@ -490,10 +628,27 @@ 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;
@@ -524,14 +679,15 @@ class RabbitMq implements IAfRabbitMq {
     } = optionsWithDefaults;
     if (useConsumeWithLock) {
       if (!this.redisLock) {
-        throw new Error('Usage of consumeWithLock requires RedisInstance');
+        throw new RabbitError('Usage of consumeWithLock requires RedisInstance');
       }
       logger.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
     }
-    const channel = await this.getNewChannel({ name: `${this.podId}_queue_${queue}` });
+    const channel = await this.getNewChannel({});
     return channel.addSetup(async (confirmChannel: ConfirmChannel) => {
-      await confirmChannel.assertQueue(queue, options ? { messageTtl: options.messageTtl } : undefined);
-      await confirmChannel.prefetch(limit, true);
+      logger.info(`rabbit: channel.addSetup before ${queue} assertQueueOld`);
+      const q = await this.assertQueue(queue, optionsWithDefaults);
+      await confirmChannel.prefetch(limit, false);
       const { consumerTag } = await confirmChannel.consume(
         queue,
         async (msg: ConsumeMessageOrNull) => {
@@ -539,8 +695,9 @@ class RabbitMq implements IAfRabbitMq {
             return null;
           }
 
-          const traceId = msg.properties.headers[TRACING_HEADER];
-          const userId = msg.properties.headers[USER_TRACING_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);
@@ -566,7 +723,10 @@ class RabbitMq implements IAfRabbitMq {
           }
 
           if (auditContext) {
-            await auditContext(queue);
+            await auditContext(queue, {
+              userId,
+              automationId,
+            });
           }
           const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
           if (!shouldConsume) {
@@ -614,22 +774,45 @@ 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> {
     const optionsWithDefaults = { ...DEFAULT_OPTIONS, ...options };
     RabbitMq.validateName('exchange', exchange);
     RabbitMq.validateName('queue', queue);
     const { limit, deadMessageTtl } = optionsWithDefaults;
-    await this.saveConsumer(queue, callback, options);
-    const channel: ChannelWrapper = await this.getNewChannel({ name: `${this.podId}_exchange_${exchange}_queue_${queue}` });
+    // 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,
+          ),
+        ]);
+      });
+    }
 
-    return channel.addSetup(async (c: ConfirmChannel) => {
+    // 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) => {
       const assertExchange = await assertExchangeFanout(c, exchange);
-      await c.assertQueue(queue);
-      this.exchanges[exchange] = assertExchange;
-      await c.prefetch(limit, true);
+      // await c.assertQueue(queue);
+      this.oldExchanges[exchange] = assertExchange;
+      await c.prefetch(limit, false);
       return Promise.all([
-        c.bindQueue(queue, exchange, ''),
-        this.consume(
+        // c.bindQueue(queue, exchange, ''),
+        this.consumeOld(
           queue,
           callback,
           options,
@@ -638,57 +821,68 @@ 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> {
     return wrapSetImmediate(async () => {
       RabbitMq.validateName('exchange', exchange);
-      const channel: ChannelWrapper = await this.assertChannel();
-      await this.assertExchange(exchange);
+      const channel: ChannelWrapper = await this.assertChannelOld();
+      await this.assertExchangeOld(exchange);
       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,
     options?: any,
     customHeaders?: any,
-    isBlocking?: boolean,
   ): Promise<boolean | undefined> {
-    const callback = async (): Promise<boolean | undefined> => {
-      try {
-        RabbitMq.validateName('queue', queue);
-        await this.assertChannel();
-        await this.assertQueue(queue, options);
-        const res = await this.channel?.sendToQueue(queue,
-          Buffer.from(JSON.stringify(content)),
-          RabbitMq.getPublishOptions(customHeaders));
-        debug(`rabbit: sending to queue ${queue}`, { res });
-        return res;
-      } catch (e) {
-        logger.error(`rabbit: failed to send to queue ${queue}`, { e });
-        throw e;
-      }
-    };
-    if (isBlocking) {
-      return callback();
+    try {
+      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 {
+      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;
     }
-    return wrapSetImmediate(callback);
   }
 
+  // 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.getConnection();
+    const connection = await this.getConnectionOld();
     const isConnected = connection.isConnected();
     if (!isConnected) {
       logger.error('rabbit: isConnected - false');
       return false;
     }
-    const channel: any = await this.assertChannel();
+    const channel: any = await this.assertChannelOld();
     try {
       await Promise.all([
         channel.waitForConnect(),
-        ...this.consumers.map((c: AfConsumer) => channel.checkQueue(c.queue)),
+        ...this.oldConsumers.map((c: AfConsumer) => channel.checkQueue(c.queue)),
       ]);
     } catch (e) {
       logger.error('rabbit: isConnected - false');
@@ -699,12 +893,15 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   async gracefulShutdown(signal: string) : Promise<void> {
-    const tagsNumber = this.consumersTags.length;
+    // 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;
     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 = [];
-    const results = await Promise.allSettled(cancelTagPromises);
+    this.oldConsumersTags = [];
+    const results = await Promise.allSettled([...cancelTagPromises, ...cancelTagPromisesOld]);
     const rejected = results.filter((p) => p.status === 'rejected');
     if (rejected.length > 0) {
       logger.warn(`rabbit: [gracefully-shutdown] #${rejected.length}/${tagsNumber} tags failed to cancel: ${rejected}`);
@@ -712,6 +909,342 @@ 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;
+      }
+    }
+
+    const queue = {
+      queue: 'bla bla queue',
+      messageCount: 0,
+      consumerCount: 2,
+    };
+
+    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;
+
+export {
+  sendCeleryTaskViaHttp,
+} from './lib/celery';