@autofleet/rabbit 3.2.5 → 3.2.6-testing

package/.env

@@ -0,0 +1,3 @@
+#RABBITMQ_SERVICE_HOST=
+RABBITMQ_USERNAME=default_user_w2_vEYNVrLWiAnWKmPH
+RABBITMQ_PASSWORD=GUAPvNXJbkgbkGeeFUYbZfOxVfR4cuf8

package/dist/index.d.ts

@@ -1,9 +1,8 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
-import { AmqpConnectionManager, ChannelWrapper, CreateChannelOpts } from 'amqp-connection-manager';
+import { AmqpConnectionManager, ChannelWrapper } from 'amqp-connection-manager';
 import { ConfirmChannel, ConsumeMessage, Options, Replies } from 'amqplib';
 import { RedisConfig } from './lib/redis';
-import { TRACING_HEADER, USER_TRACING_HEADER } from './lib/consts';
 import { CallbackFunction, ConsumeMessageOrNull, ConsumeOptions, CustomMessageHeaders, QueuesCache, RedisLockType, ExchangesCache } from './lib/types';
 export interface IAfRabbitMq {
     ack: any;
@@ -17,9 +16,6 @@ export interface IAfRabbitMq {
     sendToQueue: any;
     redisClient?: any;
 }
-interface NackOptions {
-    skipRetry?: boolean;
-}
 export interface AfRabbitOptions {
     disableReconnect?: boolean;
     /**
@@ -28,18 +24,16 @@ export interface AfRabbitOptions {
      */
     dontGracefulShutdown?: boolean;
     /**
-     * dont retry on creation error
+     * retry on creation error
      * @default false
      */
-    dontRetryAssert?: boolean;
-    rabbitHost?: string;
+    retryAssert?: boolean;
 }
-declare type newChannelOpts = {
+type newChannelOpts = {
     name?: string;
     onClose?: null | ((args: any | null) => void);
-    options?: CreateChannelOpts | undefined;
 };
-declare type assertChannelOpts = {
+type assertChannelOpts = {
     channelName?: string;
     force?: boolean;
 };
@@ -48,14 +42,14 @@ declare class RabbitMq implements IAfRabbitMq {
     static validateName(type: string, name: string): void;
     static getPublishOptions(customHeaders?: CustomMessageHeaders): {
         timestamp: number;
-        timeout: number;
         headers: {
-            "x-af-user-id": any;
             "x-trace-id": any;
             redisTimestampValidationKey?: string | undefined;
             creationTimestamp: number;
         };
     };
+    PUBLISH_TIMEOUT: number;
+    PUBLISH_ERROR_MSG: string;
     DISCONNECT_MSG: string;
     RECONNECT_MSG: string;
     channel: ChannelWrapper | null;
@@ -73,10 +67,10 @@ declare class RabbitMq implements IAfRabbitMq {
     private consumers;
     constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig);
     private shouldConsumeMessageByTimestamp;
-    ack: (channel: ConfirmChannel, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp?: boolean, releaseLock?: null) => (userMsg: ConsumeMessage) => Promise<any>;
-    nack: (channel: ConfirmChannel, queue: string, options: any, deadQueueOptions: Options.AssertQueue, msg: ConsumeMessageOrNull, releaseLock: any) => (userMsg: ConsumeMessageOrNull, { skipRetry, }?: NackOptions) => Promise<any>;
+    ack: (channel: ChannelWrapper, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp?: boolean, releaseLock?: null) => (userMsg: ConsumeMessage) => Promise<any>;
+    nack: (channel: ChannelWrapper, queue: string, options: any, deadQueueOptions: Options.AssertQueue, msg: ConsumeMessageOrNull, releaseLock: any) => (userMsg: ConsumeMessageOrNull, { skipRetry, }?: any) => Promise<any>;
     getConnection(): Promise<AmqpConnectionManager>;
-    getNewChannel({ name, onClose, options }?: newChannelOpts): Promise<ChannelWrapper>;
+    getNewChannel({ name, onClose }?: newChannelOpts): Promise<ChannelWrapper>;
     assertChannel({ force }?: assertChannelOpts): Promise<ChannelWrapper>;
     assertExchange(exchangeName: string, options?: any): Promise<any>;
     getQueueLength(queue: string): Promise<Replies.AssertQueue>;
@@ -84,6 +78,7 @@ declare class RabbitMq implements IAfRabbitMq {
     bindQueue(queue: string, exchange: string): Promise<void>;
     assertQueue(queueName: string, options?: Options.AssertQueue): Promise<any>;
     private saveConsumer;
+    private loadConsumers;
     consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any>;
     private lockRedisIfNeeded;
     private unlockRedisIfNeeded;

package/dist/index.js

@@ -9,19 +9,50 @@ const util_1 = require("util");
 const moment_1 = __importDefault(require("moment"));
 const redis_lock_1 = __importDefault(require("redis-lock"));
 const amqp_connection_manager_1 = require("amqp-connection-manager");
-const zehut_1 = require("@autofleet/zehut");
+const outbreak_1 = require("@autofleet/outbreak");
 const logger_1 = __importDefault(require("./logger"));
 const rabbitError_1 = __importDefault(require("./lib/rabbitError"));
 const redis_1 = __importDefault(require("./lib/redis"));
 const utils_1 = require("./lib/utils");
 const consts_1 = require("./lib/consts");
-const types_1 = require("./lib/types");
 // const debug = nodeDebug('af-rabbitmq')
 const debug = logger_1.default.info;
-const PUBLISH_TIMEOUT = 1000 * 10;
+const USERNAME = process.env.RABBITMQ_USERNAME || 'guest';
+const PASSWORD = process.env.RABBITMQ_PASSWORD || 'guest';
+const HOST = process.env.RABBITMQ_SERVICE_HOST || 'localhost';
 const HEARTBEAT = '60';
 class RabbitMq {
+    static parseMsg(msg) {
+        let { content } = msg;
+        content = content.toString();
+        try {
+            content = JSON.parse(content);
+        }
+        catch (e) { }
+        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 trace = (0, outbreak_1.getCurrentContext)();
+        return {
+            timestamp: (0, moment_1.default)().unix(),
+            headers: {
+                creationTimestamp: (0, moment_1.default)().valueOf(),
+                ...customHeaders,
+                [consts_1.TRACING_HEADER]: trace?.context?.get(consts_1.TRACING_HEADER),
+            },
+        };
+    }
     constructor(options, redisConfig) {
+        this.PUBLISH_TIMEOUT = Number(process.env.RABBITMQ_PUBLISH_TIMEOUT) || 60000;
+        this.PUBLISH_ERROR_MSG = `rabbit: publish timeout(${this.PUBLISH_TIMEOUT}ms) has pass, exchange: `;
         this.DISCONNECT_MSG = 'rabbit: connection disconnect';
         this.RECONNECT_MSG = 'rabbit: connection disconnect - reconnecting';
         this.consumers = [];
@@ -75,6 +106,7 @@ class RabbitMq {
             }
             else {
                 logger_1.default.error('no channel or msg', {
+                    channel: channel ? channel.name : '',
                     msg,
                 });
             }
@@ -86,9 +118,9 @@ class RabbitMq {
         this.exchanges = {};
         this.queues = {};
         this.options = options;
-        this.redisClient = redisConfig && redis_1.default(redisConfig);
+        this.redisClient = redisConfig && (0, redis_1.default)(redisConfig);
         if (this.redisClient) {
-            this.redisLock = util_1.promisify(redis_lock_1.default(this.redisClient));
+            this.redisLock = (0, util_1.promisify)((0, redis_lock_1.default)(this.redisClient));
         }
         this.consumersTags = [];
         logger_1.default.info(`rabbit: [gracefully-shutdown] adding gracefully shutdown for process.pid ${process.pid}`);
@@ -101,41 +133,8 @@ class RabbitMq {
             });
         }
     }
-    static parseMsg(msg) {
-        let { content } = msg;
-        content = content.toString();
-        try {
-            content = JSON.parse(content);
-        }
-        catch (e) { }
-        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 trace = zehut_1.getCurrentPayload();
-        const user = trace?.context?.get(consts_1.USER_OBJECT);
-        const traceId = trace?.context?.get(consts_1.TRACING_HEADER);
-        const outbreakTrace = zehut_1.outbreak.getCurrentContext();
-        return {
-            timestamp: moment_1.default().unix(),
-            timeout: PUBLISH_TIMEOUT,
-            headers: {
-                creationTimestamp: moment_1.default().valueOf(),
-                ...customHeaders,
-                [consts_1.USER_TRACING_HEADER]: user?.id,
-                [consts_1.TRACING_HEADER]: traceId || outbreakTrace?.context?.get(consts_1.TRACING_HEADER),
-            },
-        };
-    }
     async getConnection() {
-        return new Promise(async (resolve, reject) => {
+        return new Promise(async (resolve) => {
             if (this.blockReconnect) {
                 debug('rabbit: block reconnect');
                 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -143,57 +142,29 @@ class RabbitMq {
                 return resolve();
             }
             if (this.connection !== null) {
+                debug('rabbit: connection already exist');
                 if (this.options?.disableReconnect || this.connection?.isConnected()) {
-                    debug('rabbit: connection - is connected');
                     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                     // @ts-ignore
                     return resolve(this.connection);
                 }
-                debug('rabbit: connection - reconnecting');
+                debug('rabbit: connection already exist - reconnecting');
             }
             if (this.creatingConnection) {
                 debug('rabbit: creating connection emi');
                 this.em.once(consts_1.CONNECTION_CREATED_CONST, resolve);
-                this.em.once(consts_1.CONNECTION_FAILED_CONST, reject);
                 return;
             }
             this.creatingConnection = true;
-            let isResolved = false;
-            // It is import to use it as a function and not as a variable
-            // because of k8s changes the env variables
-            // and we want to use the new values
-            const findServers = () => {
-                const userName = process.env.RABBITMQ_USERNAME || 'guest';
-                const password = process.env.RABBITMQ_PASSWORD || 'guest';
-                const host = this.options?.rabbitHost || process.env.RABBITMQ_SERVICE_HOST || 'localhost';
-                debug('rabbit: creating connection', { host, userName, HEARTBEAT });
-                return [`amqp://${userName}:${password}@${host}?heartbeat=${HEARTBEAT}`];
-            };
-            const defaultUrls = findServers();
-            const connection = await amqp_connection_manager_1.connect(defaultUrls, {
-                findServers,
-            });
+            debug('rabbit: creating connection', { HOST, USERNAME, HEARTBEAT });
+            const connection = await (0, amqp_connection_manager_1.connect)([`amqp://${USERNAME}:${PASSWORD}@${HOST}?heartbeat=${HEARTBEAT}}`]);
             this.connection = connection;
-            this.connection.on('error', (err) => {
-                logger_1.default.error('rabbit: connection error', { err });
-                if (!isResolved) {
-                    isResolved = true;
-                    reject(err);
-                    this.em.emit(consts_1.CONNECTION_FAILED_CONST, err);
-                }
-            });
-            this.connection.on('connectFailed', (err) => {
-                this.consumersTags = [];
-                logger_1.default.error('rabbit: connection connectFailed', { err });
-                if (!isResolved) {
-                    isResolved = true;
-                    reject(err);
-                    this.em.emit(consts_1.CONNECTION_FAILED_CONST, err);
-                }
-            });
             this.connection.on('disconnect', ({ err }) => {
-                this.consumersTags = [];
                 debug('rabbit: connection closed');
+                this.exchanges = {};
+                this.queues = {};
+                this.connection = null;
+                this.channel = null;
                 if (this.options?.disableReconnect) {
                     logger_1.default.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`);
                     this.blockReconnect = true;
@@ -204,26 +175,19 @@ class RabbitMq {
             });
             this.connection.once('connect', async () => {
                 debug('rabbit: connection established');
+                await this.loadConsumers();
                 this.creatingConnection = false;
                 this.em.emit(consts_1.CONNECTION_CREATED_CONST, connection);
-                isResolved = true;
                 resolve(connection);
             });
         });
     }
-    async getNewChannel({ name = utils_1.rand().toString(), onClose = null, options = {} } = {}) {
+    async getNewChannel({ name = '', onClose = null } = {}) {
         return new Promise(async (resolve, reject) => {
             const connection = await this.getConnection();
-            const channel = connection.createChannel({
-                ...options,
-            });
-            let isResolved = false;
+            const channel = connection.createChannel({});
             channel.on('error', (err) => {
-                logger_1.default.error(`rabbit: channel error ${name} error`, { err });
-                if (!isResolved) {
-                    isResolved = true;
-                    reject(err);
-                }
+                logger_1.default.error(`rabbit: channel ${name} error`, { err });
             });
             channel.on('close', (...args) => {
                 logger_1.default.error(`rabbit: channel ${name} closed`, { args });
@@ -233,7 +197,6 @@ class RabbitMq {
             });
             channel.once('connect', () => {
                 debug(`rabbit: channel ${name} CONNECTED`);
-                isResolved = true;
                 resolve(channel);
             });
         });
@@ -244,9 +207,10 @@ class RabbitMq {
                 return resolve(this.channel);
             }
             try {
-                const channel = await this.getNewChannel({});
-                channel.on('error', (err) => {
-                    logger_1.default.error('rabbit: channel error', { err });
+                const channel = await this.getNewChannel({
+                    onClose: () => {
+                        this.channel = null;
+                    },
                 });
                 this.channel = channel;
                 resolve(channel);
@@ -261,26 +225,25 @@ class RabbitMq {
         if (this.exchanges[exchangeName]) {
             return this.exchanges[exchangeName];
         }
-        const exchange = await utils_1.assertExchangeFanout(channel, exchangeName);
+        const exchange = await (0, utils_1.assertExchangeFanout)(channel, exchangeName);
         this.exchanges[exchangeName] = exchange;
         return exchange;
     }
     async getQueueLength(queue) {
         RabbitMq.validateName('queue', queue);
-        const { channel } = this;
-        if (!channel) {
-            throw new Error('channel is not defined');
-        }
+        const channel = await this.assertChannel();
         debug('rabbit: getting queue length', { queue, connected: this.connection?.isConnected() });
-        return channel?.checkQueue(queue);
+        return channel.checkQueue(queue);
     }
     async deleteQueue(queue) {
-        RabbitMq.validateName('queue', queue);
-        const channel = await this.assertChannel();
-        logger_1.default.info('rabbit: deleting queue', { queue });
-        const deleteQueueRes = await channel.deleteQueue(queue);
-        debug('queue deleted', deleteQueueRes);
-        return deleteQueueRes;
+        return new Promise(async (resolve, reject) => {
+            RabbitMq.validateName('queue', queue);
+            const channel = await this.assertChannel();
+            logger_1.default.info('rabbit: deleting queue', { queue });
+            const deleteQueueRes = await channel.deleteQueue(queue);
+            debug('queue deleted', deleteQueueRes);
+            resolve(deleteQueueRes);
+        });
     }
     async bindQueue(queue, exchange) {
         const channel = await this.assertChannel();
@@ -302,7 +265,7 @@ class RabbitMq {
         }
         catch (e) {
             logger_1.default.error('rabbit: assertQueue error', { queueName, options, error: e });
-            if (!this.options?.dontRetryAssert) {
+            if (this.options?.retryAssert) {
                 debug('retrying assertQueue', { queueName });
                 const channel = await this.assertChannel({ force: true });
                 await this.deleteQueue(queueName);
@@ -325,8 +288,18 @@ class RabbitMq {
             options,
         });
     }
+    async loadConsumers() {
+        debug('rabbit: loading consumers', { consumers: this.consumers.length });
+        if (this.consumers.length > 0) {
+            await Promise.all(this.consumers.map((consumer) => this
+                .consumeFromRabbit(consumer.queue, consumer.callback, consumer.options)));
+        }
+    }
     async consume(queue, callback, options) {
-        return this.consumeFromRabbit(queue, callback, options);
+        if (this.connection && !this.creatingConnection) {
+            this.consumeFromRabbit(queue, callback, options);
+        }
+        return this.saveConsumer(queue, callback, options);
     }
     async lockRedisIfNeeded(msg, options) {
         const { properties: { headers } } = msg;
@@ -345,83 +318,46 @@ class RabbitMq {
     async consumeFromRabbit(queue, callback, options) {
         const optionsWithDefaults = { ...consts_1.DEFAULT_OPTIONS, ...options };
         RabbitMq.validateName('queue', queue);
-        const { limit, deadMessageTtl, useConsumeWithLock, lockTimeout, auditContext, enableRabbitTrace, } = optionsWithDefaults;
+        const { limit, deadMessageTtl, useConsumeWithLock, lockTimeout, } = optionsWithDefaults;
         if (useConsumeWithLock) {
             if (!this.redisLock) {
                 throw new Error('Usage of consumeWithLock requires RedisInstance');
             }
             logger_1.default.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
         }
-        const channel = await this.getNewChannel({ name: `consume-queue-${queue}` });
-        return channel.addSetup(async (confirmChannel) => {
-            await confirmChannel.assertQueue(queue, options ? { messageTtl: options.messageTtl } : undefined);
-            await confirmChannel.prefetch(limit, true);
-            const { consumerTag } = await confirmChannel.consume(queue, async (msg) => {
+        const channel = await this.getNewChannel({ name: `consume-${queue}` });
+        return channel.addSetup(async (c) => {
+            await c.assertQueue(queue, options ? { messageTtl: options.messageTtl } : undefined);
+            await c.prefetch(limit, true);
+            const { consumerTag } = await c.consume(queue, async (msg) => {
                 if (!msg) {
                     return null;
                 }
                 const traceId = msg.properties.headers[consts_1.TRACING_HEADER];
-                const userId = msg.properties.headers[consts_1.USER_TRACING_HEADER];
-                const parsedMessage = RabbitMq.parseMsg(msg);
-                const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
-                const trace = 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([
-                            zehut_1.createOrSetRabbitTrace(trace, userId),
-                            zehut_1.createOrSetRabbitTrace(outbreakTrace, userId),
-                        ]);
-                    }
-                    catch (e) {
-                        logger_1.default.error('rabbit: failed to setRabbitTrace', { userId, e });
-                        return this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
-                    }
-                }
                 if (traceId) {
+                    const trace = (0, outbreak_1.newTrace)(outbreak_1.traceTypes.RABBIT);
                     trace?.context?.set(consts_1.TRACING_HEADER, traceId);
-                    outbreakTrace?.context.set(consts_1.TRACING_HEADER, traceId);
-                }
-                if (auditContext) {
-                    await auditContext(queue);
                 }
+                const parsedMessage = RabbitMq.parseMsg(msg);
+                const releaseLock = await this.lockRedisIfNeeded(parsedMessage, optionsWithDefaults);
                 const shouldConsume = await this.shouldConsumeMessageByTimestamp(parsedMessage);
                 if (!shouldConsume) {
                     await this.unlockRedisIfNeeded(releaseLock);
-                    return this.ack(confirmChannel, msg)(msg);
+                    return this.ack(channel, msg)(msg);
                 }
-                let messageAcked = false;
-                // setting the localAck function to be used in the callback
-                const localAck = async () => {
-                    if (messageAcked) {
-                        return;
-                    }
-                    messageAcked = true;
-                    return this.ack(confirmChannel, msg, true, releaseLock)(msg);
-                };
-                const localNack = async (_, nackOptions = {}) => {
-                    if (messageAcked) {
-                        return;
-                    }
-                    messageAcked = true;
-                    return this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg, nackOptions);
-                };
                 try {
-                    await callback(parsedMessage, localAck, localNack);
+                    await callback(parsedMessage, this.ack(channel, msg, true, releaseLock), this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock));
                 }
                 catch (e) {
-                    await localNack(msg);
+                    await this.nack(channel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg);
                 }
-            }, types_1.CONSUMER_DEFAULT_OPTIONS);
+            });
             if (!consumerTag) {
                 logger_1.default.error(`rabbit: failed to consume from queue ${queue}`);
             }
             else {
                 logger_1.default.info(`rabbit: adding tag ${consumerTag} to the array.`);
-                this.consumersTags.push([confirmChannel, consumerTag]);
+                this.consumersTags.push([c, consumerTag]);
             }
         });
     }
@@ -430,9 +366,9 @@ class RabbitMq {
         RabbitMq.validateName('exchange', exchange);
         RabbitMq.validateName('queue', queue);
         const { limit, deadMessageTtl } = optionsWithDefaults;
-        const channel = await this.getNewChannel({ name: `consume-exchange-${exchange}-queue-${queue}` });
+        const channel = await this.getNewChannel();
         return channel.addSetup(async (c) => {
-            const assertExchange = await utils_1.assertExchangeFanout(c, exchange);
+            const assertExchange = await (0, utils_1.assertExchangeFanout)(c, exchange);
             await c.assertQueue(queue);
             this.exchanges[exchange] = assertExchange;
             await c.prefetch(limit, true);
@@ -443,7 +379,7 @@ class RabbitMq {
         });
     }
     async publish(exchange, content, customHeaders) {
-        return utils_1.wrapSetImmediate(async () => {
+        return (0, utils_1.wrapSetImmediate)(async () => {
             RabbitMq.validateName('exchange', exchange);
             const channel = await this.assertChannel();
             await this.assertExchange(exchange);
@@ -452,41 +388,21 @@ class RabbitMq {
     }
     async sendToQueue(queue, content, options, customHeaders, isBlocking) {
         const callback = async () => {
-            try {
-                RabbitMq.validateName('queue', queue);
-                await this.assertChannel();
-                await this.assertQueue(queue, options);
-                const res = await this.channel?.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
-                debug(`rabbit: sending to queue ${queue}`, { res });
-                return res;
-            }
-            catch (e) {
-                logger_1.default.error(`rabbit: failed to send to queue ${queue}`, { e });
-                throw e;
-            }
+            RabbitMq.validateName('queue', queue);
+            await this.assertChannel();
+            await this.assertQueue(queue, options);
+            const res = await this.channel?.sendToQueue(queue, Buffer.from(JSON.stringify(content)), RabbitMq.getPublishOptions(customHeaders));
+            debug(`rabbit: sending to queue ${queue}`, { res });
+            return res;
         };
         if (isBlocking) {
             return callback();
         }
-        return utils_1.wrapSetImmediate(callback);
+        return (0, utils_1.wrapSetImmediate)(callback);
     }
     async isConnected() {
         const connection = await this.getConnection();
-        const isConnected = connection.isConnected();
-        if (!isConnected) {
-            logger_1.default.error('rabbit: isConnected - false');
-            return false;
-        }
-        const channel = await this.assertChannel();
-        try {
-            await channel.waitForConnect();
-        }
-        catch (e) {
-            logger_1.default.error('rabbit: isConnected - false');
-            return false;
-        }
-        logger_1.default.info('rabbit: isConnected - true');
-        return true;
+        return connection.isConnected();
     }
     async gracefulShutdown(signal) {
         const tagsNumber = this.consumersTags.length;

package/dist/lib/consts.d.ts

@@ -2,17 +2,12 @@ export declare const DEFAULT_DEAD_TTL_TWO_DAYS: number;
 export declare const DEFAULT_LOCK_TIMEOUT: number;
 export declare const RETRY_HEADER = "x-retry-count";
 export declare const TRACING_HEADER = "x-trace-id";
-export declare const USER_TRACING_HEADER = "x-af-user-id";
-export declare const USER_OBJECT = "userObject";
 export declare const DEFAULT_USE_CONSUME_WITH_LOCK = false;
 export declare const CONNECTION_CREATED_CONST = "connectionCreated";
-export declare const CONNECTION_FAILED_CONST = "connectionFailed";
 export declare const DEFAULT_OPTIONS: {
     limit: number;
     retries: number;
     deadMessageTtl: number;
     lockTimeout: number;
     useConsumeWithLock: boolean;
-    auditContext: null;
-    enableRabbitTrace: boolean;
 };

package/dist/lib/consts.js

@@ -1,21 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_OPTIONS = exports.CONNECTION_FAILED_CONST = exports.CONNECTION_CREATED_CONST = exports.DEFAULT_USE_CONSUME_WITH_LOCK = exports.USER_OBJECT = exports.USER_TRACING_HEADER = exports.TRACING_HEADER = exports.RETRY_HEADER = exports.DEFAULT_LOCK_TIMEOUT = exports.DEFAULT_DEAD_TTL_TWO_DAYS = void 0;
+exports.DEFAULT_OPTIONS = exports.CONNECTION_CREATED_CONST = exports.DEFAULT_USE_CONSUME_WITH_LOCK = exports.TRACING_HEADER = exports.RETRY_HEADER = exports.DEFAULT_LOCK_TIMEOUT = exports.DEFAULT_DEAD_TTL_TWO_DAYS = void 0;
 exports.DEFAULT_DEAD_TTL_TWO_DAYS = 60000 * 60 * 12;
 exports.DEFAULT_LOCK_TIMEOUT = 1000 * 5;
 exports.RETRY_HEADER = 'x-retry-count';
 exports.TRACING_HEADER = 'x-trace-id';
-exports.USER_TRACING_HEADER = 'x-af-user-id';
-exports.USER_OBJECT = 'userObject';
 exports.DEFAULT_USE_CONSUME_WITH_LOCK = false;
 exports.CONNECTION_CREATED_CONST = 'connectionCreated';
-exports.CONNECTION_FAILED_CONST = 'connectionFailed';
 exports.DEFAULT_OPTIONS = {
     limit: 1,
     retries: 1,
     deadMessageTtl: exports.DEFAULT_DEAD_TTL_TWO_DAYS,
     lockTimeout: exports.DEFAULT_LOCK_TIMEOUT,
     useConsumeWithLock: exports.DEFAULT_USE_CONSUME_WITH_LOCK,
-    auditContext: null,
-    enableRabbitTrace: false,
 };

package/dist/lib/redis.d.ts

@@ -1,4 +1,4 @@
-export declare type RedisConfig = {
+export type RedisConfig = {
     host: string;
     port: number | undefined;
     prefix?: string;

package/dist/lib/types.d.ts

@@ -1,15 +1,15 @@
-import { ConsumeMessage, Options } from 'amqplib';
+import { ConsumeMessage } from 'amqplib';
 export interface ExchangesCache {
     [key: string]: any;
 }
 export interface QueuesCache {
     [key: string]: any;
 }
-export declare type CustomMessageHeaders = {
+export type CustomMessageHeaders = {
     redisTimestampValidationKey?: string;
 };
-export declare type RedisLockType = (args0?: string, arg1?: number) => Promise<any>;
-export declare type ConsumeMessageOrNull = ConsumeMessage | null;
+export type RedisLockType = (args0?: string, arg1?: number) => Promise<any>;
+export type ConsumeMessageOrNull = ConsumeMessage | null;
 export interface ConsumeOptions {
     retries?: number;
     deadMessageTtl?: number;
@@ -17,21 +17,5 @@ export interface ConsumeOptions {
     limit?: number;
     lockTimeout?: number;
     useConsumeWithLock?: boolean;
-    auditContext?: any;
-    enableRabbitTrace?: boolean;
 }
-export declare type CallbackFunction = (msg: ConsumeMessage, ack: any, nack: any) => Promise<any>;
-export declare type newChannelOpts = {
-    name?: string;
-    onClose?: null | ((args: any | null) => void);
-};
-export declare type assertChannelOpts = {
-    channelName?: string;
-    force?: boolean;
-};
-export declare type AfConsumer = {
-    queue: string;
-    callback: CallbackFunction;
-    options: ConsumeOptions | undefined;
-};
-export declare const CONSUMER_DEFAULT_OPTIONS: Options.Consume;
+export type CallbackFunction = (msg: ConsumeMessage, ack: any, nack: any) => Promise<any>;

package/dist/lib/types.js

@@ -1,11 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONSUMER_DEFAULT_OPTIONS = void 0;
-const HA_PROMOTE_ON_FAILURE = 'ha-promote-on-failure';
-const HA_PROMOTE_ON_SHUTDOWN = 'ha-promote-on-shutdown';
-exports.CONSUMER_DEFAULT_OPTIONS = {
-    arguments: {
-        [HA_PROMOTE_ON_FAILURE]: 'always',
-        [HA_PROMOTE_ON_SHUTDOWN]: 'always',
-    },
-};

package/dist/lib/utils.d.ts

@@ -2,4 +2,3 @@ import { ChannelWrapper } from 'amqp-connection-manager';
 import { ConfirmChannel } from 'amqplib';
 export declare const assertExchangeFanout: (c: ChannelWrapper | ConfirmChannel, exchangeName: string) => Promise<import("amqplib").Replies.AssertExchange>;
 export declare const wrapSetImmediate: (callback: () => any) => Promise<any>;
-export declare const rand: () => number;

package/dist/lib/utils.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rand = exports.wrapSetImmediate = exports.assertExchangeFanout = void 0;
-exports.assertExchangeFanout = async (c, exchangeName) => c.assertExchange(exchangeName, 'fanout');
-exports.wrapSetImmediate = (callback) => new Promise((resolve, reject) => {
+exports.wrapSetImmediate = exports.assertExchangeFanout = void 0;
+const assertExchangeFanout = async (c, exchangeName) => c.assertExchange(exchangeName, 'fanout');
+exports.assertExchangeFanout = assertExchangeFanout;
+const wrapSetImmediate = (callback) => new Promise((resolve, reject) => {
     setImmediate(async () => {
         try {
             const value = await callback();
@@ -13,4 +14,4 @@ exports.wrapSetImmediate = (callback) => new Promise((resolve, reject) => {
         }
     });
 });
-exports.rand = () => Math.floor(Math.random() * 100000);
+exports.wrapSetImmediate = wrapSetImmediate;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "3.2.5",
+  "version": "3.2.6-testing",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/index.ts

@@ -13,6 +13,7 @@ import {
 import {
   getCurrentPayload, newTrace, traceTypes, createOrSetRabbitTrace, outbreak,
 } from '@autofleet/zehut';
+import { v4 } from 'uuid';
 import logger from './logger';
 import RabbitError from './lib/rabbitError';
 import getRedisInstance, { RedisConfig } from './lib/redis';
@@ -170,6 +171,7 @@ class RabbitMq implements IAfRabbitMq {
     this.creatingConnection = false;
     this.exchanges = {};
     this.queues = {};
+    this.consumers = [];
     this.options = options;
     this.redisClient = redisConfig && getRedisInstance(redisConfig);
     if (this.redisClient) {
@@ -203,6 +205,7 @@ class RabbitMq implements IAfRabbitMq {
 
   public ack = (channel: ConfirmChannel, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp = false, releaseLock = null) => async (userMsg: ConsumeMessage) : Promise<any> => {
     if (msg) {
+      debug('rabbit acking message', { deliveryTag: msg.fields.deliveryTag });
       await channel.ack(msg);
       const { properties: { headers } } = msg;
       const timestamp = headers?.creationTimestamp;
@@ -252,6 +255,7 @@ class RabbitMq implements IAfRabbitMq {
             : 1,
         });
       }
+      debug('rabbit nacking message', { deliveryTag: msg.fields.deliveryTag });
       await channel.ack(msg);
     } else {
       logger.error('no channel or msg', {
@@ -380,8 +384,7 @@ class RabbitMq implements IAfRabbitMq {
       }
 
       try {
-        const channel = await this.getNewChannel({
-        });
+        const channel = await this.getNewChannel({});
         channel.on('error', (err) => {
           logger.error('rabbit: channel error', { err });
         });
@@ -469,7 +472,8 @@ class RabbitMq implements IAfRabbitMq {
   }
 
   async consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
-    return this.consumeFromRabbit(queue, callback, options);
+    await this.consumeFromRabbit(queue, callback, options);
+    return this.saveConsumer(queue, callback, options);
   }
 
   private async lockRedisIfNeeded(msg: any, options: any) {
@@ -495,6 +499,7 @@ class RabbitMq implements IAfRabbitMq {
   private async consumeFromRabbit(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<any> {
     const optionsWithDefaults = { ...DEFAULT_OPTIONS, ...options };
     RabbitMq.validateName('queue', queue);
+    const uniqueId = v4();
     const {
       limit, deadMessageTtl, useConsumeWithLock, lockTimeout, auditContext, enableRabbitTrace,
     } = optionsWithDefaults;
@@ -504,7 +509,7 @@ class RabbitMq implements IAfRabbitMq {
       }
       logger.info(`rabbit: Consuming with lock from queue ${queue} with lockTimeout: ${lockTimeout}ms`);
     }
-    const channel: ChannelWrapper = await this.getNewChannel({ name: `consume-queue-${queue}` });
+    const channel = await this.assertChannel();
     return channel.addSetup(async (confirmChannel: ConfirmChannel) => {
       await confirmChannel.assertQueue(queue, options ? { messageTtl: options.messageTtl } : undefined);
       await confirmChannel.prefetch(limit, true);
@@ -557,6 +562,7 @@ class RabbitMq implements IAfRabbitMq {
             if (messageAcked) {
               return;
             }
+            debug('rabbit localAck', { messageAcked, uniqueId, deliveryTag: msg.fields.deliveryTag });
             messageAcked = true;
             return this.ack(confirmChannel, msg, true, releaseLock)(msg);
           };
@@ -565,6 +571,7 @@ class RabbitMq implements IAfRabbitMq {
             if (messageAcked) {
               return;
             }
+            debug('rabbit localNack', { messageAcked, uniqueId, deliveryTag: msg.fields.deliveryTag });
             messageAcked = true;
             return this.nack(confirmChannel, queue, optionsWithDefaults, { messageTtl: deadMessageTtl }, msg, releaseLock)(msg, nackOptions);
           };
@@ -660,7 +667,12 @@ class RabbitMq implements IAfRabbitMq {
     }
     const channel = await this.assertChannel();
     try {
-      await channel.waitForConnect();
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      await Promise.all([
+        channel.waitForConnect(),
+        ...this.consumers.map((c: AfConsumer) => channel.checkQueue(c.queue)),
+      ]);
     } catch (e) {
       logger.error('rabbit: isConnected - false');
       return false;