redis-smq 6.2.3 → 6.2.6

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # CHANGELOG
 
+## 6.2.6 (2022-03-04)
+
+* Clean up (2837cc6)
+* Implement MessageHandlerRunner (cfba094)
+
+## 6.2.5 (2022-03-03)
+
+* Update Consumer API docs (8580f4a)
+* Do not consume messages with and without priority from the same queue (84130bf)
+* Use default parameters when creating a Ticker instance (db9feb0)
+* Update consumer queue list upon shutting down a message handler (14519e2)
+
+## 6.2.4 (2022-02-23)
+
+* Fix consuming-messages/test00015 error (c5c365a)
+
 ## 6.2.3 (2022-02-23)
 
 * Bump up redis-smq-monitor to v6.5.3 (4e845d0)

package/dist/src/system/app/consumer/consumer-frontend.d.ts

@@ -6,7 +6,8 @@ export declare class ConsumerFrontend extends EventEmitter {
     constructor();
     private registerEvents;
     consume(queue: string | TQueueParams, usePriorityQueuing: boolean, messageHandler: TConsumerMessageHandler, cb: ICallback<boolean>): void;
-    cancel(queue: string | TQueueParams, usePriority: boolean, cb: ICallback<void>): void;
+    cancel(queue: string | TQueueParams, cb: ICallback<void>): void;
+    cancel(queue: string | TQueueParams, usePriorityQueuing: boolean, cb: ICallback<void>): void;
     run(cb?: ICallback<boolean>): void;
     shutdown(cb?: ICallback<boolean>): void;
     isGoingUp(): boolean;

package/dist/src/system/app/consumer/consumer-frontend.js

@@ -4,6 +4,8 @@ exports.ConsumerFrontend = void 0;
 const events_1 = require("events");
 const consumer_1 = require("./consumer");
 const events_2 = require("../../common/events");
+const argument_error_1 = require("../../common/errors/argument.error");
+const queue_manager_1 = require("../queue-manager/queue-manager");
 class ConsumerFrontend extends events_1.EventEmitter {
     constructor() {
         super();
@@ -21,10 +23,19 @@ class ConsumerFrontend extends events_1.EventEmitter {
             .on(events_2.events.MESSAGE_RECEIVED, (...args) => this.emit(events_2.events.MESSAGE_RECEIVED, ...args));
     }
     consume(queue, usePriorityQueuing, messageHandler, cb) {
-        return this.consumer.consume(queue, usePriorityQueuing, messageHandler, cb);
+        const queueParams = queue_manager_1.queueManager.getQueueParams(queue);
+        return this.consumer.consume(queueParams, usePriorityQueuing, messageHandler, cb);
     }
-    cancel(queue, usePriority, cb) {
-        this.consumer.cancel(queue, usePriority, cb);
+    cancel(queue, mixed, cb) {
+        const callback = (() => {
+            if (typeof mixed === 'function')
+                return mixed;
+            if (typeof mixed === 'boolean' && typeof cb === 'function')
+                return cb;
+            throw new argument_error_1.ArgumentError('Invalid arguments provided');
+        })();
+        const queueParams = queue_manager_1.queueManager.getQueueParams(queue);
+        this.consumer.cancel(queueParams, callback);
     }
     run(cb) {
         this.consumer.run(cb);

package/dist/src/system/app/consumer/consumer-heartbeat.d.ts

@@ -13,7 +13,7 @@ export declare class ConsumerHeartbeat extends EventEmitter {
     protected consumerId: string;
     constructor(consumer: Consumer, redisClient: RedisClient);
     protected getPayload(): THeartbeatPayload;
-    protected onTick(): void;
+    protected onTick: () => void;
     quit(cb: ICallback<void>): void;
     static validateHeartbeatsOf(redisClient: RedisClient, consumerIds: string[], cb: ICallback<Record<string, boolean>>): void;
     static getValidHeartbeats(redisClient: RedisClient, transform: boolean, cb: ICallback<{

package/dist/src/system/app/consumer/consumer-heartbeat.js

@@ -34,15 +34,29 @@ function cpuUsage() {
 class ConsumerHeartbeat extends events_2.EventEmitter {
     constructor(consumer, redisClient) {
         super();
+        this.onTick = () => {
+            const timestamp = Date.now();
+            const heartbeatPayload = this.getPayload();
+            const heartbeatPayloadStr = JSON.stringify(heartbeatPayload);
+            const multi = this.redisClient.multi();
+            multi.hset(this.keyHeartbeats, this.consumerId, heartbeatPayloadStr);
+            multi.zadd(this.keyHeartbeatTimestamps, timestamp, this.consumerId);
+            this.redisClient.execMulti(multi, (err) => {
+                if (err)
+                    this.emit(events_1.events.ERROR, err);
+                else {
+                    this.emit(events_1.events.HEARTBEAT_TICK, timestamp, this.consumerId, heartbeatPayload);
+                    this.ticker.nextTick();
+                }
+            });
+        };
         this.redisClient = redisClient;
         this.consumerId = consumer.getId();
         const { keyHeartbeats } = consumer.getRedisKeys();
         this.keyHeartbeats = keyHeartbeats;
         this.keyHeartbeatTimestamps =
             redis_keys_1.redisKeys.getMainKeys().keyHeartbeatInstanceIds;
-        this.ticker = new ticker_1.Ticker(() => {
-            this.onTick();
-        }, 1000);
+        this.ticker = new ticker_1.Ticker(this.onTick);
         this.ticker.nextTick();
     }
     getPayload() {
@@ -59,22 +73,6 @@ class ConsumerHeartbeat extends events_2.EventEmitter {
             },
         };
     }
-    onTick() {
-        const timestamp = Date.now();
-        const heartbeatPayload = this.getPayload();
-        const heartbeatPayloadStr = JSON.stringify(heartbeatPayload);
-        const multi = this.redisClient.multi();
-        multi.hset(this.keyHeartbeats, this.consumerId, heartbeatPayloadStr);
-        multi.zadd(this.keyHeartbeatTimestamps, timestamp, this.consumerId);
-        this.redisClient.execMulti(multi, (err) => {
-            if (err)
-                this.emit(events_1.events.ERROR, err);
-            else {
-                this.emit(events_1.events.HEARTBEAT_TICK, timestamp, this.consumerId, heartbeatPayload);
-                this.ticker.nextTick();
-            }
-        });
-    }
     quit(cb) {
         (0, async_1.waterfall)([
             (cb) => {

package/dist/src/system/app/consumer/consumer-message-handler/message-handler-runner.d.ts

@@ -0,0 +1,29 @@
+import { Consumer } from '../consumer';
+import { MessageHandler } from './message-handler';
+import { ICallback, ICompatibleLogger, TConsumerMessageHandler, TConsumerMessageHandlerParams, TQueueParams } from '../../../../../types';
+import { RedisClient } from '../../../common/redis-client/redis-client';
+import { ConsumerMessageRate } from '../consumer-message-rate';
+export declare class MessageHandlerRunner {
+    private readonly consumer;
+    private redisClient;
+    private messageHandlerInstances;
+    private messageHandlers;
+    private config;
+    protected logger: ICompatibleLogger;
+    constructor(consumer: Consumer);
+    protected registerMessageHandlerEvents: (messageHandler: MessageHandler) => void;
+    protected getMessageHandlerInstance: (queue: TQueueParams) => MessageHandler | undefined;
+    protected getMessageHandler(queue: TQueueParams): TConsumerMessageHandlerParams | undefined;
+    protected createMessageRateInstance: (queue: TQueueParams, redisClient: RedisClient) => ConsumerMessageRate;
+    protected runMessageHandler: (handlerParams: TConsumerMessageHandlerParams, cb: ICallback<void>) => void;
+    protected shutdownMessageHandler: (messageHandler: MessageHandler, cb: ICallback<void>) => void;
+    protected getRedisClient(): RedisClient;
+    run: (redisClient: RedisClient, cb: ICallback<void>) => void;
+    shutdown: (cb: ICallback<void>) => void;
+    removeMessageHandler: (queue: TQueueParams, cb: ICallback<void>) => void;
+    addMessageHandler: (queue: TQueueParams, usePriorityQueuing: boolean, messageHandler: TConsumerMessageHandler, cb: ICallback<boolean>) => void;
+    getQueues: () => {
+        queue: TQueueParams;
+        usingPriorityQueuing: boolean;
+    }[];
+}

package/dist/src/system/app/consumer/consumer-message-handler/message-handler-runner.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageHandlerRunner = void 0;
+const message_handler_1 = require("./message-handler");
+const events_1 = require("../../../common/events");
+const redis_client_1 = require("../../../common/redis-client/redis-client");
+const empty_callback_reply_error_1 = require("../../../common/errors/empty-callback-reply.error");
+const async_1 = require("../../../lib/async");
+const configuration_1 = require("../../../common/configuration/configuration");
+const logger_1 = require("../../../common/logger");
+const consumer_message_rate_1 = require("../consumer-message-rate");
+const consumer_message_rate_writer_1 = require("../consumer-message-rate-writer");
+const message_handler_already_exists_error_1 = require("../errors/message-handler-already-exists.error");
+const panic_error_1 = require("../../../common/errors/panic.error");
+class MessageHandlerRunner {
+    constructor(consumer) {
+        this.redisClient = null;
+        this.messageHandlerInstances = [];
+        this.messageHandlers = [];
+        this.registerMessageHandlerEvents = (messageHandler) => {
+            messageHandler.on(events_1.events.ERROR, (...args) => this.consumer.emit(events_1.events.ERROR, ...args));
+            messageHandler.on(events_1.events.IDLE, (...args) => this.consumer.emit(events_1.events.IDLE, ...args));
+            messageHandler.on(events_1.events.MESSAGE_UNACKNOWLEDGED, (...args) => this.consumer.emit(events_1.events.MESSAGE_UNACKNOWLEDGED, ...args));
+            messageHandler.on(events_1.events.MESSAGE_DEAD_LETTERED, (...args) => this.consumer.emit(events_1.events.MESSAGE_DEAD_LETTERED, ...args));
+            messageHandler.on(events_1.events.MESSAGE_ACKNOWLEDGED, (...args) => this.consumer.emit(events_1.events.MESSAGE_ACKNOWLEDGED, ...args));
+        };
+        this.getMessageHandlerInstance = (queue) => {
+            return this.messageHandlerInstances.find((i) => {
+                const q = i.getQueue();
+                return q.name === queue.name && q.ns === queue.ns;
+            });
+        };
+        this.createMessageRateInstance = (queue, redisClient) => {
+            const messageRateWriter = new consumer_message_rate_writer_1.ConsumerMessageRateWriter(redisClient, queue, this.consumer.getId());
+            return new consumer_message_rate_1.ConsumerMessageRate(messageRateWriter);
+        };
+        this.runMessageHandler = (handlerParams, cb) => {
+            redis_client_1.RedisClient.getNewInstance((err, client) => {
+                if (err)
+                    cb(err);
+                else if (!client)
+                    cb(new empty_callback_reply_error_1.EmptyCallbackReplyError());
+                else {
+                    const redisClient = this.getRedisClient();
+                    const { queue, usePriorityQueuing, messageHandler } = handlerParams;
+                    const messageRate = this.config.monitor.enabled
+                        ? this.createMessageRateInstance(queue, redisClient)
+                        : null;
+                    const handler = new message_handler_1.MessageHandler(this.consumer.getId(), queue, messageHandler, usePriorityQueuing, client, messageRate);
+                    this.registerMessageHandlerEvents(handler);
+                    this.messageHandlerInstances.push(handler);
+                    this.logger.info(`Created a new instance (ID: ${handler.getId()}) for MessageHandler (${JSON.stringify(handlerParams)}).`);
+                    handler.run(cb);
+                }
+            });
+        };
+        this.shutdownMessageHandler = (messageHandler, cb) => {
+            const queue = messageHandler.getQueue();
+            const redisClient = this.getRedisClient();
+            messageHandler.shutdown(redisClient, () => {
+                this.messageHandlerInstances = this.messageHandlerInstances.filter((handler) => {
+                    const q = handler.getQueue();
+                    return !(q.name === queue.name && q.ns === queue.ns);
+                });
+                cb();
+            });
+        };
+        this.run = (redisClient, cb) => {
+            this.redisClient = redisClient;
+            (0, async_1.each)(this.messageHandlers, (handlerParams, _, done) => {
+                this.runMessageHandler(handlerParams, done);
+            }, cb);
+        };
+        this.shutdown = (cb) => {
+            (0, async_1.each)(this.messageHandlerInstances, (handler, queue, done) => {
+                this.shutdownMessageHandler(handler, done);
+            }, (err) => {
+                if (err)
+                    cb(err);
+                else {
+                    this.redisClient = null;
+                    cb();
+                }
+            });
+        };
+        this.removeMessageHandler = (queue, cb) => {
+            const handler = this.getMessageHandler(queue);
+            if (!handler)
+                cb();
+            else {
+                this.messageHandlers = this.messageHandlers.filter((handler) => {
+                    const q = handler.queue;
+                    return !(q.name === queue.name && q.ns === queue.ns);
+                });
+                this.logger.info(`Message handler with parameters (${JSON.stringify(queue)}) has been removed.`);
+                const handlerInstance = this.getMessageHandlerInstance(queue);
+                if (handlerInstance)
+                    this.shutdownMessageHandler(handlerInstance, cb);
+                else
+                    cb();
+            }
+        };
+        this.addMessageHandler = (queue, usePriorityQueuing, messageHandler, cb) => {
+            const handler = this.getMessageHandler(queue);
+            if (handler)
+                cb(new message_handler_already_exists_error_1.MessageHandlerAlreadyExistsError(queue));
+            else {
+                const handlerParams = {
+                    queue,
+                    usePriorityQueuing,
+                    messageHandler,
+                };
+                this.messageHandlers.push(handlerParams);
+                this.logger.info(`Message handler with parameters (${JSON.stringify(handlerParams)}) has been registered.`);
+                if (this.consumer.isRunning())
+                    this.runMessageHandler(handlerParams, (err) => {
+                        if (err)
+                            cb(err);
+                        else
+                            cb(null, true);
+                    });
+                else
+                    cb(null, false);
+            }
+        };
+        this.getQueues = () => {
+            return this.messageHandlers.map((i) => ({
+                queue: i.queue,
+                usingPriorityQueuing: i.usePriorityQueuing,
+            }));
+        };
+        this.consumer = consumer;
+        this.config = (0, configuration_1.getConfiguration)();
+        this.logger = (0, logger_1.getNamespacedLogger)(`${consumer.constructor.name}/${consumer.getId()}/MessageHandlerRunner`);
+    }
+    getMessageHandler(queue) {
+        return this.messageHandlers.find((i) => i.queue.name === queue.name && i.queue.ns === queue.ns);
+    }
+    getRedisClient() {
+        if (!this.redisClient) {
+            throw new panic_error_1.PanicError('Expected a non-empty value');
+        }
+        return this.redisClient;
+    }
+}
+exports.MessageHandlerRunner = MessageHandlerRunner;
+//# sourceMappingURL=message-handler-runner.js.map

package/dist/src/system/app/consumer/{consumer-message-handler.d.ts → consumer-message-handler/message-handler.d.ts}

@@ -1,12 +1,12 @@
 /// <reference types="node" />
-import { EMessageUnacknowledgedCause, ICallback, ICompatibleLogger, TConsumerMessageHandler, TQueueConsumerRedisKeys, TQueueParams, TQueueRateLimit } from '../../../../types';
-import { RedisClient } from '../../common/redis-client/redis-client';
-import { Message } from '../message/message';
+import { EMessageUnacknowledgedCause, ICallback, ICompatibleLogger, TConsumerMessageHandler, TQueueConsumerRedisKeys, TQueueParams, TQueueRateLimit, TRedisClientMulti } from '../../../../../types';
+import { RedisClient } from '../../../common/redis-client/redis-client';
+import { Message } from '../../message/message';
 import { EventEmitter } from 'events';
-import { PowerManager } from '../../common/power-manager/power-manager';
-import { ConsumerMessageRate } from './consumer-message-rate';
-import { Ticker } from '../../common/ticker/ticker';
-export declare class ConsumerMessageHandler extends EventEmitter {
+import { PowerManager } from '../../../common/power-manager/power-manager';
+import { ConsumerMessageRate } from '../consumer-message-rate';
+import { Ticker } from '../../../common/ticker/ticker';
+export declare class MessageHandler extends EventEmitter {
     protected id: string;
     protected consumerId: string;
     protected queue: TQueueParams;
@@ -33,10 +33,11 @@ export declare class ConsumerMessageHandler extends EventEmitter {
     protected dequeueMessage(cb: ICallback<string>): void;
     protected dequeue(cb: ICallback<string>): void;
     run: (cb: ICallback<void>) => void;
-    shutdown: (cb: ICallback<void>) => void;
+    shutdown: (redisClient: RedisClient, cb: ICallback<void>) => void;
     getQueue(): TQueueParams;
     isUsingPriorityQueuing(): boolean;
     getConsumerId(): string;
     getRedisKeys(): TQueueConsumerRedisKeys;
     getId(): string;
+    static cleanUp(redisClient: RedisClient, consumerId: string, queue: TQueueParams, pendingMulti: TRedisClientMulti | undefined, cb: ICallback<void>): void;
 }

package/dist/src/system/app/consumer/{consumer-message-handler.js → consumer-message-handler/message-handler.js}

@@ -1,22 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConsumerMessageHandler = void 0;
-const types_1 = require("../../../../types");
+exports.MessageHandler = void 0;
+const types_1 = require("../../../../../types");
 const uuid_1 = require("uuid");
-const message_1 = require("../message/message");
-const events_1 = require("../../common/events");
-const consumer_error_1 = require("./errors/consumer.error");
-const redis_keys_1 = require("../../common/redis-keys/redis-keys");
+const message_1 = require("../../message/message");
+const events_1 = require("../../../common/events");
+const consumer_error_1 = require("../errors/consumer.error");
+const redis_keys_1 = require("../../../common/redis-keys/redis-keys");
 const events_2 = require("events");
-const power_manager_1 = require("../../common/power-manager/power-manager");
-const empty_callback_reply_error_1 = require("../../common/errors/empty-callback-reply.error");
-const consumer_queues_1 = require("./consumer-queues");
-const broker_1 = require("../../common/broker/broker");
-const queue_manager_1 = require("../queue-manager/queue-manager");
-const ticker_1 = require("../../common/ticker/ticker");
-const logger_1 = require("../../common/logger");
-const async_1 = require("../../lib/async");
-class ConsumerMessageHandler extends events_2.EventEmitter {
+const power_manager_1 = require("../../../common/power-manager/power-manager");
+const empty_callback_reply_error_1 = require("../../../common/errors/empty-callback-reply.error");
+const consumer_queues_1 = require("../consumer-queues");
+const broker_1 = require("../../../common/broker/broker");
+const queue_manager_1 = require("../../queue-manager/queue-manager");
+const ticker_1 = require("../../../common/ticker/ticker");
+const logger_1 = require("../../../common/logger");
+const async_1 = require("../../../lib/async");
+const processing_queue_1 = require("./processing-queue");
+class MessageHandler extends events_2.EventEmitter {
     constructor(consumerId, queue, handler, usePriorityQueuing, redisClient, messageRate = null) {
         super();
         this.messageRate = null;
@@ -31,7 +32,7 @@ class ConsumerMessageHandler extends events_2.EventEmitter {
                     const multi = this.redisClient.multi();
                     queue_manager_1.queueManager.setUpMessageQueue(multi, this.queue);
                     consumer_queues_1.consumerQueues.addConsumer(multi, this.queue, this.consumerId);
-                    queue_manager_1.queueManager.setUpProcessingQueue(multi, this);
+                    processing_queue_1.processingQueue.setUpProcessingQueue(multi, this.queue, this.consumerId);
                     this.redisClient.execMulti(multi, (err) => {
                         if (err)
                             cb(err);
@@ -44,7 +45,7 @@ class ConsumerMessageHandler extends events_2.EventEmitter {
                 }
             });
         };
-        this.shutdown = (cb) => {
+        this.shutdown = (redisClient, cb) => {
             const goDown = () => {
                 this.powerManager.goingDown();
                 (0, async_1.waterfall)([
@@ -58,6 +59,9 @@ class ConsumerMessageHandler extends events_2.EventEmitter {
                         else
                             cb();
                     },
+                    (cb) => {
+                        MessageHandler.cleanUp(redisClient, this.consumerId, this.queue, undefined, cb);
+                    },
                     (cb) => {
                         this.redisClient.halt(cb);
                     },
@@ -97,7 +101,7 @@ class ConsumerMessageHandler extends events_2.EventEmitter {
                 this.emit(events_1.events.IDLE, this.queue);
             });
         }
-        this.ticker = new ticker_1.Ticker(() => void 0, 1000);
+        this.ticker = new ticker_1.Ticker();
     }
     registerEventsHandlers() {
         this.on(events_1.events.UP, () => {
@@ -263,6 +267,25 @@ class ConsumerMessageHandler extends events_2.EventEmitter {
     getId() {
         return this.id;
     }
+    static cleanUp(redisClient, consumerId, queue, pendingMulti, cb) {
+        const multi = pendingMulti !== null && pendingMulti !== void 0 ? pendingMulti : redisClient.multi();
+        (0, async_1.waterfall)([
+            (cb) => {
+                processing_queue_1.processingQueue.cleanUpProcessingQueue(redisClient, consumerId, queue, multi, cb);
+            },
+            (cb) => {
+                consumer_queues_1.consumerQueues.removeConsumer(multi, queue, consumerId);
+                cb();
+            },
+        ], (err) => {
+            if (err)
+                cb(err);
+            else if (pendingMulti)
+                cb();
+            else
+                redisClient.execMulti(multi, (err) => cb(err));
+        });
+    }
 }
-exports.ConsumerMessageHandler = ConsumerMessageHandler;
-//# sourceMappingURL=consumer-message-handler.js.map
+exports.MessageHandler = MessageHandler;
+//# sourceMappingURL=message-handler.js.map

package/dist/src/system/app/consumer/consumer-message-handler/processing-queue.d.ts

@@ -0,0 +1,6 @@
+import { RedisClient } from '../../../common/redis-client/redis-client';
+import { ICallback, TQueueParams, TRedisClientMulti } from '../../../../../types';
+export declare const processingQueue: {
+    cleanUpProcessingQueue(redisClient: RedisClient, consumerId: string, queue: TQueueParams, multi: TRedisClientMulti, cb: ICallback<void>): void;
+    setUpProcessingQueue(multi: TRedisClientMulti, queue: TQueueParams, consumerId: string): void;
+};

package/dist/src/system/app/consumer/consumer-message-handler/processing-queue.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processingQueue = void 0;
+const types_1 = require("../../../../../types");
+const message_1 = require("../../message/message");
+const async_1 = require("../../../lib/async");
+const broker_1 = require("../../../common/broker/broker");
+const time_series_1 = require("../../../common/time-series/time-series");
+const global_dead_lettered_time_series_1 = require("../consumer-time-series/global-dead-lettered-time-series");
+const queue_dead_lettered_time_series_1 = require("../consumer-time-series/queue-dead-lettered-time-series");
+const redis_keys_1 = require("../../../common/redis-keys/redis-keys");
+function fetchProcessingQueueMessage(redisClient, consumerId, keyQueueProcessing, cb) {
+    redisClient.lrange(keyQueueProcessing, 0, 0, (err, range) => {
+        if (err)
+            cb(err);
+        else if (range && range.length) {
+            const msg = message_1.Message.createFromMessage(range[0]);
+            cb(null, msg);
+        }
+        else
+            cb();
+    });
+}
+function deleteProcessingQueue(multi, queue, processingQueue) {
+    const { keyProcessingQueues, keyQueueProcessingQueues } = redis_keys_1.redisKeys.getQueueKeys(queue);
+    multi.srem(keyProcessingQueues, processingQueue);
+    multi.hdel(keyQueueProcessingQueues, processingQueue);
+    multi.del(processingQueue);
+}
+exports.processingQueue = {
+    cleanUpProcessingQueue(redisClient, consumerId, queue, multi, cb) {
+        const { keyQueueProcessing } = redis_keys_1.redisKeys.getQueueConsumerKeys(queue, consumerId);
+        (0, async_1.waterfall)([
+            (cb) => {
+                fetchProcessingQueueMessage(redisClient, consumerId, keyQueueProcessing, (err, msg) => {
+                    if (err)
+                        cb(err);
+                    else if (msg) {
+                        const deadLettered = broker_1.broker.retry(multi, keyQueueProcessing, msg, types_1.EMessageUnacknowledgedCause.RECOVERY);
+                        if (typeof deadLettered === 'string') {
+                            const timestamp = time_series_1.TimeSeries.getCurrentTimestamp();
+                            (0, global_dead_lettered_time_series_1.GlobalDeadLetteredTimeSeries)(redisClient).add(timestamp, 1, multi);
+                            (0, queue_dead_lettered_time_series_1.QueueDeadLetteredTimeSeries)(redisClient, queue).add(timestamp, 1, multi);
+                        }
+                        cb();
+                    }
+                    else
+                        cb();
+                });
+            },
+            (cb) => {
+                deleteProcessingQueue(multi, queue, keyQueueProcessing);
+                cb();
+            },
+        ], cb);
+    },
+    setUpProcessingQueue(multi, queue, consumerId) {
+        const { keyQueueProcessing, keyProcessingQueues, keyQueueProcessingQueues, } = redis_keys_1.redisKeys.getQueueConsumerKeys(queue, consumerId);
+        multi.hset(keyQueueProcessingQueues, keyQueueProcessing, consumerId);
+        multi.sadd(keyProcessingQueues, keyQueueProcessing);
+    },
+};
+//# sourceMappingURL=processing-queue.js.map

package/dist/src/system/app/consumer/consumer-queues.d.ts

@@ -1,9 +1,8 @@
 import { ICallback, THeartbeatRegistryPayload, TQueueParams, TRedisClientMulti } from '../../../../types';
 import { RedisClient } from '../../common/redis-client/redis-client';
 export declare const consumerQueues: {
-    addConsumer(multi: TRedisClientMulti, queue: TQueueParams, instanceId: string): void;
-    removeConsumer(multi: TRedisClientMulti, consumerId: string, queues: TQueueParams[]): void;
-    exists(client: RedisClient, keyRegistry: string, instanceId: string, cb: ICallback<boolean>): void;
+    removeConsumer(multi: TRedisClientMulti, queue: TQueueParams, consumerId: string): void;
+    addConsumer(multi: TRedisClientMulti, queue: TQueueParams, consumerId: string): void;
     getQueueConsumers(client: RedisClient, queue: TQueueParams, transform: boolean, cb: ICallback<Record<string, THeartbeatRegistryPayload | string>>): void;
     getQueueConsumerIds(client: RedisClient, queue: TQueueParams, cb: ICallback<string[]>): void;
     countQueueConsumers(client: RedisClient, queue: TQueueParams, cb: ICallback<number>): void;

package/dist/src/system/app/consumer/consumer-queues.js

@@ -19,26 +19,21 @@ const IPAddresses = (() => {
     return addresses;
 })();
 exports.consumerQueues = {
-    addConsumer(multi, queue, instanceId) {
+    removeConsumer(multi, queue, consumerId) {
+        const { keyQueueConsumers, keyConsumerQueues } = redis_keys_1.redisKeys.getQueueConsumerKeys(queue, consumerId);
+        multi.hdel(keyQueueConsumers, consumerId);
+        multi.srem(keyConsumerQueues, JSON.stringify(queue));
+    },
+    addConsumer(multi, queue, consumerId) {
         const data = {
             ipAddress: IPAddresses,
             hostname: os.hostname(),
             pid: process.pid,
             createdAt: Date.now(),
         };
-        const { keyQueueConsumers, keyConsumerQueues } = redis_keys_1.redisKeys.getQueueConsumerKeys(queue, instanceId);
+        const { keyQueueConsumers, keyConsumerQueues } = redis_keys_1.redisKeys.getQueueConsumerKeys(queue, consumerId);
         multi.sadd(keyConsumerQueues, JSON.stringify(queue));
-        multi.hset(keyQueueConsumers, instanceId, JSON.stringify(data));
-    },
-    removeConsumer(multi, consumerId, queues) {
-        (0, async_1.each)(queues, (queue, _, done) => {
-            const { keyQueueConsumers } = redis_keys_1.redisKeys.getQueueKeys(queue);
-            multi.hdel(keyQueueConsumers, consumerId);
-            done();
-        }, () => void 0);
-    },
-    exists(client, keyRegistry, instanceId, cb) {
-        client.hexists(keyRegistry, instanceId, cb);
+        multi.hset(keyQueueConsumers, consumerId, JSON.stringify(data));
     },
     getQueueConsumers(client, queue, transform, cb) {
         const { keyQueueConsumers } = redis_keys_1.redisKeys.getQueueKeys(queue);

package/dist/src/system/app/consumer/consumer.d.ts

@@ -1,43 +1,29 @@
-import { ICallback, TConsumerMessageHandler, TConsumerMessageHandlerParams, TConsumerRedisKeys, THeartbeatRegistryPayload, TQueueParams, TUnaryFunction, TRedisClientMulti } from '../../../../types';
-import { ConsumerMessageRate } from './consumer-message-rate';
+import { ICallback, TConsumerMessageHandler, TConsumerRedisKeys, THeartbeatRegistryPayload, TQueueParams, TUnaryFunction, TRedisClientMulti } from '../../../../types';
 import { RedisClient } from '../../common/redis-client/redis-client';
 import { Base } from '../../common/base';
-import { ConsumerMessageHandler } from './consumer-message-handler';
-import { Message } from '../message/message';
 export declare class Consumer extends Base {
+    private readonly redisKeys;
+    private readonly messageHandlerRunner;
     private heartbeat;
     private workerRunner;
-    private messageHandlerInstances;
-    private messageHandlers;
-    private readonly redisKeys;
     constructor();
-    protected registerMessageHandlerEvents: (messageHandler: ConsumerMessageHandler) => void;
     protected setUpHeartbeat: (cb: ICallback<void>) => void;
     protected tearDownHeartbeat: (cb: ICallback<void>) => void;
     protected setUpConsumerWorkers: (cb: ICallback<void>) => void;
     protected tearDownConsumerWorkers: (cb: ICallback<void>) => void;
-    protected runMessageHandler: (handlerParams: TConsumerMessageHandlerParams, cb: ICallback<void>) => void;
-    protected consumeMessages: (cb: ICallback<void>) => void;
-    protected tearDownMessageHandlerInstances: (cb: ICallback<void>) => void;
-    protected createMessageRateInstance: (queue: TQueueParams, redisClient: RedisClient) => ConsumerMessageRate;
+    protected runMessageHandlers: (cb: ICallback<void>) => void;
+    protected shutdownMessageHandlers: (cb: ICallback<void>) => void;
     protected goingUp(): TUnaryFunction<ICallback<void>>[];
     protected goingDown(): TUnaryFunction<ICallback<void>>[];
-    protected getMessageHandler(queue: TQueueParams, usePriorityQueuing: boolean): TConsumerMessageHandlerParams | undefined;
-    protected addMessageHandler(handlerParams: TConsumerMessageHandlerParams, usePriorityQueuing: boolean): boolean;
-    protected getMessageHandlerInstance: (queue: TQueueParams, usePriorityQueuing: boolean) => ConsumerMessageHandler | undefined;
-    protected removeMessageHandlerInstance: (queue: TQueueParams, usePriorityQueuing: boolean) => void;
-    protected removeMessageHandler: (queue: TQueueParams, usePriorityQueuing: boolean) => void;
-    consume(queue: string | TQueueParams, usePriorityQueuing: boolean, messageHandler: TConsumerMessageHandler, cb: ICallback<boolean>): void;
-    cancel(queue: string | TQueueParams, usePriorityQueuing: boolean, cb: ICallback<void>): void;
-    getRedisKeys(): TConsumerRedisKeys;
+    consume(queue: TQueueParams, usePriorityQueuing: boolean, messageHandler: TConsumerMessageHandler, cb: ICallback<boolean>): void;
+    cancel(queue: TQueueParams, cb: ICallback<void>): void;
     getQueues(): {
         queue: TQueueParams;
         usingPriorityQueuing: boolean;
     }[];
+    getRedisKeys(): TConsumerRedisKeys;
     static getOnlineConsumers(redisClient: RedisClient, queue: TQueueParams, transform: boolean | undefined, cb: ICallback<Record<string, THeartbeatRegistryPayload | string>>): void;
     static getOnlineConsumerIds(redisClient: RedisClient, queue: TQueueParams, cb: ICallback<string[]>): void;
     static countOnlineConsumers(redisClient: RedisClient, queue: TQueueParams, cb: ICallback<number>): void;
     static handleOfflineConsumer(multi: TRedisClientMulti, redisClient: RedisClient, consumerId: string, cb: ICallback<void>): void;
-    protected static fetchProcessingQueueMessage(redisClient: RedisClient, consumerId: string, keyQueueProcessing: string, cb: ICallback<Message>): void;
-    protected static handleConsumerProcessingQueue(multi: TRedisClientMulti, redisClient: RedisClient, consumerId: string, queue: TQueueParams, cb: ICallback<void>): void;
 }