@autofleet/rabbit 4.1.0-beta.0 → 4.1.1

package/dist/index.js

@@ -1,36 +1,47 @@
 "use strict";
-/* eslint-disable no-empty,consistent-return,no-async-promise-executor,@typescript-eslint/no-unused-vars */
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+var _RabbitMq_logger;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendCeleryTaskViaHttp = void 0;
-const events_1 = require("events");
-const util_1 = require("util");
+const node_process_1 = require("node:process");
+const promises_1 = require("node:timers/promises");
+const node_events_1 = require("node:events");
 const moment_1 = __importDefault(require("moment"));
 const redis_lock_1 = __importDefault(require("redis-lock"));
 const amqp_connection_manager_1 = require("amqp-connection-manager");
+const exponential_backoff_1 = require("exponential-backoff");
 const zehut_1 = require("@autofleet/zehut");
 const node_crypto_1 = require("node:crypto");
-const axios_1 = __importDefault(require("axios"));
 const logger_1 = __importDefault(require("./logger"));
 const rabbitError_1 = __importDefault(require("./lib/rabbitError"));
 const redis_1 = __importDefault(require("./lib/redis"));
 const utils_1 = require("./lib/utils");
 const consts_1 = require("./lib/consts");
 const types_1 = require("./lib/types");
-// const debug = nodeDebug('af-rabbitmq')
-const debug = logger_1.default.debug.bind(logger_1.default);
 const PUBLISH_TIMEOUT = 1000 * 10;
