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

package/dist/index.js

@@ -56,57 +56,10 @@ class RabbitMq {
             },
         };
     }
-    constructor(options = {}, redisConfig) {
+    constructor(options, redisConfig) {
         this.DISCONNECT_MSG = 'rabbit: connection disconnect';
         this.RECONNECT_MSG = 'rabbit: connection disconnect - reconnecting';
         this.consumers = [];
-        this.doesVHostExist = false;
-        this.vhost = 'quorum-vhost';
-        this.oldConsumers = [];
-        this.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_1.default.info('Vhost exists', { vhost: this.vhost });
-                    return;
-                }
-                if (response.status !== 404) {
-                    logger_1.default.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) {
-                    logger_1.default.error('Failed to create vhost', { response: createResponse });
-                    throw new rabbitError_1.default('Failed to create vhost');
-                }
-                this.doesVHostExist = true;
-                logger_1.default.info('Vhost created', { vhost: this.vhost });
-            }
-            catch (error) {
-                logger_1.default.error('Failed to check or create vhost', { error });
-                throw error;
-            }
-        };
         this.shouldConsumeMessageByTimestamp = async (msg) => {
             if (msg) {
                 const { properties: { headers } } = msg;
@@ -164,10 +117,24 @@ class RabbitMq {
             }
         };
         this.em = new events_1.EventEmitter();
-        this.channel = null;
+        this.publishChannel = null;
         this.publishChannelSetupPromise = null;
-        this.connection = null;
-        this.creatingConnection = false;
+        this.connectionsMap = {
+            [consts_1.ConnectionPurpose.Consume]: {
+                connection: null,
+                creatingConnection: false,
+                connectionCreatedEventName: 'consumeConnectionCreated',
+                connectionFailedEventName: 'consumeConnectionFailed',
+                blockReconnect: false,
+            },
+            [consts_1.ConnectionPurpose.Publish]: {
+                connection: null,
+                creatingConnection: false,
+                connectionCreatedEventName: 'publishConnectionCreated',
+                connectionFailedEventName: 'publishConnectionFailed',
+                blockReconnect: false,
+            },
+        };
         this.exchanges = {};
         this.queues = {};
         this.queueSetupPromises = {};
@@ -188,43 +155,32 @@ class RabbitMq {
                 await this.gracefulShutdown('SIGINT');
             });
         }
