@autofleet/rabbit 4.1.1 → 5.0.1

package/dist/index.js

@@ -1,1117 +1,1117 @@
-"use strict";
-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;
+import { env } from "node:process";
+import { setImmediate } from "node:timers/promises";
+import { EventEmitter, once } from "node:events";
+import moment from "moment";
+import RedisLock from "redis-lock";
+import { connect } from "amqp-connection-manager";
+import { backOff } from "exponential-backoff";
+import { CONTEXTS_IDS_HEADER, createOrSetRabbitTrace, getUser, newTrace, outbreak, traceTypes } from "@autofleet/zehut";
+import { randomUUID } from "node:crypto";
+import Logger from "@autofleet/logger";
+import { createClient } from "redis";
+
+//#region src/logger.ts
+const logger = Logger();
+var logger_default = logger;
+
+//#endregion
+//#region src/lib/rabbitError.ts
+var RabbitError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "RabbitError";
+	}
 };
-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);
+
+//#endregion
+//#region src/lib/redis.ts
+const getRedisInstance = (config$1) => createClient({ socket: config$1 });
+var redis_default = getRedisInstance;
+
+//#endregion
+//#region src/lib/consts.ts
+const DEFAULT_DEAD_TTL_TWO_DAYS = 6e4 * 60 * 12;
+const DEFAULT_LOCK_TIMEOUT = 1e3 * 5;
+const RETRY_HEADER = "x-retry-count";
+const TRACING_HEADER = "x-trace-id";
+const USER_TRACING_HEADER = "x-af-user-id";
+const AUTOMATION_ID_HEADER = "x-af-automation-id";
+const DEFAULT_USE_CONSUME_WITH_LOCK = false;
+const DEFAULT_OPTIONS = {
+	limit: 1,
+	retries: 1,
+	deadMessageTtl: DEFAULT_DEAD_TTL_TWO_DAYS,
+	lockTimeout: DEFAULT_LOCK_TIMEOUT,
+	useConsumeWithLock: DEFAULT_USE_CONSUME_WITH_LOCK,
+	auditContext: null,
+	enableRabbitTrace: false
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+const ASSERT_VHOST_EXPONENTIAL_BACKOFF_DEV_ENV_CONFIG = {
+	startingDelay: 500,
+	timeMultiple: 4,
+	numOfAttempts: 5
 };
-var _RabbitMq_logger;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendCeleryTaskViaHttp = void 0;
-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 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 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.toString();
-        try {
-            content = JSON.parse(content);
-        }
-        catch { /* ignore error */ }
-        return {
-            ...msg,
-            content,
-        };
-    }
-    static validateName(type, name) {
-        if (!name || name === '') {
-            throw new rabbitError_1.default(`error while using ${type} with no name`);
-        }
-    }
-    static getPublishOptions(customHeaders = {}) {
-        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,
-            headers: {
-                creationTimestamp: (0, moment_1.default)().valueOf(),
-                ...customHeaders,
-                [consts_1.USER_TRACING_HEADER]: user?.id,
-                [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.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.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;
-                    __classPrivateFieldGet(this, _RabbitMq_logger, "f").info('Vhost exists', { vhost: this.vhost });
-                    return;
-                }
-                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) {
-                __classPrivateFieldGet(this, _RabbitMq_logger, "f").error('Failed to check or create vhost', { error });
-                throw error;
-            }
-        };
-        this.shouldConsumeMessageByTimestamp = async (msg) => {
-            if (msg) {
-                const { headers } = msg.properties;
-                const timestamp = headers?.creationTimestamp;
-                if (timestamp && headers?.redisTimestampValidationKey && this.redisClient) {
-                    const key = this.getRedisKey(headers.redisTimestampValidationKey);
-                    const lastMessageTimestamp = await this.redisClient.get(key);
-                    return !lastMessageTimestamp || (parseInt(lastMessageTimestamp, 10) <= parseInt(timestamp, 10));
-                }
-                return true;
-            }
-            return false;
-        };
-        this.ack = (channel, msg, shouldUpdateRedisTimestamp = false, releaseLock = null) => async (userMsg) => {
-            if (msg) {
-                __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('rabbit acking message', { deliveryTag: msg.fields.deliveryTag });
-                await channel.ack(msg);
-                const { headers } = msg.properties;
-                const timestamp = headers?.creationTimestamp;
-                if (shouldUpdateRedisTimestamp && timestamp && headers?.redisTimestampValidationKey && this.redisClient) {
-                    const parsedTimestamp = parseInt(timestamp, 10);
-                    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) {
-                __classPrivateFieldGet(this, _RabbitMq_logger, "f").error('no channel or msg', { msg });
-                return;
-            }
-            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;
-            }
-        };
-        __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);
-        }
-        __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');
-            });
-            process.on('SIGINT', async () => {
-                await this.gracefulShutdown('SIGINT');
-            });
-        }
-    }
-    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;
-            }
-            __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;
-            }
-            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;
-                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 = {}, connection, }) {
-        let localConnection;
-        try {
-            localConnection = await this.getConnection(connection);
-        }
-        catch (e) {
-            __classPrivateFieldGet(this, _RabbitMq_logger, "f").error(`rabbit: error on get connection for new channel ${name} `, { e });
-            throw e;
-        }
-        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, node_events_1.once)(channel, 'connect');
-            __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug(`rabbit: channel ${name} CONNECTED`);
-            return channel;
-        }
-        catch (err) {
-            __classPrivateFieldGet(this, _RabbitMq_logger, "f").error(`rabbit: channel error ${name} error`, { err });
-            throw err;
-        }
-    }
-    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 promise;
-    }
-    async assertExchange(exchangeName, connection) {
-        const channel = await this.assertChannel({ connection });
-        if (this.exchanges[exchangeName]) {
-            delete this.assertExchangePromises[exchangeName];
-            return this.exchanges[exchangeName];
-        }
-        if (this.assertExchangePromises[exchangeName]) {
-            return this.assertExchangePromises[exchangeName];
-        }
-        this.assertExchangePromises[exchangeName] = (0, utils_1.assertExchangeFanout)(channel, exchangeName);
-        this.exchanges[exchangeName] = await this.assertExchangePromises[exchangeName];
-        return this.exchanges[exchangeName];
-    }
-    async getQueueLength(queue) {
-        RabbitMq.validateName('queue', queue);
-        const { publishChannel: channel } = this;
-        if (!channel) {
-            throw new rabbitError_1.default('channel is not defined');
-        }
-        __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('rabbit: getting queue length', { queue, connected: this.publishConnection.amqpConnection?.isConnected() });
-        return channel?.checkQueue(queue);
-    }
-    async deleteQueue(queue, connection) {
-        RabbitMq.validateName('queue', queue);
-        const channel = await this.assertChannel({ connection });
-        __classPrivateFieldGet(this, _RabbitMq_logger, "f").info('rabbit: deleting queue', { queue });
-        const deleteQueueRes = await channel.deleteQueue(queue);
-        __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('queue deleted', deleteQueueRes);
-        return deleteQueueRes;
-    }
-    async bindQueue(queue, exchange) {
-        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,
-            arguments: {
-                ...options?.arguments,
-                'x-consumer-timeout': 1000 * 60 * 60 * 24,
-                'x-queue-type': 'quorum',
-            },
-        };
-        try {
-            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);
-            });
-            __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('assertQueue->channel.assertQueue', { queueName });
-            queue = await channel.assertQueue(queueName, localeOptions);
-        }
-        catch (e) {
-            __classPrivateFieldGet(this, _RabbitMq_logger, "f").error('rabbit: assertQueue error', { queueName, options, error: e });
-            if (!this.options?.dontRetryAssert) {
-                __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));
-                __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('retrying assertQueue->channel.assertQueue', { queueName });
-                queue = await channel.assertQueue(queueName, localeOptions);
-            }
-            else {
-                throw e;
-            }
-        }
-        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 === '*') {
-            return true;
-        }
-        if (envQuorumQueuesWhitelist) {
-            const whitelist = envQuorumQueuesWhitelist.split(',');
-            return whitelist.includes(queueName);
-        }
-        return false;
-    }
-    async assertQueue(queueName, options) {
-        var _a;
-        RabbitMq.validateName('queue', queueName);
-        if (this.queues[queueName]) {
-            delete this.queueSetupPromises[queueName];
-            return this.queues[queueName];
-        }
-        (_a = this.queueSetupPromises)[queueName] || (_a[queueName] = this.setupQueue(queueName, options));
-        return this.queueSetupPromises[queueName];
-    }
-    saveConsumer(queue, callback, options) {
-        const isConsumerExist = this.consumersToRegister.some((consumer) => consumer.queue === queue);
-        if (!isConsumerExist) {
-            __classPrivateFieldGet(this, _RabbitMq_logger, "f").info(`rabbit: consumer: ${queue} saved in consumer array`);
-            this.consumersToRegister.push({
-                queue,
-                callback,
-                options,
-            });
-        }
-    }
-    // Used by the microservices to consume messages from the queue
-    async consume(queue, callback, options) {
-        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: [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;
-        let releaseLock = null;
-        if (options.useConsumeWithLock && timestamp && headers?.redisTimestampValidationKey && this.redisLock) {
-            releaseLock = await this.redisLock(headers.redisTimestampValidationKey, options?.lockTimeout || consts_1.DEFAULT_LOCK_TIMEOUT);
-        }
-        return releaseLock;
-    }
-    async unlockRedisIfNeeded(releaseLock) {
-        if (this.redisLock && releaseLock) {
-            await releaseLock();
-        }
-    }
-    async consumeFromRabbit(queue, callback, options) {
-        const optionsWithDefaults = { ...consts_1.DEFAULT_OPTIONS, ...options };
-        RabbitMq.validateName('queue', queue);
-        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');
-            }
-            __classPrivateFieldGet(this, _RabbitMq_logger, "f").info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
-        }
-        const channel = await this.getNewChannel({ connection: this.consumeConnection });
-        return channel.addSetup(async (confirmChannel) => {
-            await this.assertQueue(queue, optionsWithDefaults);
-            await confirmChannel.prefetch(limit, false);
-            const { consumerTag } = await confirmChannel.consume(queue, async (msg) => {
-                if (!msg) {
-                    return null;
-                }
-                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);
-                // 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) {
-                        __classPrivateFieldGet(this, _RabbitMq_logger, "f").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;
-                    await this.ack(confirmChannel, msg, true, releaseLock)(msg);
-                };
-                const localNack = async (_, nackOptions = {}) => {
-                    if (messageAcked) {
-                        return;
-                    }
-                    __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('rabbit localNack', { messageAcked, uniqueId, deliveryTag: msg.fields.deliveryTag });
-                    messageAcked = true;
-                    await this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg, nackOptions);
-                };
-                try {
-                    return await callback(parsedMessage, localAck, localNack);
-                }
-                catch (e) {
-                    return localNack(msg);
-                }
-            }, types_1.CONSUMER_DEFAULT_OPTIONS);
-            if (!consumerTag) {
-                __classPrivateFieldGet(this, _RabbitMq_logger, "f").error(`rabbit: failed to consume from queue ${queue}`);
-            }
-            else {
-                __classPrivateFieldGet(this, _RabbitMq_logger, "f").info(`rabbit: adding tag ${consumerTag} to the array.`);
-                this.consumersTags.set(queue, { channel: confirmChannel, consumerTag });
-            }
-        });
-    }
-    // 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 } = 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 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);
-                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`,
-            connection: this.oldConsumeConnection,
-        });
-        await channelOld.addSetup(async (c) => {
-            const assertExchange = await (0, utils_1.assertExchangeFanout)(c, exchange);
-            await c.assertQueue(queue);
-            this.oldExchanges[exchange] = assertExchange;
-            await c.prefetch(limit, false);
-            return Promise.all([
-                c.bindQueue(queue, exchange, ''),
-                this.consumeOld(queue, callback, options),
-            ]);
-        });
-    }
-    // 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) {
-        await (0, promises_1.setImmediate)();
-        if (isQuorumQueue && DISABLE_QUORUM_QUEUES_PUBLISH !== 'true') {
-            await this.assertVHost();
-            RabbitMq.validateName('exchange', 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) {
-        if (isQuorumQueue && DISABLE_QUORUM_QUEUES_PUBLISH !== 'true') {
-            try {
-                await this.assertVHost();
-                await this.assertChannel({ connection: this.publishConnection });
-            }
-            catch (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.assertQueue(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.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();
-                __classPrivateFieldGet(this, _RabbitMq_logger, "f").error(`rabbit sendToQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
-                throw e;
-            }
-        }
-        else {
-            try {
-                await this.assertChannelOld({ connection: this.oldPublishConnection });
-            }
-            catch (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;
-            }
-        }
-    }
-    async isConnected() {
-        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();
-        }
-        __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug(`rabbit: isConnected - ${isConnected}`);
-        return isConnected;
-    }
-    async gracefulShutdown(signal) {
-        // 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.clear();
-        this.oldConsumersTags.clear();
-        const results = await Promise.allSettled([...cancelTagPromises, ...cancelTagPromisesOld]);
-        const rejected = results.filter((p) => p.status === 'rejected');
-        if (rejected.length > 0) {
-            __classPrivateFieldGet(this, _RabbitMq_logger, "f").warn(`rabbit: [gracefully-shutdown] #${rejected.length}/${tagsNumber} tags failed to cancel: ${rejected}`);
-        }
-        else {
-            __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);
-        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');
-            }
-            __classPrivateFieldGet(this, _RabbitMq_logger, "f").info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
-        }
-        const channel = await this.getNewChannelOld({ connection: this.oldConsumeConnection });
-        return channel.addSetup(async (confirmChannel) => {
-            await this.assertQueueOld(queue, optionsWithDefaults);
-            await confirmChannel.prefetch(limit, false);
-            const { consumerTag } = await confirmChannel.consume(queue, async (msg) => {
-                if (!msg) {
-                    return null;
-                }
-                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);
-                // 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) {
-                        __classPrivateFieldGet(this, _RabbitMq_logger, "f").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;
-                    await this.ack(confirmChannel, msg, true, releaseLock)(msg);
-                };
-                const localNack = async (_, nackOptions = {}) => {
-                    if (messageAcked) {
-                        return;
-                    }
-                    __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('rabbit localNack', { messageAcked, uniqueId, deliveryTag: msg.fields.deliveryTag });
-                    messageAcked = true;
-                    await this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg, nackOptions);
-                };
-                try {
-                    return await callback(parsedMessage, localAck, localNack);
-                }
-                catch (e) {
-                    return localNack(msg);
-                }
-            }, types_1.CONSUMER_DEFAULT_OPTIONS);
-            if (!consumerTag) {
-                __classPrivateFieldGet(this, _RabbitMq_logger, "f").error(`rabbit: failed to consume from queue ${queue} old`);
-            }
-            else {
-                __classPrivateFieldGet(this, _RabbitMq_logger, "f").info(`rabbit: adding tag ${consumerTag} to the array old`);
-                this.oldConsumersTags.set(queue, { channel: confirmChannel, consumerTag });
-            }
-        });
-    }
-    // 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 {
-            localConnection = await this.getConnectionOld(connection);
-        }
-        catch (e) {
-            __classPrivateFieldGet(this, _RabbitMq_logger, "f").error(`rabbit: error on get connection for new channel ${name} `, { e });
-            throw e;
-        }
-        if (!localConnection) {
-            throw new Error(`rabbit: couldnt get connection for new channel ${name}`);
-        }
-        const channel = localConnection?.createChannel({ ...options });
-        (0, node_events_1.once)(channel, 'close').then((args) => {
-            __classPrivateFieldGet(this, _RabbitMq_logger, "f").error(`rabbit: channel ${name} closed`);
-            onClose?.(args);
-        });
-        try {
-            await (0, node_events_1.once)(channel, 'connect');
-            __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug(`rabbit: channel ${name} CONNECTED`);
-            return channel;
-        }
-        catch (err) {
-            __classPrivateFieldGet(this, _RabbitMq_logger, "f").error(`rabbit: channel error ${name} error`, { err });
-            throw err;
-        }
-    }
-    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 connectionLocal;
-            }
-            __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;
-            }
-            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;
-                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.oldConsumersToRegister.some((consumer) => consumer.queue === queue);
-        if (!isConsumerExist) {
-            logger_1.default.info(`rabbit: consumer: ${queue} saved in consumer array`);
-            this.oldConsumersToRegister.push({
-                queue,
-                callback,
-                options,
-            });
-        }
-    }
-    async assertQueueOld(queueName, options) {
-        var _a;
-        RabbitMq.validateName('queue', queueName);
-        if (this.oldQueues[queueName]) {
-            delete this.oldQueueSetupPromises[queueName];
-            return this.oldQueues[queueName];
-        }
-        (_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,
-            durable: true,
-            arguments: {
-                ...options?.arguments,
-                'x-consumer-timeout': 1000 * 60 * 60 * 24,
-                'x-queue-type': shouldUseQuorum ? 'quorum' : 'classic',
-            },
-        };
-        try {
-            const channel = await this.assertChannelOld({ connection });
-            __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('assertQueue->channel.addSetup', { queueName });
-            await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, localeOptions));
-            __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) {
-                __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));
-                __classPrivateFieldGet(this, _RabbitMq_logger, "f").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, 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);
-        }
-        catch (e) {
-            reject(e);
-        }
-        return promise;
-    }
-    async deleteQueueOld(queue, connection) {
-        RabbitMq.validateName('queue', queue);
-        const channel = await this.assertChannelOld({ connection });
-        logger_1.default.info('rabbit: deleting queue', { queue });
-        const deleteQueueRes = await channel.deleteQueue(queue);
-        __classPrivateFieldGet(this, _RabbitMq_logger, "f").debug('queue deleted', deleteQueueRes);
-        return deleteQueueRes;
-    }
-    async assertExchangeOld(exchangeName, connection) {
-        const channel = await this.assertChannelOld({ connection });
-        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];
-    }
-    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;
-    }
+const ASSERT_VHOST_EXPONENTIAL_BACKOFF_PROD_CONFIG = {
+	startingDelay: 1,
+	timeMultiple: 1,
+	numOfAttempts: 5
+};
+
+//#endregion
+//#region src/lib/utils.ts
+const { PROJECT_ID } = process.env;
+const assertExchangeFanout = async (c, exchangeName) => c.assertExchange(exchangeName, "fanout");
+const rand = () => Math.floor(Math.random() * 1e5);
+/** This is polyfill for `Promise.withResolvers` which exists only on Node v22 and onwards */
+const createDeferredPromise = () => {
+	if (Promise.withResolvers) return Promise.withResolvers();
+	let resolve;
+	let reject;
+	const promise = new Promise((res, rej) => {
+		resolve = res;
+		reject = rej;
+	});
+	return {
+		promise,
+		resolve,
+		reject
+	};
+};
+const isDevEnv = () => ["af-experiment-manager", "dev1-experiment-manager"].includes(PROJECT_ID || "");
+const getAssertVhostExponentialBackoffConfig = () => isDevEnv() ? ASSERT_VHOST_EXPONENTIAL_BACKOFF_DEV_ENV_CONFIG : ASSERT_VHOST_EXPONENTIAL_BACKOFF_PROD_CONFIG;
+
+//#endregion
+//#region src/lib/types.ts
+const HA_PROMOTE_ON_FAILURE = "ha-promote-on-failure";
+const HA_PROMOTE_ON_SHUTDOWN = "ha-promote-on-shutdown";
+const CONSUMER_DEFAULT_OPTIONS = { arguments: {
+	[HA_PROMOTE_ON_FAILURE]: "always",
+	[HA_PROMOTE_ON_SHUTDOWN]: "always"
+} };
+
+//#endregion
+//#region src/lib/celery.ts
+const config = {
+	host: process.env.RABBITMQ_SERVICE_HOST || "localhost",
+	username: process.env.RABBITMQ_USERNAME || "guest",
+	password: process.env.RABBITMQ_PASSWORD || "guest"
+};
+async function sendCeleryTaskViaHttp(data, { taskName, queueName }) {
+	const apiUrl = `http://${config.host}:15672/api/exchanges/%2f/amq.default/publish`;
+	const message = {
+		task: taskName,
+		id: randomUUID(),
+		args: [data]
+	};
+	const payload = {
+		properties: {
+			delivery_mode: 2,
+			content_type: "application/json"
+		},
+		routing_key: queueName,
+		payload: JSON.stringify(message),
+		payload_encoding: "string"
+	};
+	try {
+		const response = await fetch(apiUrl, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Basic ${Buffer.from(`${config.username}:${config.password}`).toString("base64")}`
+			},
+			body: JSON.stringify(payload)
+		});
+		if (response.ok) {
+			const result = await response.json();
+			logger_default.info("Successfully published message:", result);
+		} else {
+			logger_default.error(`Failed to publish message. Status code: ${response.status}`);
+			logger_default.error(`Response: ${await response.text()}`);
+		}
+	} catch (error) {
+		logger_default.error("Error sending request:", error instanceof Error ? error.message : String(error));
+		throw error;
+	}
 }
-_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; } });
+
+//#endregion
+//#region src/index.ts
+const PUBLISH_TIMEOUT = 1e3 * 10;
+const { DISABLE_QUORUM_QUEUES_CONSUME, DISABLE_QUORUM_QUEUES_PUBLISH } = env;
+const HEARTBEAT = "60";
+var RabbitMq = class RabbitMq {
+	static parseMsg(msg) {
+		let content = msg.content.toString();
+		try {
+			content = JSON.parse(content);
+		} catch {}
+		return {
+			...msg,
+			content
+		};
+	}
+	static validateName(type, name) {
+		if (!name || name === "") throw new RabbitError(`error while using ${type} with no name`);
+	}
+	static getPublishOptions(customHeaders = {}) {
+		const user = getUser();
+		const traceId = outbreak.getCurrentContextTraceId();
+		return {
+			timestamp: moment().unix(),
+			timeout: PUBLISH_TIMEOUT,
+			headers: {
+				creationTimestamp: moment().valueOf(),
+				...customHeaders,
+				[USER_TRACING_HEADER]: user?.id,
+				[CONTEXTS_IDS_HEADER]: user?.contextIds,
+				[TRACING_HEADER]: traceId
+			}
+		};
+	}
+	DISCONNECT_MSG = "rabbit: connection disconnect";
+	RECONNECT_MSG = "rabbit: connection disconnect - reconnecting";
+	publishChannel = null;
+	publishChannelSetupPromise = null;
+	publishConnection = {
+		amqpConnection: null,
+		creatingConnection: false,
+		connectionCreatedEventName: "publishConnectionCreated",
+		connectionFailedEventName: "publishConnectionFailed",
+		blockReconnect: false
+	};
+	consumeConnection = {
+		amqpConnection: null,
+		creatingConnection: false,
+		connectionCreatedEventName: "consumeConnectionCreated",
+		connectionFailedEventName: "consumeConnectionFailed",
+		blockReconnect: false
+	};
+	em = new EventEmitter();
+	exchanges = {};
+	queues = {};
+	queueSetupPromises = {};
+	assertExchangePromises = {};
+	redisClient;
+	redisLock;
+	/** A map of consumers' tags used for canceling consumption */
+	consumersTags = /* @__PURE__ */ new Map();
+	consumersToRegister = [];
+	doesVHostExist = false;
+	vhost = "quorum-vhost";
+	gracefulShutdownStarted = false;
+	oldPublishChannel = null;
+	oldPublishChannelSetupPromise = null;
+	oldPublishConnection = {
+		amqpConnection: null,
+		creatingConnection: false,
+		connectionCreatedEventName: "oldPublishConnectionCreated",
+		connectionFailedEventName: "oldPublishConnectionFailed",
+		blockReconnect: false
+	};
+	oldConsumeConnection = {
+		amqpConnection: null,
+		creatingConnection: false,
+		connectionCreatedEventName: "oldConsumeConnectionCreated",
+		connectionFailedEventName: "oldConsumeConnectionFailed",
+		blockReconnect: false
+	};
+	oldEm = new EventEmitter();
+	oldExchanges = {};
+	oldQueues = {};
+	oldQueueSetupPromises = {};
+	oldAssertExchangePromises = {};
+	oldConsumersTags = /* @__PURE__ */ new Map();
+	oldConsumersToRegister = [];
+	#logger;
+	constructor(options = {}, redisConfig) {
+		this.options = options;
+		this.redisConfig = redisConfig;
+		this.#logger = options?.logger || logger_default;
+		if (redisConfig) {
+			this.redisClient = redis_default(redisConfig).on("error", (err) => {
+				this.#logger.error("rabbit: Redis error", {
+					err,
+					redisConfig
+				});
+			});
+			this.redisClient.connect().catch((err) => {
+				this.#logger.error("rabbit: Failed to connect to Redis", {
+					err,
+					redisConfig
+				});
+			});
+			this.redisLock = RedisLock(this.redisClient);
+		}
+		this.#logger.info(`rabbit: [gracefully-shutdown] adding gracefully shutdown for process.pid ${process.pid}`);
+		if (!this.options?.dontGracefulShutdown) {
+			process.on("SIGTERM", async () => {
+				await this.gracefulShutdown("SIGTERM");
+			});
+			process.on("SIGINT", async () => {
+				await this.gracefulShutdown("SIGINT");
+			});
+		}
+	}
+	getRedisKey(key) {
+		return `${this.redisConfig?.prefix || ""}${key}`;
+	}
+	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;
+				this.#logger.info("Vhost exists", { vhost: this.vhost });
+				return;
+			}
+			if (response.status !== 404) {
+				this.#logger.error("Failed to check vhost", { response });
+				throw new RabbitError("Failed to check vhost");
+			}
+			const createResponse = await fetch(url, {
+				method: "PUT",
+				headers,
+				body: JSON.stringify({ default_queue_type: "quorum" })
+			});
+			if (!createResponse.ok) {
+				this.#logger.error("Failed to create vhost", { response: createResponse });
+				throw new RabbitError("Failed to create vhost");
+			}
+			this.doesVHostExist = true;
+			this.#logger.info("Vhost created", { vhost: this.vhost });
+		} catch (error) {
+			this.#logger.error("Failed to check or create vhost", { error });
+			throw error;
+		}
+	};
+	shouldConsumeMessageByTimestamp = async (msg) => {
+		if (!msg) return false;
+		const { headers } = msg.properties;
+		const timestamp = headers?.creationTimestamp;
+		if (timestamp && headers?.redisTimestampValidationKey && this.redisClient) {
+			const key = this.getRedisKey(headers.redisTimestampValidationKey);
+			const lastMessageTimestamp = await this.redisClient.get(key);
+			return !lastMessageTimestamp || parseInt(lastMessageTimestamp, 10) <= parseInt(timestamp, 10);
+		}
+		return true;
+	};
+	ack = (channel, msg, shouldUpdateRedisTimestamp = false, releaseLock = null) => async (userMsg) => {
+		if (!msg) return;
+		this.#logger.debug("rabbit acking message", { deliveryTag: msg.fields.deliveryTag });
+		await channel.ack(msg);
+		const { headers } = msg.properties;
+		const timestamp = headers?.creationTimestamp;
+		if (shouldUpdateRedisTimestamp && timestamp && headers?.redisTimestampValidationKey && this.redisClient) {
+			const parsedTimestamp = parseInt(timestamp, 10);
+			const key = this.getRedisKey(headers.redisTimestampValidationKey);
+			await this.redisClient.set(key, parsedTimestamp, { EX: 3600 });
+			await this.unlockRedisIfNeeded(releaseLock);
+		}
+	};
+	nack = (channel, queue, options, deadQueueOptions, msg, releaseLock) => async (userMsg, { skipRetry = false } = {}) => {
+		await this.unlockRedisIfNeeded(releaseLock);
+		if (!channel || !msg) {
+			this.#logger.error("no channel or msg", { msg });
+			return;
+		}
+		const currentRetryHeader = Number.parseInt(msg.properties.headers?.[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,
+			[RETRY_HEADER]: currentRetryHeader + 1
+		});
+		this.#logger.debug("rabbit nacking message", { deliveryTag: msg.fields.deliveryTag });
+		await channel.ack(msg);
+	};
+	async getConnection(connection) {
+		const { amqpConnection: connectionLocal, creatingConnection, connectionCreatedEventName, connectionFailedEventName, blockReconnect } = connection;
+		if (blockReconnect) {
+			this.#logger.debug("rabbit: block reconnect");
+			return void 0;
+		}
+		if (connectionLocal !== null) {
+			if (this.options?.disableReconnect || connectionLocal?.isConnected()) {
+				this.#logger.debug("rabbit: connection - is connected");
+				return connectionLocal;
+			}
+			this.#logger.debug("rabbit: connection - reconnecting");
+		}
+		if (creatingConnection) {
+			this.#logger.debug("rabbit: creating connection emi");
+			const [event, value] = await Promise.race([connectionCreatedEventName, connectionFailedEventName].map((e) => once(this.em, e).then(([result]) => [e, result])));
+			if (event === connectionCreatedEventName) return value;
+			throw value;
+		}
+		connection.creatingConnection = true;
+		let isResolved = false;
+		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";
+			this.#logger.debug("rabbit: creating connection", {
+				host,
+				userName,
+				HEARTBEAT
+			});
+			return [`amqp://${userName}:${password}@${host}/${this.vhost}?heartbeat=${HEARTBEAT}`];
+		};
+		const defaultUrls = findServers();
+		const newConnection = connect(defaultUrls, { findServers });
+		connection.amqpConnection = newConnection;
+		const { promise, reject, resolve } = createDeferredPromise();
+		newConnection.on("error", (err) => {
+			this.#logger.error("rabbit: connection error", { err });
+			if (!isResolved) {
+				isResolved = true;
+				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);
+			this.#logger.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();
+			this.#logger.debug("rabbit: connection closed");
+			if (this.options?.disableReconnect) {
+				this.#logger.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
+				connection.blockReconnect = true;
+			} else this.#logger.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
+		});
+		newConnection.once("connect", async () => {
+			this.#logger.debug("rabbit: connection established");
+			connection.creatingConnection = false;
+			this.em.emit(connectionCreatedEventName, newConnection);
+			isResolved = true;
+			resolve(newConnection);
+		});
+		return promise;
+	}
+	async getNewChannel({ name = rand().toString(), onClose = null, options = {}, connection }) {
+		let localConnection;
+		try {
+			localConnection = await this.getConnection(connection);
+		} catch (e) {
+			this.#logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
+			throw e;
+		}
+		const channel = localConnection?.createChannel({ ...options });
+		once(channel, "close").then((args) => {
+			this.#logger.error(`rabbit: channel ${name} closed`);
+			onClose?.(args);
+		});
+		try {
+			await once(channel, "connect");
+			this.#logger.debug(`rabbit: channel ${name} CONNECTED`);
+			return channel;
+		} catch (err) {
+			this.#logger.error(`rabbit: channel error ${name} error`, { err });
+			throw err;
+		}
+	}
+	async assertChannel({ force = false, connection }) {
+		if (this.publishChannelSetupPromise) return this.publishChannelSetupPromise;
+		const { promise, resolve, reject } = createDeferredPromise();
+		this.publishChannelSetupPromise = promise;
+		if (this.publishChannel && !force) {
+			resolve(this.publishChannel);
+			return promise;
+		}
+		try {
+			const channel = await this.getNewChannel({ connection });
+			channel.on("error", (err) => {
+				this.#logger.error("rabbit: channel error", { err });
+			});
+			if (this.publishConnection === connection) this.publishChannel = channel;
+			resolve(channel);
+		} catch (e) {
+			reject(e);
+		}
+		return promise;
+	}
+	async assertExchange(exchangeName, connection) {
+		const channel = await this.assertChannel({ connection });
+		if (this.exchanges[exchangeName]) {
+			delete this.assertExchangePromises[exchangeName];
+			return this.exchanges[exchangeName];
+		}
+		if (this.assertExchangePromises[exchangeName]) return this.assertExchangePromises[exchangeName];
+		this.assertExchangePromises[exchangeName] = assertExchangeFanout(channel, exchangeName);
+		this.exchanges[exchangeName] = await this.assertExchangePromises[exchangeName];
+		return this.exchanges[exchangeName];
+	}
+	async getQueueLength(queue) {
+		RabbitMq.validateName("queue", queue);
+		const { publishChannel: channel } = this;
+		if (!channel) throw new RabbitError("channel is not defined");
+		this.#logger.debug("rabbit: getting queue length", {
+			queue,
+			connected: this.publishConnection.amqpConnection?.isConnected()
+		});
+		return channel?.checkQueue(queue);
+	}
+	async deleteQueue(queue, connection) {
+		RabbitMq.validateName("queue", queue);
+		const channel = await this.assertChannel({ connection });
+		this.#logger.info("rabbit: deleting queue", { queue });
+		const deleteQueueRes = await channel.deleteQueue(queue);
+		this.#logger.debug("queue deleted", deleteQueueRes);
+		return deleteQueueRes;
+	}
+	async bindQueue(queue, exchange) {
+		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,
+			arguments: {
+				...options?.arguments,
+				"x-consumer-timeout": 1e3 * 60 * 60 * 24,
+				"x-queue-type": "quorum"
+			}
+		};
+		try {
+			const channel = await this.assertChannel({ connection });
+			this.#logger.debug("assertQueue->channel.addSetup", { queueName });
+			await channel.addSetup(async (setupChannel) => {
+				await setupChannel.assertQueue(queueName, localeOptions);
+			});
+			this.#logger.debug("assertQueue->channel.assertQueue", { queueName });
+			queue = await channel.assertQueue(queueName, localeOptions);
+		} catch (e) {
+			this.#logger.error("rabbit: assertQueue error", {
+				queueName,
+				options,
+				error: e
+			});
+			if (!this.options?.dontRetryAssert) {
+				this.#logger.debug("retrying assertQueue", { queueName });
+				const channel = await this.assertChannel({
+					force: true,
+					connection
+				});
+				await this.deleteQueue(queueName, connection);
+				this.#logger.debug("retrying assertQueue->channel.addSetup", { queueName });
+				await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, localeOptions));
+				this.#logger.debug("retrying assertQueue->channel.assertQueue", { queueName });
+				queue = await channel.assertQueue(queueName, localeOptions);
+			} else throw e;
+		}
+		this.queues[queueName] = queue;
+		return queue;
+	}
+	static shouldUseQuorum(queueName) {
+		const envQuorumQueuesWhitelist = process.env.QUORUM_QUEUES_WHITELIST;
+		if (envQuorumQueuesWhitelist === "*") return true;
+		if (envQuorumQueuesWhitelist) {
+			const whitelist = envQuorumQueuesWhitelist.split(",");
+			return whitelist.includes(queueName);
+		}
+		return false;
+	}
+	async assertQueue(queueName, options) {
+		RabbitMq.validateName("queue", queueName);
+		if (this.queues[queueName]) {
+			delete this.queueSetupPromises[queueName];
+			return this.queues[queueName];
+		}
+		this.queueSetupPromises[queueName] ||= this.setupQueue(queueName, options);
+		return this.queueSetupPromises[queueName];
+	}
+	saveConsumer(queue, callback, options) {
+		const isConsumerExist = this.consumersToRegister.some((consumer) => consumer.queue === queue);
+		if (!isConsumerExist) {
+			this.#logger.info(`rabbit: consumer: ${queue} saved in consumer array`);
+			this.consumersToRegister.push({
+				queue,
+				callback,
+				options
+			});
+		}
+	}
+	async consume(queue, callback, options) {
+		this.saveConsumerOld(queue, callback, options);
+		if (options?.isQuorumQueue !== false && DISABLE_QUORUM_QUEUES_CONSUME !== "true") {
+			this.saveConsumer(queue, callback, options);
+			const backoffConfig = getAssertVhostExponentialBackoffConfig();
+			await backOff(() => this.assertVHost(), backoffConfig);
+			await this.consumeNew(queue, callback, options);
+		}
+		await this.consumeOld(queue, callback, options);
+	}
+	async consumeNew(queue, callback, options) {
+		await this.consumeFromRabbit(queue, callback, options);
+	}
+	async consumeOld(queue, callback, options) {
+		await this.consumeFromRabbitOld(queue, callback, options);
+	}
+	async lockRedisIfNeeded(msg, options) {
+		const { properties: { headers } } = msg;
+		const timestamp = headers?.creationTimestamp;
+		let releaseLock = null;
+		if (options.useConsumeWithLock && timestamp && headers?.redisTimestampValidationKey && this.redisLock) releaseLock = await this.redisLock(headers.redisTimestampValidationKey, options?.lockTimeout || DEFAULT_LOCK_TIMEOUT);
+		return releaseLock;
+	}
+	async unlockRedisIfNeeded(releaseLock) {
+		if (this.redisLock && releaseLock) await releaseLock();
+	}
+	async consumeFromRabbit(queue, callback, options) {
+		const optionsWithDefaults = {
+			...DEFAULT_OPTIONS,
+			...options
+		};
+		RabbitMq.validateName("queue", queue);
+		const uniqueId = randomUUID();
+		const { limit, deadMessageTtl, useConsumeWithLock, lockTimeout, auditContext, enableRabbitTrace } = optionsWithDefaults;
+		if (useConsumeWithLock) {
+			if (!this.redisLock) throw new RabbitError("Usage of consumeWithLock requires RedisInstance");
+			this.#logger.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
+		}
+		const channel = await this.getNewChannel({ connection: this.consumeConnection });
+		return channel.addSetup(async (confirmChannel) => {
+			await this.assertQueue(queue, optionsWithDefaults);
+			await confirmChannel.prefetch(limit, false);
+			const { consumerTag } = await confirmChannel.consume(queue, async (msg) => {
+				if (!msg) return null;
+				const { [TRACING_HEADER]: traceId, [USER_TRACING_HEADER]: userId, [AUTOMATION_ID_HEADER]: automationId, [CONTEXTS_IDS_HEADER]: userContextIds } = msg.properties.headers || {};
+				const parsedMessage = RabbitMq.parseMsg(msg);
+				const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
+				const trace = newTrace(traceTypes.RABBIT);
+				if (userId && enableRabbitTrace) try {
+					await createOrSetRabbitTrace(trace, userId, userContextIds);
+				} catch (e) {
+					this.#logger.error("rabbit: failed to setRabbitTrace", {
+						userId,
+						e
+					});
+					return this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
+				}
+				if (traceId) trace.context?.set(TRACING_HEADER, traceId);
+				if (auditContext) await auditContext(queue, {
+					userId,
+					automationId
+				});
+				const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
+				if (!shouldConsume) {
+					await this.unlockRedisIfNeeded(releaseLock);
+					return this.ack(confirmChannel, msg)(msg);
+				}
+				let messageAcked = false;
+				const localAck = async () => {
+					if (messageAcked) return;
+					messageAcked = true;
+					await this.ack(confirmChannel, msg, true, releaseLock)(msg);
+				};
+				const localNack = async (_, nackOptions = {}) => {
+					if (messageAcked) return;
+					this.#logger.debug("rabbit localNack", {
+						messageAcked,
+						uniqueId,
+						deliveryTag: msg.fields.deliveryTag
+					});
+					messageAcked = true;
+					await this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg, nackOptions);
+				};
+				try {
+					return await callback(parsedMessage, localAck, localNack);
+				} catch (e) {
+					return localNack(msg);
+				}
+			}, CONSUMER_DEFAULT_OPTIONS);
+			if (!consumerTag) this.#logger.error(`rabbit: failed to consume from queue ${queue}`);
+			else {
+				this.#logger.info(`rabbit: adding tag ${consumerTag} to the array.`);
+				this.consumersTags.set(queue, {
+					channel: confirmChannel,
+					consumerTag
+				});
+			}
+		});
+	}
+	async consumeFromExchange(queue, exchange, callback, options) {
+		const optionsWithDefaults = {
+			...DEFAULT_OPTIONS,
+			...options
+		};
+		RabbitMq.validateName("exchange", exchange);
+		RabbitMq.validateName("queue", queue);
+		const { limit } = optionsWithDefaults;
+		if (options?.isQuorumQueue !== false && DISABLE_QUORUM_QUEUES_CONSUME !== "true") {
+			await this.saveConsumer(queue, callback, options);
+			const backoffConfig = getAssertVhostExponentialBackoffConfig();
+			await 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 assertExchangeFanout(c, exchange);
+				await c.assertQueue(queue);
+				this.exchanges[exchange] = assertExchange;
+				await c.prefetch(limit, false);
+				return Promise.all([c.bindQueue(queue, exchange, ""), this.consumeNew(queue, callback, options)]);
+			});
+		}
+		await this.saveConsumerOld(queue, callback, options);
+		const channelOld = await this.getNewChannelOld({
+			name: `consume-exchange-${exchange}-queue-${queue}-old`,
+			connection: this.oldConsumeConnection
+		});
+		await channelOld.addSetup(async (c) => {
+			const assertExchange = await assertExchangeFanout(c, exchange);
+			await c.assertQueue(queue);
+			this.oldExchanges[exchange] = assertExchange;
+			await c.prefetch(limit, false);
+			return Promise.all([c.bindQueue(queue, exchange, ""), this.consumeOld(queue, callback, options)]);
+		});
+	}
+	async publish(exchange, content, customHeaders, isQuorumQueue = true) {
+		await setImmediate();
+		if (isQuorumQueue && DISABLE_QUORUM_QUEUES_PUBLISH !== "true") {
+			await this.assertVHost();
+			RabbitMq.validateName("exchange", exchange);
+			const channel$1 = await this.assertChannel({ connection: this.publishConnection });
+			await this.assertExchange(exchange, this.publishConnection);
+			await channel$1.publish(exchange, "", Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
+			return;
+		}
+		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));
+	}
+	async sendToQueue(queue, content, options, customHeaders, isQuorumQueue = true) {
+		if (isQuorumQueue && DISABLE_QUORUM_QUEUES_PUBLISH !== "true") {
+			try {
+				await this.assertVHost();
+				await this.assertChannel({ connection: this.publishConnection });
+			} catch (e) {
+				this.#logger.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
+				throw e;
+			}
+			try {
+				RabbitMq.validateName("queue", queue);
+				await this.assertQueue(queue, options);
+			} catch (e) {
+				this.#logger.error(`rabbit sendToQueue: failed to assert queue ${queue}`, { e });
+				throw e;
+			}
+			try {
+				const res = await this.publishChannel?.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
+				this.#logger.debug(`rabbit: sending to queue ${queue}`, { res });
+				return res;
+			} catch (e) {
+				const isConnected = await this.isConnected();
+				this.#logger.error(`rabbit sendToQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
+				throw e;
+			}
+		} else {
+			try {
+				await this.assertChannelOld({ connection: this.oldPublishConnection });
+			} catch (e) {
+				this.#logger.error(`rabbit sendToQueue: failed to send assert channel when sending to queue ${queue}`, { e });
+				throw e;
+			}
+			try {
+				RabbitMq.validateName("queue", queue);
+				await this.assertQueueOld(queue, options);
+			} catch (e) {
+				this.#logger.error(`rabbit sendToQueue: failed to assert queue ${queue}`, { e });
+				throw e;
+			}
+			try {
+				const res = await this.oldPublishChannel?.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
+				this.#logger.debug(`rabbit: sending to queue ${queue}`, { res });
+				return res;
+			} catch (e) {
+				const isConnected = await this.isConnectedOld();
+				this.#logger.error(`rabbit sendToQueue: failed to send to queue ${queue}, isConnected: ${isConnected}`, { e });
+				throw e;
+			}
+		}
+	}
+	async isConnected() {
+		let isConnected = true;
+		if (!this.gracefulShutdownStarted) {
+			if (DISABLE_QUORUM_QUEUES_CONSUME !== "true" || DISABLE_QUORUM_QUEUES_PUBLISH !== "true") {
+				this.#logger.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) {
+					this.#logger.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);
+						this.#logger.error("rabbit: found unregistered consumers for queues", {
+							count: queueNames.length,
+							queues: queueNames
+						});
+						throw new RabbitError("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) {
+					this.#logger.error("rabbit: isConnected - false", { msg: e.message });
+					return false;
+				}
+			}
+			isConnected = await this.isConnectedOld();
+		}
+		this.#logger.debug(`rabbit: isConnected - ${isConnected}`);
+		return isConnected;
+	}
+	async gracefulShutdown(signal) {
+		this.gracefulShutdownStarted = true;
+		const tagsNumber = this.consumersTags.size + this.oldConsumersTags.size;
+		this.#logger.info(`rabbit: [gracefully-shutdown] received ${signal}! canceling #${tagsNumber} tags...`);
+		const cancelTagPromises = [...this.consumersTags].map(([, { channel, consumerTag }]) => channel.cancel(consumerTag));
+		const cancelTagPromisesOld = [...this.oldConsumersTags].map(([, { channel, consumerTag }]) => channel.cancel(consumerTag));
+		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) this.#logger.warn(`rabbit: [gracefully-shutdown] #${rejected.length}/${tagsNumber} tags failed to cancel: ${rejected}`);
+		else this.#logger.info("rabbit: [gracefully-shutdown] all tags successfully canceled.");
+	}
+	async consumeFromRabbitOld(queue, callback, options) {
+		const optionsWithDefaults = {
+			...DEFAULT_OPTIONS,
+			...options
+		};
+		RabbitMq.validateName("queue", queue);
+		const uniqueId = randomUUID();
+		const { limit, deadMessageTtl, useConsumeWithLock, lockTimeout, auditContext, enableRabbitTrace } = optionsWithDefaults;
+		if (useConsumeWithLock) {
+			if (!this.redisLock) throw new RabbitError("Usage of consumeWithLock requires RedisInstance");
+			this.#logger.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
+		}
+		const channel = await this.getNewChannelOld({ connection: this.oldConsumeConnection });
+		return channel.addSetup(async (confirmChannel) => {
+			await this.assertQueueOld(queue, optionsWithDefaults);
+			await confirmChannel.prefetch(limit, false);
+			const { consumerTag } = await confirmChannel.consume(queue, async (msg) => {
+				if (!msg) return null;
+				const { [TRACING_HEADER]: traceId, [USER_TRACING_HEADER]: userId, [AUTOMATION_ID_HEADER]: automationId, [CONTEXTS_IDS_HEADER]: userContextIds } = msg.properties.headers || {};
+				const parsedMessage = RabbitMq.parseMsg(msg);
+				const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
+				const trace = newTrace(traceTypes.RABBIT);
+				if (userId && enableRabbitTrace) try {
+					await createOrSetRabbitTrace(trace, userId, userContextIds);
+				} catch (e) {
+					this.#logger.error("rabbit: failed to setRabbitTrace", {
+						userId,
+						e
+					});
+					return this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
+				}
+				if (traceId) trace.context?.set(TRACING_HEADER, traceId);
+				if (auditContext) await auditContext(queue, {
+					userId,
+					automationId
+				});
+				const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
+				if (!shouldConsume) {
+					await this.unlockRedisIfNeeded(releaseLock);
+					return this.ack(confirmChannel, msg)(msg);
+				}
+				let messageAcked = false;
+				const localAck = async () => {
+					if (messageAcked) return;
+					messageAcked = true;
+					await this.ack(confirmChannel, msg, true, releaseLock)(msg);
+				};
+				const localNack = async (_, nackOptions = {}) => {
+					if (messageAcked) return;
+					this.#logger.debug("rabbit localNack", {
+						messageAcked,
+						uniqueId,
+						deliveryTag: msg.fields.deliveryTag
+					});
+					messageAcked = true;
+					await this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg, nackOptions);
+				};
+				try {
+					return await callback(parsedMessage, localAck, localNack);
+				} catch (e) {
+					return localNack(msg);
+				}
+			}, CONSUMER_DEFAULT_OPTIONS);
+			if (!consumerTag) this.#logger.error(`rabbit: failed to consume from queue ${queue} old`);
+			else {
+				this.#logger.info(`rabbit: adding tag ${consumerTag} to the array old`);
+				this.oldConsumersTags.set(queue, {
+					channel: confirmChannel,
+					consumerTag
+				});
+			}
+		});
+	}
+	async getNewChannelOld({ name = rand().toString(), onClose = null, options = {}, connection }) {
+		let localConnection;
+		try {
+			localConnection = await this.getConnectionOld(connection);
+		} catch (e) {
+			this.#logger.error(`rabbit: error on get connection for new channel ${name} `, { e });
+			throw e;
+		}
+		if (!localConnection) throw new Error(`rabbit: couldnt get connection for new channel ${name}`);
+		const channel = localConnection?.createChannel({ ...options });
+		once(channel, "close").then((args) => {
+			this.#logger.error(`rabbit: channel ${name} closed`);
+			onClose?.(args);
+		});
+		try {
+			await once(channel, "connect");
+			this.#logger.debug(`rabbit: channel ${name} CONNECTED`);
+			return channel;
+		} catch (err) {
+			this.#logger.error(`rabbit: channel error ${name} error`, { err });
+			throw err;
+		}
+	}
+	async getConnectionOld(connection) {
+		const { amqpConnection: connectionLocal, creatingConnection, connectionCreatedEventName, connectionFailedEventName, blockReconnect } = connection;
+		if (blockReconnect) {
+			this.#logger.debug("rabbit: block reconnect");
+			return void 0;
+		}
+		if (connectionLocal !== null) {
+			if (this.options?.disableReconnect || connectionLocal?.isConnected()) {
+				this.#logger.debug("rabbit: connection - is connected");
+				return connectionLocal;
+			}
+			this.#logger.debug("rabbit: connection - reconnecting");
+		}
+		if (creatingConnection) {
+			const [event, value] = await Promise.race([connectionCreatedEventName, connectionFailedEventName].map((e) => once(this.oldEm, e).then(([result]) => [e, result])));
+			if (event === connectionCreatedEventName) return value;
+			throw value;
+		}
+		connection.creatingConnection = true;
+		let isResolved = false;
+		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";
+			this.#logger.debug("rabbit: creating connection", {
+				host,
+				userName,
+				HEARTBEAT
+			});
+			return [`amqp://${userName}:${password}@${host}?heartbeat=${HEARTBEAT}`];
+		};
+		const defaultUrls = findServers();
+		const newConnection = await connect(defaultUrls, { findServers });
+		connection.amqpConnection = newConnection;
+		const { promise, reject, resolve } = createDeferredPromise();
+		newConnection.on("error", (err) => {
+			this.#logger.error("rabbit: connection error", { err });
+			if (!isResolved) {
+				isResolved = true;
+				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);
+			this.#logger.error("rabbit: connection connectFailed", { err });
+			if (!isResolved) {
+				isResolved = true;
+				reject(err);
+				this.oldEm.emit(connectionFailedEventName, err);
+			}
+		});
+		newConnection.on("disconnect", ({ err }) => {
+			this.oldConsumersTags.clear();
+			this.#logger.debug("rabbit: connection closed");
+			if (this.options?.disableReconnect) {
+				this.#logger.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
+				connection.blockReconnect = true;
+			} else this.#logger.error(`${this.RECONNECT_MSG}${err && ` - ${err}`}`);
+		});
+		newConnection.once("connect", async () => {
+			this.#logger.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.oldConsumersToRegister.some((consumer) => consumer.queue === queue);
+		if (!isConsumerExist) {
+			this.#logger.info(`rabbit: consumer: ${queue} saved in consumer array`);
+			this.oldConsumersToRegister.push({
+				queue,
+				callback,
+				options
+			});
+		}
+	}
+	async assertQueueOld(queueName, options) {
+		RabbitMq.validateName("queue", queueName);
+		if (this.oldQueues[queueName]) {
+			delete this.oldQueueSetupPromises[queueName];
+			return this.oldQueues[queueName];
+		}
+		this.oldQueueSetupPromises[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,
+			durable: true,
+			arguments: {
+				...options?.arguments,
+				"x-consumer-timeout": 1e3 * 60 * 60 * 24,
+				"x-queue-type": shouldUseQuorum ? "quorum" : "classic"
+			}
+		};
+		try {
+			const channel = await this.assertChannelOld({ connection });
+			this.#logger.debug("assertQueue->channel.addSetup", { queueName });
+			await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, localeOptions));
+			this.#logger.debug("assertQueue->channel.assertQueue", { queueName });
+			queue = await channel.assertQueue(queueName, localeOptions);
+		} catch (e) {
+			this.#logger.error("rabbit: assertQueue error", {
+				queueName,
+				options,
+				error: e
+			});
+			if (!this.options?.dontRetryAssert) {
+				this.#logger.debug("retrying assertQueue", { queueName });
+				const channel = await this.assertChannelOld({
+					force: true,
+					connection
+				});
+				await this.deleteQueueOld(queueName, connection);
+				this.#logger.debug("retrying assertQueue->channel.addSetup", { queueName });
+				await channel.addSetup((setupChannel) => setupChannel.assertQueue(queueName, localeOptions));
+				this.#logger.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, connection }) {
+		if (this.oldPublishChannelSetupPromise) return this.oldPublishChannelSetupPromise;
+		const { promise, resolve, reject } = createDeferredPromise();
+		this.oldPublishChannelSetupPromise = promise;
+		if (this.oldPublishChannel && !force) {
+			resolve(this.oldPublishChannel);
+			return promise;
+		}
+		try {
+			const channel = await this.getNewChannelOld({ connection });
+			channel.on("error", (err) => {
+				this.#logger.error("rabbit: channel error", { err });
+			});
+			if (this.oldPublishConnection === connection) this.oldPublishChannel = channel;
+			resolve(channel);
+		} catch (e) {
+			reject(e);
+		}
+		return promise;
+	}
+	async deleteQueueOld(queue, connection) {
+		RabbitMq.validateName("queue", queue);
+		const channel = await this.assertChannelOld({ connection });
+		this.#logger.info("rabbit: deleting queue", { queue });
+		const deleteQueueRes = await channel.deleteQueue(queue);
+		this.#logger.debug("queue deleted", deleteQueueRes);
+		return deleteQueueRes;
+	}
+	async assertExchangeOld(exchangeName, connection) {
+		const channel = await this.assertChannelOld({ connection });
+		if (this.oldExchanges[exchangeName]) {
+			delete this.oldAssertExchangePromises[exchangeName];
+			return this.oldExchanges[exchangeName];
+		}
+		if (this.oldAssertExchangePromises[exchangeName]) return this.oldAssertExchangePromises[exchangeName];
+		this.oldAssertExchangePromises[exchangeName] = assertExchangeFanout(channel, exchangeName);
+		this.oldExchanges[exchangeName] = await this.oldAssertExchangePromises[exchangeName];
+		return this.oldExchanges[exchangeName];
+	}
+	async isConnectedOld() {
+		if (this.gracefulShutdownStarted) return true;
+		this.#logger.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) {
+			this.#logger.error("rabbit: isConnected old - false");
+			return false;
+		}
+		try {
+			const unRegisteredConsumersOld = this.consumersToRegister.filter((c) => !this.consumersTags.get(c.queue));
+			if (unRegisteredConsumersOld.length > 0) {
+				const queueNames = unRegisteredConsumersOld.map((c) => c.queue);
+				this.#logger.error("rabbit: found unregistered consumers for queues old", {
+					count: queueNames.length,
+					queues: queueNames
+				});
+				throw new RabbitError("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)));
+			return true;
+		} catch (e) {
+			this.#logger.error("rabbit: isConnected - false old", { msg: e.message });
+			return false;
+		}
+	}
+	maskURL = (url) => {
+		try {
+			const urlObj = new URL(url);
+			urlObj.username = "***";
+			urlObj.password = "***";
+			return urlObj.toString();
+		} catch {
+			return url;
+		}
+	};
+};
+var src_default = RabbitMq;
+
+//#endregion
+export { src_default as default, sendCeleryTaskViaHttp };
 //# sourceMappingURL=index.js.map