@autofleet/rabbit 4.1.1 → 5.0.0

package/dist/index.cjs

@@ -0,0 +1,1119 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const node_process = require_chunk.__toESM(require("node:process"));
+const node_timers_promises = require_chunk.__toESM(require("node:timers/promises"));
+const node_events = require_chunk.__toESM(require("node:events"));
+const moment = require_chunk.__toESM(require("moment"));
+const redis_lock = require_chunk.__toESM(require("redis-lock"));
+const amqp_connection_manager = require_chunk.__toESM(require("amqp-connection-manager"));
+const exponential_backoff = require_chunk.__toESM(require("exponential-backoff"));
+const __autofleet_zehut = require_chunk.__toESM(require("@autofleet/zehut"));
+const node_crypto = require_chunk.__toESM(require("node:crypto"));
+const __autofleet_logger = require_chunk.__toESM(require("@autofleet/logger"));
+const redis = require_chunk.__toESM(require("redis"));
+
+//#region src/logger.ts
+const logger = (0, __autofleet_logger.default)();
+var logger_default = logger;
+
+//#endregion
+//#region src/lib/rabbitError.ts
+var RabbitError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "RabbitError";
+	}
+};
+
+//#endregion
+//#region src/lib/redis.ts
+const getRedisInstance = (config$1) => (0, redis.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
+};
+const ASSERT_VHOST_EXPONENTIAL_BACKOFF_DEV_ENV_CONFIG = {
+	startingDelay: 500,
+	timeMultiple: 4,
+	numOfAttempts: 5
+};
+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: (0, node_crypto.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;
+	}
+}
+
+//#endregion
+//#region src/index.ts
+const PUBLISH_TIMEOUT = 1e3 * 10;
+const { DISABLE_QUORUM_QUEUES_CONSUME, DISABLE_QUORUM_QUEUES_PUBLISH } = node_process.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 = (0, __autofleet_zehut.getUser)();
+		const traceId = __autofleet_zehut.outbreak.getCurrentContextTraceId();
+		return {
+			timestamp: (0, moment.default)().unix(),
+			timeout: PUBLISH_TIMEOUT,
+			headers: {
+				creationTimestamp: (0, moment.default)().valueOf(),
+				...customHeaders,
+				[USER_TRACING_HEADER]: user?.id,
+				[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 node_events.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 node_events.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 = (0, redis_lock.default)(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) => (0, node_events.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 = (0, amqp_connection_manager.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 });
+		(0, node_events.once)(channel, "close").then((args) => {
+			this.#logger.error(`rabbit: channel ${name} closed`);
+			onClose?.(args);
+		});
+		try {
+			await (0, node_events.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 (0, exponential_backoff.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 = (0, node_crypto.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 } = msg.properties.headers ?? {};
+				const parsedMessage = RabbitMq.parseMsg(msg);
+				const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
+				const trace = (0, __autofleet_zehut.newTrace)(__autofleet_zehut.traceTypes.RABBIT);
+				if (userId && enableRabbitTrace) try {
+					await (0, __autofleet_zehut.createOrSetRabbitTrace)(trace, userId);
+				} 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 (0, exponential_backoff.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 (0, node_timers_promises.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 = (0, node_crypto.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 } = msg.properties.headers ?? {};
+				const parsedMessage = RabbitMq.parseMsg(msg);
+				const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
+				const trace = (0, __autofleet_zehut.newTrace)(__autofleet_zehut.traceTypes.RABBIT);
+				if (userId && enableRabbitTrace) try {
+					await (0, __autofleet_zehut.createOrSetRabbitTrace)(trace, userId);
+				} 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 });
+		(0, node_events.once)(channel, "close").then((args) => {
+			this.#logger.error(`rabbit: channel ${name} closed`);
+			onClose?.(args);
+		});
+		try {
+			await (0, node_events.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) => (0, node_events.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 (0, amqp_connection_manager.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
+exports.default = src_default;
+exports.sendCeleryTaskViaHttp = sendCeleryTaskViaHttp;
+//# sourceMappingURL=index.cjs.map