+// TODO: [QUORUM-PHASE-3] Delete these env vars
+const { DISABLE_QUORUM_QUEUES_CONSUME, DISABLE_QUORUM_QUEUES_PUBLISH, } = node_process_1.env;
 const HEARTBEAT = '60';
 class RabbitMq {
     static parseMsg(msg) {
-        let { content } = msg;
-        content = content.toString();
+        let content = msg.content.toString();
         try {
             content = JSON.parse(content);
         }
-        catch (e) { }
+        catch { /* ignore error */ }
         return {
             ...msg,
             content,
@@ -42,10 +53,8 @@ class RabbitMq {
         }
     }
     static getPublishOptions(customHeaders = {}) {
-        const trace = (0, zehut_1.getCurrentPayload)();
-        const user = trace?.context?.get(consts_1.USER_OBJECT);
-        const traceId = trace?.context?.get(consts_1.TRACING_HEADER);
-        const outbreakTrace = zehut_1.outbreak.getCurrentContext();
+        const user = (0, zehut_1.getUser)();
+        const traceId = (0, zehut_1.getCurrentPayload)()?.context?.get(consts_1.TRACING_HEADER) || zehut_1.outbreak.getCurrentContext()?.context?.get(consts_1.TRACING_HEADER);
         return {
             timestamp: (0, moment_1.default)().unix(),
             timeout: PUBLISH_TIMEOUT,
@@ -53,65 +62,118 @@ class RabbitMq {
                 creationTimestamp: (0, moment_1.default)().valueOf(),
                 ...customHeaders,
                 [consts_1.USER_TRACING_HEADER]: user?.id,
-                [consts_1.TRACING_HEADER]: traceId || outbreakTrace?.context?.get(consts_1.TRACING_HEADER),
+                [consts_1.TRACING_HEADER]: traceId,
             },
         };
     }
     constructor(options = {}, redisConfig) {
+        this.options = options;
+        this.redisConfig = redisConfig;
         this.DISCONNECT_MSG = 'rabbit: connection disconnect';
         this.RECONNECT_MSG = 'rabbit: connection disconnect - reconnecting';
-        this.consumers = [];
-        this.isVHostExist = false;
-        this.oldConsumers = [];
+        this.publishChannel = 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.em = new node_events_1.EventEmitter();
+        this.exchanges = {};
+        this.queues = {};
+        this.queueSetupPromises = {};
+        this.assertExchangePromises = {};
+        /** Array of consumers tags used for canceling consumption */
+        this.consumersTags = new Map();
+        this.consumersToRegister = [];
+        this.doesVHostExist = false;
+        this.vhost = 'quorum-vhost';
+        this.gracefulShutdownStarted = false;
+        // TODO:[QUORUM-PHASE-3] Delete the old properties that we use for the old consumers and publishers
+        this.oldPublishChannel = 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.oldEm = new node_events_1.EventEmitter();
+        this.oldExchanges = {};
+        this.oldQueues = {};
+        this.oldQueueSetupPromises = {};
+        this.oldAssertExchangePromises = {};
+        this.oldConsumersTags = new Map();
+        this.oldConsumersToRegister = [];
+        _RabbitMq_logger.set(this, void 0);
         this.assertVHost = async () => {
-            if (this.isVHostExist) {
+            if (this.doesVHostExist) {
                 return;
             }
-            if (!this.options?.vhost) {
-                throw new Error('vhost is not defined');
-            }
-            const { vhost } = this.options;
-            const auth = {
-                auth: {
-                    username: process.env.RABBITMQ_USERNAME || 'guest',
-                    password: process.env.RABBITMQ_PASSWORD || 'guest',
-                },
+            const username = process.env.RABBITMQ_USERNAME || 'guest';
+            const password = process.env.RABBITMQ_PASSWORD || 'guest';
+            const credentials = Buffer.from(`${username}:${password}`).toString('base64');
+            const headers = {
+                Authorization: `Basic ${credentials}`,
+                'Content-Type': 'application/json',
             };
-            const rabbitHost = `http://${(this.options.rabbitHost || process.env.RABBITMQ_SERVICE_HOST || 'localhost').split(':')[0]}:15672`;
+            const rabbitHost = `http://${(this.options?.rabbitHost || process.env.RABBITMQ_SERVICE_HOST || 'localhost').split(':')[0]}:15672`;
+            const url = `${rabbitHost}/api/vhosts/${encodeURIComponent(this.vhost)}`;
             try {
-                const response = await axios_1.default.get(`${rabbitHost}/api/vhosts/${encodeURIComponent(vhost)}`, auth);
-                if (response.status !== 200) {
-                    throw new Error('Failed to check vhost');
+                const response = await fetch(url, {
+                    method: 'GET',
+                    headers,
+                });
+                if (response.status === 200) {
+                    this.doesVHostExist = true;
+                    __classPrivateFieldGet(this, _RabbitMq_logger, "f").info('Vhost exists', { vhost: this.vhost });
+                    return;
                 }
-                this.isVHostExist = true;
-                logger_1.default.info('Vhost exists', { vhost });
+                if (response.status !== 404) {
+                    __classPrivateFieldGet(this, _RabbitMq_logger, "f").error('Failed to check vhost', { response });
+                    throw new rabbitError_1.default('Failed to check vhost');
+                }
+                const createResponse = await fetch(url, {
+                    method: 'PUT',
+                    headers,
+                    body: JSON.stringify({ default_queue_type: 'quorum' }),
+                });
+                if (!createResponse.ok) {
+                    __classPrivateFieldGet(this, _RabbitMq_logger, "f").error('Failed to create vhost', { response: createResponse });
+                    throw new rabbitError_1.default('Failed to create vhost');
+                }
+                this.doesVHostExist = true;
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").info('Vhost created', { vhost: this.vhost });
             }
             catch (error) {
-                // If the vhost does not exist, create it
-                if (error instanceof axios_1.default.AxiosError && error.response?.status === 404) {
-                    try {
-                        await axios_1.default.put(`${rabbitHost}/api/vhosts/${encodeURIComponent(vhost)}`, {
-                            default_queue_type: 'quorum',
-                        }, auth);
-                        this.isVHostExist = true;
-                        logger_1.default.info('Vhost created', { vhost: this.options?.vhost });
-                        return;
-                    }
-                    catch (createError) {
-                        logger_1.default.error('Failed to create vhost', { error: createError });
-                        throw createError;
-                    }
-                }
-                logger_1.default.error('Failed to check vhost', { error });
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").error('Failed to check or create vhost', { error });
                 throw error;
             }
         };
         this.shouldConsumeMessageByTimestamp = async (msg) => {
             if (msg) {
-                const { properties: { headers } } = msg;
+                const { headers } = msg.properties;
                 const timestamp = headers?.creationTimestamp;
                 if (timestamp && headers?.redisTimestampValidationKey && this.redisClient) {
-                    const lastMessageTimestamp = await this.redisClient.getAsync(headers.redisTimestampValidationKey);
+                    const key = this.getRedisKey(headers.redisTimestampValidationKey);
+                    const lastMessageTimestamp = await this.redisClient.get(key);
                     return !lastMessageTimestamp || (parseInt(lastMessageTimestamp, 10) <= parseInt(timestamp, 10));
                 }
                 return true;
@@ -120,68 +182,55 @@ class RabbitMq {
         };
         this.ack = (channel, msg, shouldUpdateRedisTimestamp = false, releaseLock = null) => async (userMsg) => {
             if (msg) {
-                debug('rabbit acking message', { deliveryTag: msg.fields.deliveryTag });
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('rabbit acking message', { deliveryTag: msg.fields.deliveryTag });
                 await channel.ack(msg);
-                const { properties: { headers } } = msg;
+                const { headers } = msg.properties;
                 const timestamp = headers?.creationTimestamp;
                 if (shouldUpdateRedisTimestamp && timestamp && headers?.redisTimestampValidationKey && this.redisClient) {
                     const parsedTimestamp = parseInt(timestamp, 10);
-                    await this.redisClient.setAsync(headers.redisTimestampValidationKey, parsedTimestamp, 'EX', 3600);
+                    const key = this.getRedisKey(headers.redisTimestampValidationKey);
+                    await this.redisClient.set(key, parsedTimestamp, { EX: 3600 });
                     await this.unlockRedisIfNeeded(releaseLock);
                 }
             }
         };
         this.nack = (channel, queue, options, deadQueueOptions, msg, releaseLock) => async (userMsg, { skipRetry = false, } = {}) => {
             await this.unlockRedisIfNeeded(releaseLock);
-            if (channel && msg) {
-                if (!skipRetry
-                    && (!msg.properties.headers[consts_1.RETRY_HEADER]
-                        || parseInt(msg.properties.headers[consts_1.RETRY_HEADER], 10) < options.retries)) {
-                    await this.sendToQueue(queue, RabbitMq.parseMsg(msg).content, options, {
-                        ...msg.properties.headers,
-                        [consts_1.RETRY_HEADER]: msg.properties.headers[consts_1.RETRY_HEADER]
-                            ? msg.properties.headers[consts_1.RETRY_HEADER] + 1
-                            : 1,
-                    });
-                }
-                else {
-                    const deadQueue = `${queue}-dead`;
-                    await this.sendToQueue(deadQueue, RabbitMq.parseMsg(msg).content, deadQueueOptions, {
-                        ...msg.properties.headers,
-                        [consts_1.RETRY_HEADER]: msg.properties.headers[consts_1.RETRY_HEADER]
-                            ? msg.properties.headers[consts_1.RETRY_HEADER] + 1
-                            : 1,
-                    });
-                }
-                debug('rabbit nacking message', { deliveryTag: msg.fields.deliveryTag });
-                await channel.ack(msg);
+            if (!channel || !msg) {
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").error('no channel or msg', { msg });
+                return;
             }
-            else {
-                logger_1.default.error('no channel or msg', {
-                    msg,
-                });
+            const currentRetryHeader = Number.parseInt(msg.properties.headers?.[consts_1.RETRY_HEADER] || '0', 10) || 0;
+            const sendToDeadQueue = skipRetry || currentRetryHeader >= options.retries;
+            await this.sendToQueue(`${queue}${sendToDeadQueue ? '-dead' : ''}`, RabbitMq.parseMsg(msg).content, sendToDeadQueue ? deadQueueOptions : options, {
+                ...msg.properties.headers,
+                [consts_1.RETRY_HEADER]: currentRetryHeader + 1,
+            });
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('rabbit nacking message', { deliveryTag: msg.fields.deliveryTag });
+            await channel.ack(msg);
+        };
+        this.maskURL = (url) => {
+            try {
+                const urlObj = new URL(url);
+                urlObj.username = '***';
+                urlObj.password = '***';
+                return urlObj.toString();
+            }
+            catch {
+                return url;
             }
         };
-        this.em = new events_1.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;
-        if (!options?.vhost) {
-            this.options.vhost = process.env.VHOST_NAME || 'quorum-vhost';
-        }
-        this.redisClient = redisConfig && (0, redis_1.default)(redisConfig);
-        if (this.redisClient) {
-            this.redisLock = (0, util_1.promisify)((0, redis_lock_1.default)(this.redisClient));
+        __classPrivateFieldSet(this, _RabbitMq_logger, options?.logger || logger_1.default, "f");
+        if (redisConfig) {
+            this.redisClient = (0, redis_1.default)(redisConfig).on('error', (err) => {
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").error('rabbit: Redis error', { err, redisConfig });
+            });
+            this.redisClient.connect().catch((err) => {
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").error('rabbit: Failed to connect to Redis', { err, redisConfig });
+            });
+            this.redisLock = (0, redis_lock_1.default)(this.redisClient);
         }
-        this.consumersTags = [];
-        logger_1.default.info(`rabbit: [gracefully-shutdown] adding gracefully shutdown for process.pid ${process.pid}`);
+        __classPrivateFieldGet(this, _RabbitMq_logger, "f").info(`rabbit: [gracefully-shutdown] adding gracefully shutdown for process.pid ${process.pid}`);
         if (!this.options?.dontGracefulShutdown) {
             process.on('SIGTERM', async () => {
                 await this.gracefulShutdown('SIGTERM');
@@ -190,144 +239,139 @@ class RabbitMq {
                 await this.gracefulShutdown('SIGINT');
             });
         }
-        // TODO: DELETE OLD PROPERTIES
-        this.oldEm = new events_1.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 = [];
     }
-    async getConnection() {
-        return new Promise(async (resolve, reject) => {
-            if (this.blockReconnect) {
-                debug('rabbit: block reconnect');
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore
-                return resolve();
-            }
-            if (this.connection !== null) {
-                if (this.options?.disableReconnect || this.connection?.isConnected()) {
-                    debug('rabbit: connection - is connected');
-                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                    // @ts-ignore
-                    return resolve(this.connection);
-                }
-                debug('rabbit: connection - reconnecting');
+    getRedisKey(key) {
+        return `${this.redisConfig?.prefix || ''}${key}`;
+    }
+    async getConnection(connection) {
+        const { amqpConnection: connectionLocal, creatingConnection, connectionCreatedEventName, connectionFailedEventName, blockReconnect, } = connection;
+        if (blockReconnect) {
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('rabbit: block reconnect');
+            // @ts-expect-error we are returning undefined while the function clearly expects a connection.
+            return undefined;
+        }
+        if (connectionLocal !== null) {
+            if (this.options?.disableReconnect || connectionLocal?.isConnected()) {
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('rabbit: connection - is connected');
+                return connectionLocal;
             }
-            if (this.creatingConnection) {
-                debug('rabbit: creating connection emi');
-                this.em.once(consts_1.CONNECTION_CREATED_CONST, resolve);
-                this.em.once(consts_1.CONNECTION_FAILED_CONST, reject);
-                return;
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('rabbit: connection - reconnecting');
+        }
+        if (creatingConnection) {
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('rabbit: creating connection emi');
+            const [event, value] = await Promise.race([connectionCreatedEventName, connectionFailedEventName].map((e) => (0, node_events_1.once)(this.em, e).then(([result]) => [e, result])));
+            if (event === connectionCreatedEventName) {
+                return value;
             }
-            this.creatingConnection = true;
-            let isResolved = false;
-            // It is import to use it as a function and not as a variable
-            // because of k8s changes the env variables
-            // and we want to use the new values
-            const findServers = () => {
-                const userName = process.env.RABBITMQ_USERNAME || 'guest';
-                const password = process.env.RABBITMQ_PASSWORD || 'guest';
-                const host = this.options?.rabbitHost || process.env.RABBITMQ_SERVICE_HOST || 'localhost';
-                debug('rabbit: creating connection', { host, userName, HEARTBEAT });
-                return [`amqp://${userName}:${password}@${host}/${this.options?.vhost}?heartbeat=${HEARTBEAT}`];
-            };
-            const defaultUrls = findServers();
-            const connection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
-                findServers,
-            });
-            this.connection = connection;
-            this.connection.on('error', (err) => {
-                logger_1.default.error('rabbit: connection error', { err });
-                if (!isResolved) {
-                    isResolved = true;
-                    reject(err);
-                    this.em.emit(consts_1.CONNECTION_FAILED_CONST, err);
-                }
-            });
-            this.connection.on('connectFailed', (err) => {
-                this.consumersTags = [];
-                logger_1.default.error('rabbit: connection connectFailed', { err, advice: 'Check if the vhost exist', vhost: this.options?.vhost });
-                if (!isResolved) {
-                    isResolved = true;
-                    reject(err);
-                    this.em.emit(consts_1.CONNECTION_FAILED_CONST, err);
-                }
-            });
-            this.connection.on('disconnect', ({ err }) => {
-                // this.channel = null;
-                this.consumersTags = [];
-                debug('rabbit: connection closed');
-                if (this.options?.disableReconnect) {
-                    logger_1.default.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
-                    this.blockReconnect = true;
-                }
-                else {
-                    logger_1.default.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
-                }
-            });
-            this.connection.once('connect', async () => {
-                debug('rabbit: connection established');
-                this.creatingConnection = false;
-                this.em.emit(consts_1.CONNECTION_CREATED_CONST, connection);
+            throw value;
+        }
+        connection.creatingConnection = true;
+        let isResolved = false;
+        // It is import to use it as a function and not as a variable
+        // because of k8s changes the env variables
+        // and we want to use the new values
+        const findServers = () => {
+            const userName = process.env.RABBITMQ_USERNAME || 'guest';
+            const password = process.env.RABBITMQ_PASSWORD || 'guest';
+            const host = this.options?.rabbitHost || process.env.RABBITMQ_SERVICE_HOST || 'localhost';
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('rabbit: creating connection', { host, userName, HEARTBEAT });
+            return [`amqp://${userName}:${password}@${host}/${this.vhost}?heartbeat=${HEARTBEAT}`];
+        };
+        const defaultUrls = findServers();
+        const newConnection = (0, amqp_connection_manager_1.connect)(defaultUrls, { findServers });
+        connection.amqpConnection = newConnection;
+        const { promise, reject, resolve } = (0, utils_1.createDeferredPromise)();
+        newConnection.on('error', (err) => {
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").error('rabbit: connection error', { err });
+            if (!isResolved) {
                 isResolved = true;
-                resolve(connection);
-            });
+                reject(err);
+                this.em.emit(connectionFailedEventName, err);
+            }
+        });
+        newConnection.on('connectFailed', (err) => {
+            this.consumersTags.clear();
+            if (typeof err.url === 'string') {
+                err.url = this.maskURL(err.url);
+            }
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").error('rabbit: connection connectFailed', { err, advice: 'Check if the vhost exist', vhost: this.vhost });
+            if (!isResolved) {
+                isResolved = true;
+                reject(err);
+                this.em.emit(connectionFailedEventName, err);
+            }
+        });
+        newConnection.on('disconnect', ({ err }) => {
+            this.consumersTags.clear();
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('rabbit: connection closed');
+            if (this.options?.disableReconnect) {
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
+                connection.blockReconnect = true;
+            }
+            else {
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
+            }
+        });
+        newConnection.once('connect', async () => {
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('rabbit: connection established');
+            connection.creatingConnection = false;
+            this.em.emit(connectionCreatedEventName, newConnection);
+            isResolved = true;
+            resolve(newConnection);
         });
+        return promise;
     }
-    async getNewChannel({ name = (0, utils_1.rand)().toString(), onClose = null, options = {} } = {}) {
-        let connection;
+    async getNewChannel({ name = (0, utils_1.rand)().toString(), onClose = null, options = {}, connection, }) {
+        let localConnection;
         try {
-            connection = await this.getConnection();
+            localConnection = await this.getConnection(connection);
         }
         catch (e) {
-            logger_1.default.error(`rabbit: error on get connection for new channel ${name} `, { e });
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").error(`rabbit: error on get connection for new channel ${name} `, { e });
             throw e;
         }
-        const channel = connection.createChannel({ ...options });
-        (0, events_1.once)(channel, 'close').then((args) => {
-            logger_1.default.error(`rabbit: channel ${name} closed`);
+        const channel = localConnection?.createChannel({ ...options });
+        (0, node_events_1.once)(channel, 'close').then((args) => {
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").error(`rabbit: channel ${name} closed`);
             onClose?.(args);
         });
         try {
-            await (0, events_1.once)(channel, 'connect');
-            debug(`rabbit: channel ${name} CONNECTED`);
+            await (0, node_events_1.once)(channel, 'connect');
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug(`rabbit: channel ${name} CONNECTED`);
             return channel;
         }
         catch (err) {
-            logger_1.default.error(`rabbit: channel error ${name} error`, { err });
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").error(`rabbit: channel error ${name} error`, { err });
             throw err;
         }
     }
-    async assertChannel({ force = false } = {}) {
-        if (!this.publishChannelSetupPromise) {
-            this.publishChannelSetupPromise = new Promise(async (resolve, reject) => {
-                if (this.channel && !force) {
-                    return resolve(this.channel);
-                }
-                try {
-                    const channel = await this.getNewChannel({});
-                    channel.on('error', (err) => {
-                        logger_1.default.error('rabbit: channel error', { err });
-                    });
-                    this.channel = channel;
-                    resolve(channel);
-                }
-                catch (e) {
-                    reject(e);
-                }
+    async assertChannel({ force = false, connection }) {
+        if (this.publishChannelSetupPromise) {
+            return this.publishChannelSetupPromise;
+        }
+        const { promise, resolve, reject } = (0, utils_1.createDeferredPromise)();
+        this.publishChannelSetupPromise = promise;
+        if (this.publishChannel && !force) {
+            resolve(this.publishChannel);
+            return promise;
+        }
+        try {
+            const channel = await this.getNewChannel({ connection });
+            channel.on('error', (err) => {
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").error('rabbit: channel error', { err });
             });
+            if (this.publishConnection === connection) {
+                this.publishChannel = channel;
+            }
+            resolve(channel);
+        }
+        catch (e) {
+            reject(e);
         }
-        return this.publishChannelSetupPromise;
+        return promise;
     }
-    async assertExchange(exchangeName, options) {
-        const channel = await this.assertChannel();
+    async assertExchange(exchangeName, connection) {
+        const channel = await this.assertChannel({ connection });
         if (this.exchanges[exchangeName]) {
             delete this.assertExchangePromises[exchangeName];
             return this.exchanges[exchangeName];
@@ -341,28 +385,29 @@ class RabbitMq {
     }
     async getQueueLength(queue) {
         RabbitMq.validateName('queue', queue);
-        const { channel } = this;
+        const { publishChannel: channel } = this;
         if (!channel) {
-            throw new Error('channel is not defined');
+            throw new rabbitError_1.default('channel is not defined');
         }
-        debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
+        __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('rabbit: getting queue length', { queue, connected: this.publishConnection.amqpConnection?.isConnected() });
         return channel?.checkQueue(queue);
     }
-    async deleteQueue(queue) {
+    async deleteQueue(queue, connection) {
         RabbitMq.validateName('queue', queue);
-        const channel = await this.assertChannel();
-        logger_1.default.info('rabbit: deleting queue', { queue });
+        const channel = await this.assertChannel({ connection });
+        __classPrivateFieldGet(this, _RabbitMq_logger, "f").info('rabbit: deleting queue', { queue });
         const deleteQueueRes = await channel.deleteQueue(queue);
-        debug('queue deleted', deleteQueueRes);
+        __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('queue deleted', deleteQueueRes);
         return deleteQueueRes;
     }
     async bindQueue(queue, exchange) {
-        const channel = await this.assertChannel();
+        const channel = await this.assertChannel({ connection: this.publishConnection });
         await channel.addSetup((setupChannel) => setupChannel.bindQueue(queue, exchange, ''));
         return channel.bindQueue(queue, exchange, '');
     }
     async setupQueue(queueName, options) {
         let queue;
+        const connection = this.publishConnection;
         const localeOptions = {
             ...options,
             durable: true,
@@ -373,23 +418,23 @@ class RabbitMq {
             },
         };
         try {
-            const channel = await this.assertChannel();
-            debug('assertQueue->channel.addSetup', { queueName });
+            const channel = await this.assertChannel({ connection });
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('assertQueue->channel.addSetup', { queueName });
             await channel.addSetup(async (setupChannel) => {
                 await setupChannel.assertQueue(queueName, localeOptions);
             });
-            debug('assertQueue->channel.assertQueue', { queueName });
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('assertQueue->channel.assertQueue', { queueName });
             queue = await channel.assertQueue(queueName, localeOptions);
         }
         catch (e) {
-            logger_1.default.error('rabbit: assertQueue error', { queueName, options, error: e });
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").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);
-                debug('retrying assertQueue->channel.addSetup', { queueName });
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('retrying assertQueue', { queueName });
+                const channel = await this.assertChannel({ force: true, connection });
+                await this.deleteQueue(queueName, connection);
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('retrying assertQueue->channel.addSetup', { queueName });
                 await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, localeOptions));
-                debug('retrying assertQueue->channel.assertQueue', { queueName });
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('retrying assertQueue->channel.assertQueue', { queueName });
                 queue = await channel.assertQueue(queueName, localeOptions);
             }
             else {
@@ -399,7 +444,7 @@ class RabbitMq {
         this.queues[queueName] = queue;
         return queue;
     }
-    // TODO: Can be deleted after deleting the old consumers
+    // TODO: [QUORUM-PHASE-3] Can be deleted after deleting the old consumers and publishers because all the queues are created us quorum queues
     static shouldUseQuorum(queueName) {
         const envQuorumQueuesWhitelist = process.env.QUORUM_QUEUES_WHITELIST;
         if (envQuorumQueuesWhitelist === '*') {
@@ -412,22 +457,20 @@ class RabbitMq {
         return false;
     }
     async assertQueue(queueName, options) {
+        var _a;
         RabbitMq.validateName('queue', queueName);
         if (this.queues[queueName]) {
             delete this.queueSetupPromises[queueName];
             return this.queues[queueName];
         }
-        if (this.queueSetupPromises[queueName]) {
-            return this.queueSetupPromises[queueName];
-        }
-        this.queueSetupPromises[queueName] = this.setupQueue(queueName, options);
+        (_a = this.queueSetupPromises)[queueName] || (_a[queueName] = this.setupQueue(queueName, options));
         return this.queueSetupPromises[queueName];
     }
     saveConsumer(queue, callback, options) {
-        const isConsumerExist = this.consumers.some((consumer) => consumer.queue === queue);
+        const isConsumerExist = this.consumersToRegister.some((consumer) => consumer.queue === queue);
         if (!isConsumerExist) {
-            logger_1.default.info(`rabbit: consumer: ${queue} saved in consumer array`);
-            this.consumers.push({
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").info(`rabbit: consumer: ${queue} saved in consumer array`);
+            this.consumersToRegister.push({
                 queue,
                 callback,
                 options,
@@ -436,18 +479,21 @@ class RabbitMq {
     }
     // Used by the microservices to consume messages from the queue
     async consume(queue, callback, options) {
-        // TODO: USE THE IMPLEMENTATION OF THE NEW CONSUME AND DELETE THE NEW AND OLD
-        if (options?.isQuorumQueue !== false) {
-            await this.assertVHost();
+        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 = (0, utils_1.getAssertVhostExponentialBackoffConfig)();
+            await (0, exponential_backoff_1.backOff)(() => this.assertVHost(), backoffConfig);
             await this.consumeNew(queue, callback, options);
         }
         await this.consumeOld(queue, callback, options);
     }
-    // TODO: DELETE
+    // TODO: [QUORUM-PHASE-3] Delete consumeNew we do not use it anymore
     async consumeNew(queue, callback, options) {
         await this.consumeFromRabbit(queue, callback, options);
     }
-    // TODO: DELETE
+    // TODO: [QUORUM-PHASE-3] Delete consumeOld we do not use it anymore
     async consumeOld(queue, callback, options) {
         await this.consumeFromRabbitOld(queue, callback, options);
     }
@@ -468,26 +514,23 @@ class RabbitMq {
     async consumeFromRabbit(queue, callback, options) {
         const optionsWithDefaults = { ...consts_1.DEFAULT_OPTIONS, ...options };
         RabbitMq.validateName('queue', queue);
-        this.saveConsumer(queue, callback, options);
         const uniqueId = (0, node_crypto_1.randomUUID)();
         const { limit, deadMessageTtl, useConsumeWithLock, lockTimeout, auditContext, enableRabbitTrace, } = optionsWithDefaults;
         if (useConsumeWithLock) {
             if (!this.redisLock) {
-                throw new Error('Usage of consumeWithLock requires RedisInstance');
+                throw new rabbitError_1.default('Usage of consumeWithLock requires RedisInstance');
             }
-            logger_1.default.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
         }
-        const channel = await this.getNewChannel({});
+        const channel = await this.getNewChannel({ connection: this.consumeConnection });
         return channel.addSetup(async (confirmChannel) => {
-            const q = await this.assertQueue(queue, optionsWithDefaults);
+            await this.assertQueue(queue, optionsWithDefaults);
             await confirmChannel.prefetch(limit, false);
             const { consumerTag } = await confirmChannel.consume(queue, async (msg) => {
                 if (!msg) {
                     return null;
                 }
-                const traceId = msg.properties.headers[consts_1.TRACING_HEADER];
-                const userId = msg.properties.headers[consts_1.USER_TRACING_HEADER];
-                const automationId = msg.properties.headers[consts_1.AUTOMATION_ID_HEADER];
+                const { [consts_1.TRACING_HEADER]: traceId, [consts_1.USER_TRACING_HEADER]: userId, [consts_1.AUTOMATION_ID_HEADER]: automationId } = msg.properties.headers ?? {};
                 const parsedMessage = RabbitMq.parseMsg(msg);
                 const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
                 const trace = (0, zehut_1.newTrace)(zehut_1.traceTypes.RABBIT);
@@ -503,7 +546,7 @@ class RabbitMq {
                         ]);
                     }
                     catch (e) {
-                        logger_1.default.error('rabbit: failed to setRabbitTrace', { userId, e });
+                        __classPrivateFieldGet(this, _RabbitMq_logger, "f").error('rabbit: failed to setRabbitTrace', { userId, e });
                         return this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
                     }
                 }
@@ -529,29 +572,29 @@ class RabbitMq {
                         return;
                     }
                     messageAcked = true;
-                    return this.ack(confirmChannel, msg, true, releaseLock)(msg);
+                    await this.ack(confirmChannel, msg, true, releaseLock)(msg);
                 };
                 const localNack = async (_, nackOptions = {}) => {
                     if (messageAcked) {
                         return;
                     }
-                    debug('rabbit localNack', { messageAcked, uniqueId, deliveryTag: msg.fields.deliveryTag });
+                    __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('rabbit localNack', { messageAcked, uniqueId, deliveryTag: msg.fields.deliveryTag });
                     messageAcked = true;
-                    return this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg, nackOptions);
+                    await this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg, nackOptions);
                 };
                 try {
-                    await callback(parsedMessage, localAck, localNack);
+                    return await callback(parsedMessage, localAck, localNack);
                 }
                 catch (e) {
-                    await localNack(msg);
+                    return localNack(msg);
                 }
             }, types_1.CONSUMER_DEFAULT_OPTIONS);
             if (!consumerTag) {
-                logger_1.default.error(`rabbit: failed to consume from queue ${queue}`);
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").error(`rabbit: failed to consume from queue ${queue}`);
             }
             else {
-                logger_1.default.info(`rabbit: adding tag ${consumerTag} to the array.`);
-                this.consumersTags.push([confirmChannel, consumerTag]);
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").info(`rabbit: adding tag ${consumerTag} to the array.`);
+                this.consumersTags.set(queue, { channel: confirmChannel, consumerTag });
             }
         });
     }
@@ -560,11 +603,16 @@ class RabbitMq {
         const optionsWithDefaults = { ...consts_1.DEFAULT_OPTIONS, ...options };
         RabbitMq.validateName('exchange', exchange);
         RabbitMq.validateName('queue', queue);
-        const { limit, deadMessageTtl } = optionsWithDefaults;
-        if (options?.isQuorumQueue !== false) {
-            await this.assertVHost();
+        const { limit } = optionsWithDefaults;
+        // TODO: [QUORUM-PHASE-3] Delete the if statement after all the queues are created as quorum queues
+        if (options?.isQuorumQueue !== false && DISABLE_QUORUM_QUEUES_CONSUME !== 'true') {
             await this.saveConsumer(queue, callback, options);
-            const channel = await this.getNewChannel({ name: `consume-exchange-${exchange}-queue-${queue}` });
+            const backoffConfig = (0, utils_1.getAssertVhostExponentialBackoffConfig)();
+            await (0, exponential_backoff_1.backOff)(() => this.assertVHost(), backoffConfig);
+            const channel = await this.getNewChannel({
+                name: `consume-exchange-${exchange}-queue-${queue}`,
+                connection: this.consumeConnection,
+            });
             await channel.addSetup(async (c) => {
                 const assertExchange = await (0, utils_1.assertExchangeFanout)(c, exchange);
                 await c.assertQueue(queue);
@@ -576,9 +624,12 @@ class RabbitMq {
                 ]);
             });
         }
-        // TODO: DELETE OLD
+        // TODO: [QUORUM-PHASE-3] Delete the old implementation
         await this.saveConsumerOld(queue, callback, options);
-        const channelOld = await this.getNewChannelOld({ name: `consume-exchange-${exchange}-queue-${queue}-old` });
+        const channelOld = await this.getNewChannelOld({
+            name: `consume-exchange-${exchange}-queue-${queue}-old`,
+            connection: this.oldConsumeConnection,
+        });
         await channelOld.addSetup(async (c) => {
             const assertExchange = await (0, utils_1.assertExchangeFanout)(c, exchange);
             await c.assertQueue(queue);
@@ -591,35 +642,33 @@ class RabbitMq {
         });
     }
     // 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, content, customHeaders, isQuorumQueue = true) {
-        // TODO: DELETE THE IF
-        if (isQuorumQueue) {
-            return (0, utils_1.wrapSetImmediate)(async () => {
-                await this.assertVHost();
-                RabbitMq.validateName('exchange', exchange);
-                const channel = await this.assertChannel();
-                await this.assertExchange(exchange);
-                await channel.publish(exchange, '', Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
-            });
-        }
-        // TODO: DELETE THE OLD
-        return (0, utils_1.wrapSetImmediate)(async () => {
+        await (0, promises_1.setImmediate)();
+        if (isQuorumQueue && DISABLE_QUORUM_QUEUES_PUBLISH !== 'true') {
+            await this.assertVHost();
             RabbitMq.validateName('exchange', exchange);
-            const channel = await this.assertChannelOld();
-            await this.assertExchangeOld(exchange);
+            const channel = await this.assertChannel({ connection: this.publishConnection });
+            await this.assertExchange(exchange, this.publishConnection);
             await channel.publish(exchange, '', Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
-        });
+            return;
+        }
+        // TODO: [QUORUM-PHASE-3] Delete the old implementation
+        RabbitMq.validateName('exchange', exchange);
+        const channel = await this.assertChannelOld({ connection: this.oldPublishConnection });
+        await this.assertExchangeOld(exchange, this.oldPublishConnection);
+        await channel.publish(exchange, '', Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
     }
     // Used by the microservices to send messages to the queue
+    // TODO: [QUORUM-PHASE-3] isQuorumQueue flag is not needed anymore because all the queues are created as quorum queues
     async sendToQueue(queue, content, options, customHeaders, isQuorumQueue = true) {
-        // TODO: DELETE THE IF AND THE OLD
-        if (isQuorumQueue) {
+        if (isQuorumQueue && DISABLE_QUORUM_QUEUES_PUBLISH !== 'true') {
             try {
                 await this.assertVHost();
-                await this.assertChannel();
+                await this.assertChannel({ connection: this.publishConnection });
             }
             catch (e) {
-                logger_1.default.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
                 throw e;
             }
             try {
@@ -627,110 +676,127 @@ class RabbitMq {
                 await this.assertQueue(queue, options);
             }
             catch (e) {
-                logger_1.default.error(`rabbit sendToQueue: failed to assert queue ${queue}`, { e });
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").error(`rabbit sendToQueue: failed to assert queue ${queue}`, { e });
                 throw e;
             }
             try {
-                const res = await this.channel?.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
-                debug(`rabbit: sending to queue ${queue}`, { res });
+                const res = await this.publishChannel?.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug(`rabbit: sending to queue ${queue}`, { res });
                 return res;
             }
             catch (e) {
                 const isConnected = await this.isConnected();
-                logger_1.default.error(`rabbit sendToQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").error(`rabbit sendToQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
                 throw e;
             }
         }
         else {
             try {
-                await this.assertChannelOld();
+                await this.assertChannelOld({ connection: this.oldPublishConnection });
             }
             catch (e) {
-                logger_1.default.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").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) {
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").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));
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug(`rabbit: sending to queue ${queue}`, { res });
+                return res;
+            }
+            catch (e) {
+                const isConnected = await this.isConnectedOld();
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").error(`rabbit sendToQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
                 throw e;
             }
-        }
-        try {
-            RabbitMq.validateName('queue', queue);
-            await this.assertQueueOld(queue, options);
-        }
-        catch (e) {
-            logger_1.default.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_1.default.error(`rabbit sendToQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
-            throw e;
         }
     }
     async isConnected() {
-        const connection = await this.getConnection();
-        const isConnected = connection.isConnected();
-        if (!isConnected) {
-            logger_1.default.error('rabbit: isConnected - false');
-            return false;
-        }
-        const channel = await this.assertChannel();
-        try {
-            await Promise.all([
-                channel.waitForConnect(),
-                ...this.consumers.map((c) => channel.checkQueue(c.queue)),
-            ]);
-        }
-        catch (e) {
-            logger_1.default.error('rabbit: isConnected - false');
-            return false;
+        let isConnected = true;
+        // TODO:[QUORUM-PHASE-3] Remove the condition
+        if (!this.gracefulShutdownStarted) {
+            if (DISABLE_QUORUM_QUEUES_CONSUME !== 'true' || DISABLE_QUORUM_QUEUES_PUBLISH !== 'true') {
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").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) {
+                    __classPrivateFieldGet(this, _RabbitMq_logger, "f").error('rabbit: isConnected - false');
+                    return false;
+                }
+                try {
+                    const unRegisteredConsumers = this.consumersToRegister.filter((c) => !this.consumersTags.get(c.queue));
+                    if (unRegisteredConsumers.length > 0) {
+                        const queueNames = unRegisteredConsumers.map((c) => c.queue);
+                        __classPrivateFieldGet(this, _RabbitMq_logger, "f").error('rabbit: found unregistered consumers for queues', {
+                            count: queueNames.length,
+                            queues: queueNames,
+                        });
+                        throw new rabbitError_1.default('Found unregistered consumers');
+                    }
+                    const channel = await this.assertChannel({ connection: this.publishConnection });
+                    await channel.waitForConnect();
+                    await Promise.all(this.consumersToRegister.map((c) => channel.checkQueue(c.queue)));
+                }
+                catch (e) {
+                    __classPrivateFieldGet(this, _RabbitMq_logger, "f").error('rabbit: isConnected - false', { msg: e.message });
+                    return false;
+                }
+            }
+            // TODO:[QUORUM-PHASE-3] Delete the old is connected and adjust the return value to return true
+            isConnected = await this.isConnectedOld();
         }
-        logger_1.default.info('rabbit: isConnected - true');
-        return true;
+        __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug(`rabbit: isConnected - ${isConnected}`);
+        return isConnected;
     }
     async gracefulShutdown(signal) {
-        // TODO: DELETE OLD
-        const tagsNumber = this.consumersTags.length + this.oldConsumersTags.length;
-        logger_1.default.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));
+        // TODO: [QUORUM-PHASE-3] Delete the old implementation they are not needed anymore
+        this.gracefulShutdownStarted = true;
+        const tagsNumber = this.consumersTags.size + this.oldConsumersTags.size;
+        __classPrivateFieldGet(this, _RabbitMq_logger, "f").info(`rabbit: [gracefully-shutdown] received ${signal}! canceling #${tagsNumber} tags...`);
+        const cancelTagPromises = [...this.consumersTags].map(([, { channel, consumerTag }]) => channel.cancel(consumerTag));
+        const cancelTagPromisesOld = [...this.oldConsumersTags].map(([, { channel, consumerTag }]) => channel.cancel(consumerTag));
         // Clean the array to avoid race
-        this.consumersTags = [];
-        this.oldConsumersTags = [];
+        this.consumersTags.clear();
+        this.oldConsumersTags.clear();
         const results = await Promise.allSettled([...cancelTagPromises, ...cancelTagPromisesOld]);
         const rejected = results.filter((p) => p.status === 'rejected');
         if (rejected.length > 0) {
-            logger_1.default.warn(`rabbit: [gracefully-shutdown] #${rejected.length}/${tagsNumber} tags failed to cancel: ${rejected}`);
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").warn(`rabbit: [gracefully-shutdown] #${rejected.length}/${tagsNumber} tags failed to cancel: ${rejected}`);
         }
         else {
-            logger_1.default.info('rabbit: [gracefully-shutdown] all tags successfully canceled.');
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").info('rabbit: [gracefully-shutdown] all tags successfully canceled.');
         }
     }
     async consumeFromRabbitOld(queue, callback, options) {
         const optionsWithDefaults = { ...consts_1.DEFAULT_OPTIONS, ...options };
         RabbitMq.validateName('queue', queue);
-        this.saveConsumerOld(queue, callback, options);
         const uniqueId = (0, node_crypto_1.randomUUID)();
         const { limit, deadMessageTtl, useConsumeWithLock, lockTimeout, auditContext, enableRabbitTrace, } = optionsWithDefaults;
         if (useConsumeWithLock) {
             if (!this.redisLock) {
-                throw new Error('Usage of consumeWithLock requires RedisInstance');
+                throw new rabbitError_1.default('Usage of consumeWithLock requires RedisInstance');
             }
-            logger_1.default.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
         }
-        const channel = await this.getNewChannelOld({});
+        const channel = await this.getNewChannelOld({ connection: this.oldConsumeConnection });
         return channel.addSetup(async (confirmChannel) => {
-            const q = await this.assertQueueOld(queue, optionsWithDefaults);
+            await this.assertQueueOld(queue, optionsWithDefaults);
             await confirmChannel.prefetch(limit, false);
             const { consumerTag } = await confirmChannel.consume(queue, async (msg) => {
                 if (!msg) {
                     return null;
                 }
-                const traceId = msg.properties.headers[consts_1.TRACING_HEADER];
-                const userId = msg.properties.headers[consts_1.USER_TRACING_HEADER];
-                const automationId = msg.properties.headers[consts_1.AUTOMATION_ID_HEADER];
+                const { [consts_1.TRACING_HEADER]: traceId, [consts_1.USER_TRACING_HEADER]: userId, [consts_1.AUTOMATION_ID_HEADER]: automationId } = msg.properties.headers ?? {};
                 const parsedMessage = RabbitMq.parseMsg(msg);
                 const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
                 const trace = (0, zehut_1.newTrace)(zehut_1.traceTypes.RABBIT);
@@ -746,7 +812,7 @@ class RabbitMq {
                         ]);
                     }
                     catch (e) {
-                        logger_1.default.error('rabbit: failed to setRabbitTrace', { userId, e });
+                        __classPrivateFieldGet(this, _RabbitMq_logger, "f").error('rabbit: failed to setRabbitTrace', { userId, e });
                         return this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
                     }
                 }
@@ -772,139 +838,144 @@ class RabbitMq {
                         return;
                     }
                     messageAcked = true;
-                    return this.ack(confirmChannel, msg, true, releaseLock)(msg);
+                    await this.ack(confirmChannel, msg, true, releaseLock)(msg);
                 };
                 const localNack = async (_, nackOptions = {}) => {
                     if (messageAcked) {
                         return;
                     }
-                    debug('rabbit localNack', { messageAcked, uniqueId, deliveryTag: msg.fields.deliveryTag });
+                    __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('rabbit localNack', { messageAcked, uniqueId, deliveryTag: msg.fields.deliveryTag });
                     messageAcked = true;
-                    return this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg, nackOptions);
+                    await this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg, nackOptions);
                 };
                 try {
-                    await callback(parsedMessage, localAck, localNack);
+                    return await callback(parsedMessage, localAck, localNack);
                 }
                 catch (e) {
-                    await localNack(msg);
+                    return localNack(msg);
                 }
             }, types_1.CONSUMER_DEFAULT_OPTIONS);
             if (!consumerTag) {
-                logger_1.default.error(`rabbit: failed to consume from queue ${queue}`);
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").error(`rabbit: failed to consume from queue ${queue} old`);
             }
             else {
-                logger_1.default.info(`rabbit: adding tag ${consumerTag} to the array.`);
-                this.oldConsumersTags.push([confirmChannel, consumerTag]);
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").info(`rabbit: adding tag ${consumerTag} to the array old`);
+                this.oldConsumersTags.set(queue, { channel: confirmChannel, consumerTag });
             }
         });
     }
-    // TODO: DELETE OLD PROPERTIES UNDER THIS LINE
-    async getNewChannelOld({ name = (0, utils_1.rand)().toString(), onClose = null, options = {} } = {}) {
-        let connection;
+    // TODO: [QUORUM-PHASE-3] Delete all the function under this line.
+    async getNewChannelOld({ name = (0, utils_1.rand)().toString(), onClose = null, options = {}, connection, }) {
+        let localConnection;
         try {
-            connection = await this.getConnectionOld();
+            localConnection = await this.getConnectionOld(connection);
         }
         catch (e) {
-            logger_1.default.error(`rabbit: error on get connection for new channel ${name} `, { e });
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").error(`rabbit: error on get connection for new channel ${name} `, { e });
             throw e;
         }
-        const channel = connection.createChannel({ ...options });
-        (0, events_1.once)(channel, 'close').then((args) => {
-            logger_1.default.error(`rabbit: channel ${name} closed`);
+        if (!localConnection) {
+            throw new Error(`rabbit: couldnt get connection for new channel ${name}`);
+        }
+        const channel = localConnection?.createChannel({ ...options });
+        (0, node_events_1.once)(channel, 'close').then((args) => {
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").error(`rabbit: channel ${name} closed`);
             onClose?.(args);
         });
         try {
-            await (0, events_1.once)(channel, 'connect');
-            debug(`rabbit: channel ${name} CONNECTED`);
+            await (0, node_events_1.once)(channel, 'connect');
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug(`rabbit: channel ${name} CONNECTED`);
             return channel;
         }
         catch (err) {
-            logger_1.default.error(`rabbit: channel error ${name} error`, { err });
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").error(`rabbit: channel error ${name} error`, { err });
             throw err;
         }
     }
-    async getConnectionOld() {
-        return new Promise(async (resolve, reject) => {
-            if (this.oldBlockReconnect) {
-                debug('rabbit: block reconnect');
+    async getConnectionOld(connection) {
+        const { amqpConnection: connectionLocal, creatingConnection, connectionCreatedEventName, connectionFailedEventName, blockReconnect, } = connection;
+        if (blockReconnect) {
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('rabbit: block reconnect');
+            // @ts-expect-error we are returning undefined while the function clearly expects a connection.
+            return undefined;
+        }
+        if (connectionLocal !== null) {
+            if (this.options?.disableReconnect || connectionLocal?.isConnected()) {
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('rabbit: connection - is connected');
                 // 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');
+                return connectionLocal;
             }
-            if (this.oldCreatingConnection) {
-                debug('rabbit: creating connection emi');
-                this.oldEm.once(consts_1.CONNECTION_CREATED_CONST, resolve);
-                this.oldEm.once(consts_1.CONNECTION_FAILED_CONST, reject);
-                return;
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('rabbit: connection - reconnecting');
+        }
+        if (creatingConnection) {
+            const [event, value] = await Promise.race([connectionCreatedEventName, connectionFailedEventName].map((e) => (0, node_events_1.once)(this.oldEm, e).then(([result]) => [e, result])));
+            if (event === connectionCreatedEventName) {
+                return value;
             }
-            this.oldCreatingConnection = true;
-            let isResolved = false;
-            // It is import to use it as a function and not as a variable
-            // because of k8s changes the env variables
-            // and we want to use the new values
-            const findServers = () => {
-                const userName = process.env.RABBITMQ_USERNAME || 'guest';
-                const password = process.env.RABBITMQ_PASSWORD || 'guest';
-                const host = this.options?.rabbitHost || process.env.RABBITMQ_SERVICE_HOST || 'localhost';
-                debug('rabbit: creating connection', { host, userName, HEARTBEAT });
-                return [`amqp://${userName}:${password}@${host}?heartbeat=${HEARTBEAT}`];
-            };
-            const defaultUrls = findServers();
-            const connection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
-                findServers,
-            });
-            this.oldConnection = connection;
-            this.oldConnection.on('error', (err) => {
-                logger_1.default.error('rabbit: connection error', { err });
-                if (!isResolved) {
-                    isResolved = true;
-                    reject(err);
-                    this.oldEm.emit(consts_1.CONNECTION_FAILED_CONST, err);
-                }
-            });
-            this.oldConnection.on('connectFailed', (err) => {
-                this.oldConsumersTags = [];
-                logger_1.default.error('rabbit: connection connectFailed', { err });
-                if (!isResolved) {
-                    isResolved = true;
-                    reject(err);
-                    this.oldEm.emit(consts_1.CONNECTION_FAILED_CONST, err);
-                }
-            });
-            this.oldConnection.on('disconnect', ({ err }) => {
-                this.oldConsumersTags = [];
-                debug('rabbit: connection closed');
-                if (this.options?.disableReconnect) {
-                    logger_1.default.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
-                    this.oldBlockReconnect = true;
-                }
-                else {
-                    logger_1.default.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
-                }
-            });
-            this.oldConnection.once('connect', async () => {
-                debug('rabbit: connection established');
-                this.oldCreatingConnection = false;
-                this.oldEm.emit(consts_1.CONNECTION_CREATED_CONST, connection);
+            throw value;
+        }
+        connection.creatingConnection = true;
+        let isResolved = false;
+        // It is import to use it as a function and not as a variable
+        // because of k8s changes the env variables
+        // and we want to use the new values
+        const findServers = () => {
+            const userName = process.env.RABBITMQ_USERNAME || 'guest';
+            const password = process.env.RABBITMQ_PASSWORD || 'guest';
+            const host = this.options?.rabbitHost || process.env.RABBITMQ_SERVICE_HOST || 'localhost';
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('rabbit: creating connection', { host, userName, HEARTBEAT });
+            return [`amqp://${userName}:${password}@${host}?heartbeat=${HEARTBEAT}`];
+        };
+        const defaultUrls = findServers();
+        const newConnection = await (0, amqp_connection_manager_1.connect)(defaultUrls, { findServers });
+        connection.amqpConnection = newConnection;
+        const { promise, reject, resolve } = (0, utils_1.createDeferredPromise)();
+        newConnection.on('error', (err) => {
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").error('rabbit: connection error', { err });
+            if (!isResolved) {
                 isResolved = true;
-                resolve(connection);
-            });
+                reject(err);
+                this.oldEm.emit(connectionFailedEventName, err);
+            }
+        });
+        newConnection.on('connectFailed', (err) => {
+            this.oldConsumersTags.clear();
+            if (typeof err.url === 'string') {
+                err.url = this.maskURL(err.url);
+            }
+            logger_1.default.error('rabbit: connection connectFailed', { err });
+            if (!isResolved) {
+                isResolved = true;
+                reject(err);
+                this.oldEm.emit(connectionFailedEventName, err);
+            }
+        });
+        newConnection.on('disconnect', ({ err }) => {
+            this.oldConsumersTags.clear();
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('rabbit: connection closed');
+            if (this.options?.disableReconnect) {
+                logger_1.default.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
+                connection.blockReconnect = true;
+            }
+            else {
+                logger_1.default.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
+            }
         });
+        newConnection.once('connect', async () => {
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('rabbit: connection established');
+            connection.creatingConnection = false;
+            this.oldEm.emit(connectionCreatedEventName, newConnection);
+            isResolved = true;
+            resolve(newConnection);
+        });
+        return promise;
     }
     saveConsumerOld(queue, callback, options) {
-        const isConsumerExist = this.oldConsumers.some((consumer) => consumer.queue === queue);
+        const isConsumerExist = this.oldConsumersToRegister.some((consumer) => consumer.queue === queue);
         if (!isConsumerExist) {
             logger_1.default.info(`rabbit: consumer: ${queue} saved in consumer array`);
-            this.oldConsumers.push({
+            this.oldConsumersToRegister.push({
                 queue,
                 callback,
                 options,
@@ -912,19 +983,18 @@ class RabbitMq {
         }
     }
     async assertQueueOld(queueName, options) {
+        var _a;
         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);
+        (_a = this.oldQueueSetupPromises)[queueName] || (_a[queueName] = this.setupQueueOld(queueName, options));
         return this.oldQueueSetupPromises[queueName];
     }
     async setupQueueOld(queueName, options) {
         let queue;
+        const connection = this.oldPublishConnection;
         const shouldUseQuorum = RabbitMq.shouldUseQuorum(queueName);
         const localeOptions = {
             ...options,
@@ -936,21 +1006,21 @@ class RabbitMq {
             },
         };
         try {
-            const channel = await this.assertChannelOld();
-            debug('assertQueue->channel.addSetup', { queueName });
+            const channel = await this.assertChannelOld({ connection });
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('assertQueue->channel.addSetup', { queueName });
             await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, localeOptions));
-            debug('assertQueue->channel.assertQueue', { queueName });
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('assertQueue->channel.assertQueue', { queueName });
             queue = await channel.assertQueue(queueName, localeOptions);
         }
         catch (e) {
             logger_1.default.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 });
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('retrying assertQueue', { queueName });
+                const channel = await this.assertChannelOld({ force: true, connection });
+                await this.deleteQueueOld(queueName, connection);
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('retrying assertQueue->channel.addSetup', { queueName });
                 await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, localeOptions));
-                debug('retrying assertQueue->channel.assertQueue', { queueName });
+                __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('retrying assertQueue->channel.assertQueue', { queueName });
                 queue = await channel.assertQueue(queueName, localeOptions);
             }
             else {
@@ -960,37 +1030,41 @@ class RabbitMq {
         this.oldQueues[queueName] = queue;
         return queue;
     }
-    async assertChannelOld({ force = false } = {}) {
-        if (!this.oldPublishChannelSetupPromise) {
-            this.oldPublishChannelSetupPromise = new Promise(async (resolve, reject) => {
-                if (this.oldChannel && !force) {
-                    return resolve(this.oldChannel);
-                }
-                try {
-                    const channel = await this.getNewChannelOld({});
-                    channel.on('error', (err) => {
-                        logger_1.default.error('rabbit: channel error', { err });
-                    });
-                    this.oldChannel = channel;
-                    resolve(channel);
-                }
-                catch (e) {
-                    reject(e);
-                }
+    async assertChannelOld({ force = false, connection }) {
+        if (this.oldPublishChannelSetupPromise) {
+            return this.oldPublishChannelSetupPromise;
+        }
+        const { promise, resolve, reject } = (0, utils_1.createDeferredPromise)();
+        this.oldPublishChannelSetupPromise = promise;
+        if (this.oldPublishChannel && !force) {
+            resolve(this.oldPublishChannel);
+            return promise;
+        }
+        try {
+            const channel = await this.getNewChannelOld({ connection });
+            channel.on('error', (err) => {
+                logger_1.default.error('rabbit: channel error', { err });
             });
+            if (this.oldPublishConnection === connection) {
+                this.oldPublishChannel = channel;
+            }
+            resolve(channel);
         }
-        return this.oldPublishChannelSetupPromise;
+        catch (e) {
+            reject(e);
+        }
+        return promise;
     }
-    async deleteQueueOld(queue) {
+    async deleteQueueOld(queue, connection) {
         RabbitMq.validateName('queue', queue);
-        const channel = await this.assertChannelOld();
+        const channel = await this.assertChannelOld({ connection });
         logger_1.default.info('rabbit: deleting queue', { queue });
         const deleteQueueRes = await channel.deleteQueue(queue);
-        debug('queue deleted', deleteQueueRes);
+        __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('queue deleted', deleteQueueRes);
         return deleteQueueRes;
     }
-    async assertExchangeOld(exchangeName, options) {
-        const channel = await this.assertChannelOld();
+    async assertExchangeOld(exchangeName, connection) {
+        const channel = await this.assertChannelOld({ connection });
         if (this.oldExchanges[exchangeName]) {
             delete this.oldAssertExchangePromises[exchangeName];
             return this.oldExchanges[exchangeName];
@@ -1002,7 +1076,42 @@ class RabbitMq {
         this.oldExchanges[exchangeName] = await this.oldAssertExchangePromises[exchangeName];
         return this.oldExchanges[exchangeName];
     }
+    async isConnectedOld() {
+        if (!this.gracefulShutdownStarted) {
+            __classPrivateFieldGet(this, _RabbitMq_logger, "f").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_1.default.error('rabbit: isConnected old - false');
+                return false;
+            }
+            try {
+                const unRegisteredConsumersOld = this.oldConsumersToRegister.filter((c) => !this.oldConsumersTags.get(c.queue));
+                if (unRegisteredConsumersOld.length > 0) {
+                    const queueNames = unRegisteredConsumersOld.map((c) => c.queue);
+                    logger_1.default.error('rabbit: found unregistered consumers for queues old', {
+                        count: queueNames.length,
+                        queues: queueNames,
+                    });
+                    throw new rabbitError_1.default('Found unregistered consumers old');
+                }
+                const channelOld = await this.assertChannelOld({ connection: this.oldPublishConnection });
+                await channelOld.waitForConnect();
+                await Promise.all(this.oldConsumersToRegister.map((c) => channelOld.checkQueue(c.queue)));
+            }
+            catch (e) {
+                logger_1.default.error('rabbit: isConnected - false old', { msg: e.message });
+                return false;
+            }
+        }
+        return true;
+    }
 }
+_RabbitMq_logger = new WeakMap();
 exports.default = RabbitMq;
 var celery_1 = require("./lib/celery");
 Object.defineProperty(exports, "sendCeleryTaskViaHttp", { enumerable: true, get: function () { return celery_1.sendCeleryTaskViaHttp; } });
+//# sourceMappingURL=index.js.map