-        // TODO: [QUORUM-PHASE-3] Delete the old properties that we use for the old consumers and publishers
-        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() {
+    async getConnection(connectionPurpose) {
         return new Promise(async (resolve, reject) => {
-            if (this.blockReconnect) {
+            const { connection, creatingConnection, connectionCreatedEventName, connectionFailedEventName, blockReconnect, } = this.connectionsMap[connectionPurpose];
+            if (blockReconnect) {
                 debug('rabbit: block reconnect');
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                 // @ts-ignore
                 return resolve();
             }
-            if (this.connection !== null) {
-                if (this.options?.disableReconnect || this.connection?.isConnected()) {
+            if (connection !== null) {
+                if (this.options?.disableReconnect || connection?.isConnected()) {
                     debug('rabbit: connection - is connected');
                     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                     // @ts-ignore
-                    return resolve(this.connection);
+                    return resolve(connection);
                 }
                 debug('rabbit: connection - reconnecting');
             }
-            if (this.creatingConnection) {
+            if (creatingConnection) {
                 debug('rabbit: creating connection emi');
-                this.em.once(consts_1.CONNECTION_CREATED_CONST, resolve);
-                this.em.once(consts_1.CONNECTION_FAILED_CONST, reject);
+                this.em.once(connectionCreatedEventName, resolve);
+                this.em.once(connectionFailedEventName, reject);
                 return;
             }
-            this.creatingConnection = true;
+            this.connectionsMap[connectionPurpose].creatingConnection = true;
             let isResolved = false;
             // It is import to use it as a function and not as a variable
             // because of k8s changes the env variables
@@ -234,60 +190,62 @@ class RabbitMq {
                 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.vhost}?heartbeat=${HEARTBEAT}`];
+                return [`amqp://${userName}:${password}@${host}?heartbeat=${HEARTBEAT}`];
             };
             const defaultUrls = findServers();
-            const connection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
+            const newConnection = await (0, amqp_connection_manager_1.connect)(defaultUrls, {
                 findServers,
             });
-            this.connection = connection;
-            this.connection.on('error', (err) => {
+            this.connectionsMap[connectionPurpose].connection = newConnection;
+            logger_1.default.info(`rabbit: created new connection ${connectionPurpose}`);
+            newConnection.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.em.emit(connectionFailedEventName, err);
                 }
             });
-            this.connection.on('connectFailed', (err) => {
+            newConnection.on('connectFailed', (err) => {
                 this.consumersTags = [];
-                logger_1.default.error('rabbit: connection connectFailed', { err, advice: 'Check if the vhost exist', vhost: this.vhost });
+                logger_1.default.error('rabbit: connection connectFailed', { err });
                 if (!isResolved) {
                     isResolved = true;
                     reject(err);
-                    this.em.emit(consts_1.CONNECTION_FAILED_CONST, err);
+                    this.em.emit(connectionFailedEventName, err);
                 }
             });
-            this.connection.on('disconnect', ({ err }) => {
-                // this.channel = null;
+            newConnection.on('disconnect', ({ err }) => {
                 this.consumersTags = [];
                 debug('rabbit: connection closed');
                 if (this.options?.disableReconnect) {
                     logger_1.default.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
-                    this.blockReconnect = true;
+                    this.connectionsMap[connectionPurpose].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);
+            newConnection.once('connect', async () => {
+                this.connectionsMap[connectionPurpose].creatingConnection = false;
+                this.em.emit(connectionCreatedEventName, newConnection);
                 isResolved = true;
-                resolve(connection);
+                resolve(newConnection);
             });
         });
     }
-    async getNewChannel({ name = (0, utils_1.rand)().toString(), onClose = null, options = {} } = {}) {
+    async getNewChannel({ name = (0, utils_1.rand)().toString(), onClose = null, options = {}, connectionPurpose = consts_1.ConnectionPurpose.Consume, }) {
         let connection;
         try {
-            connection = await this.getConnection();
+            connection = await this.getConnection(connectionPurpose);
         }
         catch (e) {
             logger_1.default.error(`rabbit: error on get connection for new channel ${name} `, { e });
             throw e;
         }
+        if (!connection) {
+            throw new Error(`rabbit: couldnt get connection for new channel ${name}`);
+        }
         const channel = connection.createChannel({ ...options });
         (0, events_1.once)(channel, 'close').then((args) => {
             logger_1.default.error(`rabbit: channel ${name} closed`);
@@ -303,18 +261,22 @@ class RabbitMq {
             throw err;
         }
     }
-    async assertChannel({ force = false } = {}) {
+    async assertChannel({ force = false, connectionPurpose = consts_1.ConnectionPurpose.Consume }) {
+        debug('rabbit: start assert channel', { connectionPurpose, publishPromise: this.publishChannelSetupPromise, channel: this.publishChannel });
         if (!this.publishChannelSetupPromise) {
             this.publishChannelSetupPromise = new Promise(async (resolve, reject) => {
-                if (this.channel && !force) {
-                    return resolve(this.channel);
+                if (this.publishChannel && !force) {
+                    return resolve(this.publishChannel);
                 }
                 try {
-                    const channel = await this.getNewChannel({});
+                    const channel = await this.getNewChannel({ connectionPurpose });
+                    debug('rabbit: new channel got', { connectionPurpose, channel: this.publishChannel });
                     channel.on('error', (err) => {
                         logger_1.default.error('rabbit: channel error', { err });
                     });
-                    this.channel = channel;
+                    if (connectionPurpose === consts_1.ConnectionPurpose.Publish) {
+                        this.publishChannel = channel;
+                    }
                     resolve(channel);
                 }
                 catch (e) {
@@ -324,8 +286,8 @@ class RabbitMq {
         }
         return this.publishChannelSetupPromise;
     }
-    async assertExchange(exchangeName, options) {
-        const channel = await this.assertChannel();
+    async assertExchange(exchangeName, options = { connectionPurpose: consts_1.ConnectionPurpose.Consume }) {
+        const channel = await this.assertChannel({ connectionPurpose: options.connectionPurpose });
         if (this.exchanges[exchangeName]) {
             delete this.assertExchangePromises[exchangeName];
             return this.exchanges[exchangeName];
@@ -337,47 +299,46 @@ class RabbitMq {
         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) {
+    async getQueueLength(queue, connectionPurpose = consts_1.ConnectionPurpose.Consume) {
         RabbitMq.validateName('queue', queue);
-        const { oldChannel: channel } = this;
-        if (!channel) {
-            throw new rabbitError_1.default('channel is not defined');
+        const { connection } = this.connectionsMap[connectionPurpose];
+        const { publishChannel } = this;
+        if (!publishChannel) {
+            throw new Error('channel is not defined');
         }
-        debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
-        return channel?.checkQueue(queue);
+        debug('rabbit: getting queue length', { queue, connected: connection?.isConnected() });
+        return publishChannel?.checkQueue(queue);
     }
-    async deleteQueue(queue) {
+    async deleteQueue(queue, connectionPurpose) {
         RabbitMq.validateName('queue', queue);
-        const channel = await this.assertChannel();
+        const channel = await this.assertChannel({ connectionPurpose });
         logger_1.default.info('rabbit: deleting queue', { queue });
         const deleteQueueRes = await channel.deleteQueue(queue);
         debug('queue deleted', deleteQueueRes);
         return deleteQueueRes;
     }
-    // TODO: [QUORUM-PHASE-2] Change the implementation to the new one
     async bindQueue(queue, exchange) {
-        const channel = await this.assertChannelOld();
+        const channel = await this.assertChannel({ connectionPurpose: consts_1.ConnectionPurpose.Publish });
         await channel.addSetup((setupChannel) => setupChannel.bindQueue(queue, exchange, ''));
         return channel.bindQueue(queue, exchange, '');
     }
     async setupQueue(queueName, options) {
         let queue;
+        const connectionPurpose = consts_1.ConnectionPurpose.Publish;
+        const shouldUseQuorum = RabbitMq.shouldUseQuorum(queueName);
         const localeOptions = {
             ...options,
             durable: true,
             arguments: {
                 ...options?.arguments,
                 'x-consumer-timeout': 1000 * 60 * 60 * 24,
-                'x-queue-type': 'quorum',
+                'x-queue-type': shouldUseQuorum ? 'quorum' : 'classic',
             },
         };
         try {
-            const channel = await this.assertChannel();
+            const channel = await this.assertChannel({ connectionPurpose });
             debug('assertQueue->channel.addSetup', { queueName });
-            await channel.addSetup(async (setupChannel) => {
-                await setupChannel.assertQueue(queueName, localeOptions);
-            });
+            await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, localeOptions));
             debug('assertQueue->channel.assertQueue', { queueName });
             queue = await channel.assertQueue(queueName, localeOptions);
         }
@@ -385,8 +346,8 @@ class RabbitMq {
             logger_1.default.error('rabbit: assertQueue error', { queueName, options, error: e });
             if (!this.options?.dontRetryAssert) {
                 debug('retrying assertQueue', { queueName });
-                const channel = await this.assertChannel({ force: true });
-                await this.deleteQueue(queueName);
+                const channel = await this.assertChannel({ force: true, connectionPurpose });
+                await this.deleteQueue(queueName, connectionPurpose);
                 debug('retrying assertQueue->channel.addSetup', { queueName });
                 await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, localeOptions));
                 debug('retrying assertQueue->channel.assertQueue', { queueName });
@@ -399,7 +360,6 @@ class RabbitMq {
         this.queues[queueName] = queue;
         return queue;
     }
-    // TODO: [QUORUM-PHASE-3] Can be deleted after deleting the old consumers and publishers because all the queues are created us quorum queues
     static shouldUseQuorum(queueName) {
         const envQuorumQueuesWhitelist = process.env.QUORUM_QUEUES_WHITELIST;
         if (envQuorumQueuesWhitelist === '*') {
@@ -412,6 +372,7 @@ class RabbitMq {
         return false;
     }
     async assertQueue(queueName, options) {
+        debug('rabbit: start assert queue', { queueName });
         RabbitMq.validateName('queue', queueName);
         if (this.queues[queueName]) {
             delete this.queueSetupPromises[queueName];
@@ -421,6 +382,7 @@ class RabbitMq {
             return this.queueSetupPromises[queueName];
         }
         this.queueSetupPromises[queueName] = this.setupQueue(queueName, options);
+        debug('rabbit: done assert queue', { queueName });
         return this.queueSetupPromises[queueName];
     }
     saveConsumer(queue, callback, options) {
@@ -434,23 +396,9 @@ class RabbitMq {
             });
         }
     }
-    // Used by the microservices to consume messages from the queue
     async consume(queue, callback, options) {
-        // 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, callback, options) {
         await this.consumeFromRabbit(queue, callback, options);
     }
-    // TODO: [QUORUM-PHASE-3] Delete consumeOld we do not use it anymore
-    async consumeOld(queue, callback, options) {
-        await this.consumeFromRabbitOld(queue, callback, options);
-    }
     async lockRedisIfNeeded(msg, options) {
         const { properties: { headers } } = msg;
         const timestamp = headers?.creationTimestamp;
@@ -473,13 +421,12 @@ class RabbitMq {
         const { limit, deadMessageTtl, useConsumeWithLock, lockTimeout, auditContext, enableRabbitTrace, } = optionsWithDefaults;
         if (useConsumeWithLock) {
             if (!this.redisLock) {
-                throw new rabbitError_1.default('Usage of consumeWithLock requires RedisInstance');
+                throw new Error('Usage of consumeWithLock requires RedisInstance');
             }
             logger_1.default.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
         }
-        const channel = await this.getNewChannel({});
+        const channel = await this.getNewChannel({ connectionPurpose: consts_1.ConnectionPurpose.Consume });
         return channel.addSetup(async (confirmChannel) => {
-            throw new Error('Dummy assertQueue error');
             const q = await this.assertQueue(queue, optionsWithDefaults);
             await confirmChannel.prefetch(limit, false);
             const { consumerTag } = await confirmChannel.consume(queue, async (msg) => {
@@ -556,57 +503,36 @@ class RabbitMq {
             }
         });
     }
-    // Used by the microservices to consume messages from the exchange
     async consumeFromExchange(queue, exchange, callback, options) {
         const optionsWithDefaults = { ...consts_1.DEFAULT_OPTIONS, ...options };
         RabbitMq.validateName('exchange', exchange);
         RabbitMq.validateName('queue', queue);
         const { limit, deadMessageTtl } = optionsWithDefaults;
-        // TODO: [QUORUM-PHASE-3] Delete the if statement after all the queues are created as quorum queues
-        if (options?.isQuorumQueue !== false) {
-            await this.assertVHost();
-            await this.saveConsumer(queue, callback, options);
-            const channel = await this.getNewChannel({ name: `consume-exchange-${exchange}-queue-${queue}` });
-            await channel.addSetup(async (c) => {
-                const assertExchange = await (0, utils_1.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),
-                ]);
-            });
-        }
-        // 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` });
-        await channelOld.addSetup(async (c) => {
+        await this.saveConsumer(queue, callback, options);
+        const channel = await this.getNewChannel({ name: `consume-exchange-${exchange}-queue-${queue}` });
+        return channel.addSetup(async (c) => {
             const assertExchange = await (0, utils_1.assertExchangeFanout)(c, exchange);
             await c.assertQueue(queue);
-            this.oldExchanges[exchange] = assertExchange;
+            this.exchanges[exchange] = assertExchange;
             await c.prefetch(limit, false);
             return Promise.all([
                 c.bindQueue(queue, exchange, ''),
-                this.consumeOld(queue, callback, options),
+                this.consume(queue, callback, options),
             ]);
         });
     }
-    // Used by the microservices to publish messages to the exchange
-    // TODO: [QUORUM-PHASE-2] Change the implementation to the new one
     async publish(exchange, content, customHeaders) {
+        debug('rabbit: start publish msg');
         return (0, utils_1.wrapSetImmediate)(async () => {
             RabbitMq.validateName('exchange', exchange);
-            const channel = await this.assertChannelOld();
-            await this.assertExchangeOld(exchange);
+            const channel = await this.assertChannel({ connectionPurpose: consts_1.ConnectionPurpose.Publish });
+            await this.assertExchange(exchange, { connectionPurpose: consts_1.ConnectionPurpose.Publish });
             await channel.publish(exchange, '', Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
         });
     }
-    // Used by the microservices to send messages to the queue
-    // TODO: [QUORUM-PHASE-2] Change the implementation to the new one
     async sendToQueue(queue, content, options, customHeaders) {
         try {
-            await this.assertChannelOld();
+            await this.assertChannel({ connectionPurpose: consts_1.ConnectionPurpose.Publish });
         }
         catch (e) {
             logger_1.default.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
@@ -614,55 +540,56 @@ class RabbitMq {
         }
         try {
             RabbitMq.validateName('queue', queue);
-            await this.assertQueueOld(queue, options);
+            await this.assertQueue(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));
+            const res = await this.publishChannel?.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
             debug(`rabbit: sending to queue ${queue}`, { res });
             return res;
         }
         catch (e) {
-            const isConnected = await this.isConnected();
-            logger_1.default.error(`rabbit sendToQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
+            logger_1.default.error(`rabbit sendToQueue: failed to send to queue ${queue}`, { e });
             throw e;
         }
     }
-    // TODO: [QUORUM-PHASE-2] After changing the publish from old to new change from the old to the new implementation
     async isConnected() {
-        const connection = await this.getConnectionOld();
-        const isConnected = connection.isConnected();
-        if (!isConnected) {
-            logger_1.default.error('rabbit: isConnected - false');
-            return false;
-        }
-        const channel = await this.assertChannelOld();
-        try {
-            await Promise.all([
-                channel.waitForConnect(),
-                ...this.oldConsumers.map((c) => channel.checkQueue(c.queue)),
-            ]);
-        }
-        catch (e) {
-            logger_1.default.error('rabbit: isConnected - false');
-            return false;
-        }
-        logger_1.default.info('rabbit: isConnected - true');
-        return true;
+        debug('rabbit: start is connected');
+        const isEachConnectionConnected = await Promise.all(Object.keys(this.connectionsMap).map(async (connectionPurpose) => {
+            const connection = await this.getConnection(connectionPurpose);
+            const isConnected = connection?.isConnected();
+            if (!isConnected) {
+                logger_1.default.error('rabbit: isConnected - false', { connectionPurpose });
+                return false;
+            }
+            if (connectionPurpose === consts_1.ConnectionPurpose.Publish) {
+                const channel = await this.assertChannel({ connectionPurpose: connectionPurpose });
+                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;
+                }
+            }
+            logger_1.default.info('rabbit: isConnected - true', { connectionPurpose });
+            return true;
+        }));
+        return isEachConnectionConnected.every((isConnected) => isConnected === true);
     }
     async gracefulShutdown(signal) {
-        // 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;
+        const tagsNumber = this.consumersTags.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));
         // Clean the array to avoid race
         this.consumersTags = [];
-        this.oldConsumersTags = [];
-        const results = await Promise.allSettled([...cancelTagPromises, ...cancelTagPromisesOld]);
+        const results = await Promise.allSettled(cancelTagPromises);
         const rejected = results.filter((p) => p.status === 'rejected');
         if (rejected.length > 0) {
             logger_1.default.warn(`rabbit: [gracefully-shutdown] #${rejected.length}/${tagsNumber} tags failed to cancel: ${rejected}`);
@@ -671,300 +598,6 @@ class RabbitMq {
             logger_1.default.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 rabbitError_1.default('Usage of consumeWithLock requires RedisInstance');
-            }
-            logger_1.default.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
-        }
-        const channel = await this.getNewChannelOld({});
-        return channel.addSetup(async (confirmChannel) => {
-            const q = 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 parsedMessage = RabbitMq.parseMsg(msg);
-                const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
-                const trace = (0, zehut_1.newTrace)(zehut_1.traceTypes.RABBIT);
-                // setting also outbreak trace as part of legacy code
-                const outbreakTrace = zehut_1.outbreak.newTrace(zehut_1.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([
-                            (0, zehut_1.createOrSetRabbitTrace)(trace, userId),
-                            (0, zehut_1.createOrSetRabbitTrace)(outbreakTrace, userId),
-                        ]);
-                    }
-                    catch (e) {
-                        logger_1.default.error('rabbit: failed to setRabbitTrace', { userId, e });
-                        return this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
-                    }
-                }
-                if (traceId) {
-                    trace?.context?.set(consts_1.TRACING_HEADER, traceId);
-                    outbreakTrace?.context.set(consts_1.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 (_, 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);
-                }
-            }, types_1.CONSUMER_DEFAULT_OPTIONS);
-            if (!consumerTag) {
-                logger_1.default.error(`rabbit: failed to consume from queue ${queue}`);
-            }
-            else {
-                logger_1.default.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 = (0, utils_1.rand)().toString(), onClose = null, options = {} } = {}) {
-        let connection;
-        try {
-            connection = await this.getConnectionOld();
-        }
-        catch (e) {
-            logger_1.default.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`);
-            onClose?.(args);
-        });
-        try {
-            await (0, events_1.once)(channel, 'connect');
-            debug(`rabbit: channel ${name} CONNECTED`);
-            return channel;
-        }
-        catch (err) {
-            logger_1.default.error(`rabbit: channel error ${name} error`, { err });
-            throw err;
-        }
-    }
-    async getConnectionOld() {
-        return new Promise(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(consts_1.CONNECTION_CREATED_CONST, resolve);
-                this.oldEm.once(consts_1.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 = 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);
-                isResolved = true;
-                resolve(connection);
-            });
-        });
-    }
-    saveConsumerOld(queue, callback, options) {
-        const isConsumerExist = this.oldConsumers.some((consumer) => consumer.queue === queue);
-        if (!isConsumerExist) {
-            logger_1.default.info(`rabbit: consumer: ${queue} saved in consumer array`);
-            this.oldConsumers.push({
-                queue,
-                callback,
-                options,
-            });
-        }
-    }
-    async assertQueueOld(queueName, options) {
-        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, options) {
-        let queue;
-        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 = await this.assertChannelOld();
-            debug('assertQueue->channel.addSetup', { queueName });
-            await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, localeOptions));
-            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 });
-                await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, localeOptions));
-                debug('retrying assertQueue->channel.assertQueue', { queueName });
-                queue = await channel.assertQueue(queueName, localeOptions);
-            }
-            else {
-                throw e;
-            }
-        }
-        this.oldQueues[queueName] = queue;
-        return queue;
-    }
-    async assertChannelOld({ force = false } = {}) {
-        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);
-                }
-            });
-        }
-        return this.oldPublishChannelSetupPromise;
-    }
-    async deleteQueueOld(queue) {
-        RabbitMq.validateName('queue', queue);
-        const channel = await this.assertChannelOld();
-        logger_1.default.info('rabbit: deleting queue', { queue });
-        const deleteQueueRes = await channel.deleteQueue(queue);
-        debug('queue deleted', deleteQueueRes);
-        return deleteQueueRes;
-    }
-    async assertExchangeOld(exchangeName, options) {
-        const channel = 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] = (0, utils_1.assertExchangeFanout)(channel, exchangeName);
-        this.oldExchanges[exchangeName] = await this.oldAssertExchangePromises[exchangeName];
-        return this.oldExchanges[exchangeName];
-    }
 }
 exports.default = RabbitMq;
 var celery_1 = require("./lib/celery");