redis-smq 6.2.4 → 6.3.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # CHANGELOG
 
+## 6.3.0 (2022-03-15)
+
+* Update docs (3ad938a)
+* Use colons instead of dots for joining Redis key segments (75dbcb6)
+* Continue testing consumer message multiplexing (17c9659)
+* Improve multiplexing delay when dequeuing messages (a635c8a)
+* Remove deprecated consumer.cancel(queue,priority,cb), add new tests (4a2d458)
+* Fix test errors, clean up (09feb9c)
+* Prefer method definition over arrow function property (5d7e664)
+* Implement MultiplexedMessageHandlerRunner (6980cbf)
+* Refactor MessageHandler to allow more modular structures (b079244)
+
+## 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)

package/README.md

@@ -22,6 +22,7 @@ RedisSMQ is a Node.js library for queuing messages (aka jobs) and processing the
 * **[Queue Rate Limiting](docs/queue-rate-limiting.md)**: Allowing you to control the rate at which the messages are consumed from a given queue.
 * **[Scheduling Messages](docs/scheduling-messages.md)**: Messages can be configured to be delayed, delivered for N times with an optional period between deliveries, and to be scheduled using CRON expressions.
 * **[Reliable Priority Queues](docs/priority-queues.md)**: Supports priority messaging.
+* **[Multiplexing](docs/multiplexing.md)**: It's great feature which allows message handlers to use a single redis connection to dequeue and consume messages.  
 * **[HTTP API](docs/http-api.md)**: an HTTP interface is provided to interact with the MQ.
 * **[Web UI](docs/web-ui.md)**: RedisSMQ can be managed also from your web browser.
 * **[Logging](docs/logs.md)**: Comes with a built-in JSON logger. But you can also use your own logger instance.
@@ -51,11 +52,12 @@ RedisSMQ is a Node.js library for queuing messages (aka jobs) and processing the
       1. [Scheduling Messages](docs/scheduling-messages.md)
       2. [Priority Queues](docs/priority-queues.md)
       3. [Queue Rate Limiting](docs/queue-rate-limiting.md)
-      4. [Message Manager](docs/api/message-manager.md)
-      5. [Queue Manager](docs/api/queue-manager.md)
-      6. [HTTP API](docs/http-api.md)
-      7. [Web UI](docs/web-ui.md)
-      8. [Logs](docs/logs.md)
+      4. [Multiplexing](docs/multiplexing.md)
+      5. [Message Manager](docs/api/message-manager.md)
+      6. [Queue Manager](docs/api/queue-manager.md)
+      7. [HTTP API](docs/http-api.md)
+      8. [Web UI](docs/web-ui.md)
+      9. [Logs](docs/logs.md)
 5. [RedisSMQ Architecture](docs/redis-smq-architecture.md)
 6. [Performance](#performance)
 7. [Contributing](#contributing)
@@ -223,6 +225,8 @@ See [Consumer Reference](docs/api/consumer.md) for more details.
 * [Priority Queues](docs/priority-queues.md)
 
 * [Queue Rate Limiting](docs/queue-rate-limiting.md)
+
+* [Multiplexing](docs/multiplexing.md)
   
 * [Message Manager](docs/api/message-manager.md)
 

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

@@ -3,10 +3,10 @@ import { ICallback, TConsumerMessageHandler, TQueueParams } from '../../../../ty
 import { EventEmitter } from 'events';
 export declare class ConsumerFrontend extends EventEmitter {
     private consumer;
-    constructor();
+    constructor(useMultiplexing?: boolean);
     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;
     run(cb?: ICallback<boolean>): void;
     shutdown(cb?: ICallback<boolean>): void;
     isGoingUp(): boolean;

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

@@ -4,10 +4,11 @@ exports.ConsumerFrontend = void 0;
 const events_1 = require("events");
 const consumer_1 = require("./consumer");
 const events_2 = require("../../common/events");
+const queue_manager_1 = require("../queue-manager/queue-manager");
 class ConsumerFrontend extends events_1.EventEmitter {
-    constructor() {
+    constructor(useMultiplexing = false) {
         super();
-        this.consumer = new consumer_1.Consumer();
+        this.consumer = new consumer_1.Consumer(useMultiplexing);
         this.registerEvents();
     }
     registerEvents() {
@@ -21,10 +22,12 @@ 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, cb) {
+        const queueParams = queue_manager_1.queueManager.getQueueParams(queue);
+        this.consumer.cancel(queueParams, cb);
     }
     run(cb) {
         this.consumer.run(cb);

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

@@ -40,9 +40,7 @@ class ConsumerHeartbeat extends events_2.EventEmitter {
         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() {

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

@@ -0,0 +1,13 @@
+import { Message } from '../../message/message';
+import { EMessageUnacknowledgedCause } from '../../../../../types';
+import { RedisClient } from '../../../common/redis-client/redis-client';
+import { MessageHandler } from './message-handler';
+export declare class ConsumeMessage {
+    protected keyQueueProcessing: string;
+    protected messageHandler: MessageHandler;
+    protected redisClient: RedisClient;
+    constructor(messageHandler: MessageHandler, redisClient: RedisClient);
+    protected unacknowledgeMessage(msg: Message, cause: EMessageUnacknowledgedCause, err?: Error): void;
+    protected consumeMessage(msg: Message): void;
+    handleReceivedMessage(message: Message): void;
+}

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsumeMessage = void 0;
+const message_1 = require("../../message/message");
+const types_1 = require("../../../../../types");
+const broker_1 = require("../../../common/broker/broker");
+const events_1 = require("../../../common/events");
+const consumer_error_1 = require("../errors/consumer.error");
+const redis_keys_1 = require("../../../common/redis-keys/redis-keys");
+class ConsumeMessage {
+    constructor(messageHandler, redisClient) {
+        this.redisClient = redisClient;
+        this.messageHandler = messageHandler;
+        const { keyQueueProcessing } = redis_keys_1.redisKeys.getQueueConsumerKeys(messageHandler.getQueue(), messageHandler.getConsumerId());
+        this.keyQueueProcessing = keyQueueProcessing;
+    }
+    unacknowledgeMessage(msg, cause, err) {
+        if (err) {
+        }
+        broker_1.broker.retry(this.redisClient, this.keyQueueProcessing, msg, cause, (err, deadLetterCause) => {
+            if (err)
+                this.messageHandler.handleError(err);
+            else {
+                this.messageHandler.emit(events_1.events.MESSAGE_UNACKNOWLEDGED, msg, cause);
+                if (deadLetterCause !== undefined) {
+                    this.messageHandler.emit(events_1.events.MESSAGE_DEAD_LETTERED, msg, deadLetterCause);
+                }
+            }
+        });
+    }
+    consumeMessage(msg) {
+        let isTimeout = false;
+        let timer = null;
+        try {
+            const consumeTimeout = msg.getConsumeTimeout();
+            if (consumeTimeout) {
+                timer = setTimeout(() => {
+                    isTimeout = true;
+                    timer = null;
+                    this.unacknowledgeMessage(msg, types_1.EMessageUnacknowledgedCause.TIMEOUT);
+                }, consumeTimeout);
+            }
+            const onConsumed = (err) => {
+                if (this.messageHandler.isRunning() && !isTimeout) {
+                    if (timer)
+                        clearTimeout(timer);
+                    if (err)
+                        this.unacknowledgeMessage(msg, types_1.EMessageUnacknowledgedCause.UNACKNOWLEDGED, err);
+                    else {
+                        broker_1.broker.acknowledgeMessage(this.redisClient, msg, this.keyQueueProcessing, (err) => {
+                            if (err)
+                                this.messageHandler.handleError(err);
+                            else
+                                this.messageHandler.emit(events_1.events.MESSAGE_ACKNOWLEDGED, msg);
+                        });
+                    }
+                }
+            };
+            this.messageHandler.getHandler()(message_1.Message.createFromMessage(msg), onConsumed);
+        }
+        catch (error) {
+            const err = error instanceof Error
+                ? error
+                : new consumer_error_1.ConsumerError(`An error occurred while processing message ID (${msg.getRequiredId()})`);
+            this.unacknowledgeMessage(msg, types_1.EMessageUnacknowledgedCause.CAUGHT_ERROR, err);
+        }
+    }
+    handleReceivedMessage(message) {
+        if (message.getSetExpired()) {
+            this.unacknowledgeMessage(message, types_1.EMessageUnacknowledgedCause.TTL_EXPIRED);
+        }
+        else
+            this.consumeMessage(message);
+    }
+}
+exports.ConsumeMessage = ConsumeMessage;
+//# sourceMappingURL=consume-message.js.map

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

@@ -0,0 +1,24 @@
+import { ICallback, TQueueParams, TQueueRateLimit } from '../../../../../types';
+import { RedisClient } from '../../../common/redis-client/redis-client';
+import { Ticker } from '../../../common/ticker/ticker';
+import { MessageHandler } from './message-handler';
+export declare class DequeueMessage {
+    protected redisClient: RedisClient;
+    protected queue: TQueueParams;
+    protected consumerId: string;
+    protected keyQueuePending: string;
+    protected keyQueuePriority: string;
+    protected keyPendingMessagesWithPriority: string;
+    protected keyQueueProcessing: string;
+    protected usingPriorityQueuing: boolean;
+    protected queueRateLimit: TQueueRateLimit | null;
+    protected ticker: Ticker;
+    protected messageHandler: MessageHandler;
+    constructor(messageHandler: MessageHandler, redisClient: RedisClient);
+    protected dequeueMessageWithPriority(cb: ICallback<string>): void;
+    protected waitForMessage(cb: ICallback<string>): void;
+    protected dequeueMessage(cb: ICallback<string>): void;
+    dequeue(): void;
+    run(cb: ICallback<void>): void;
+    quit(cb: ICallback<void>): void;
+}

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DequeueMessage = void 0;
+const queue_manager_1 = require("../../queue-manager/queue-manager");
+const redis_keys_1 = require("../../../common/redis-keys/redis-keys");
+const ticker_1 = require("../../../common/ticker/ticker");
+const events_1 = require("../../../common/events");
+const consumer_queues_1 = require("../consumer-queues");
+const processing_queue_1 = require("./processing-queue");
+const message_1 = require("../../message/message");
+class DequeueMessage {
+    constructor(messageHandler, redisClient) {
+        this.queueRateLimit = null;
+        this.messageHandler = messageHandler;
+        this.redisClient = redisClient;
+        this.queue = messageHandler.getQueue();
+        this.consumerId = messageHandler.getConsumerId();
+        const { keyQueuePendingPriorityMessageIds, keyQueuePending, keyQueuePendingPriorityMessages, keyQueueProcessing, } = redis_keys_1.redisKeys.getQueueConsumerKeys(this.queue, this.consumerId);
+        this.keyQueuePending = keyQueuePending;
+        this.keyPendingMessagesWithPriority = keyQueuePendingPriorityMessages;
+        this.keyQueuePriority = keyQueuePendingPriorityMessageIds;
+        this.keyQueueProcessing = keyQueueProcessing;
+        this.usingPriorityQueuing = messageHandler.isUsingPriorityQueuing();
+        this.ticker = new ticker_1.Ticker(() => this.dequeue());
+    }
+    dequeueMessageWithPriority(cb) {
+        this.redisClient.zpophgetrpush(this.keyQueuePriority, this.keyPendingMessagesWithPriority, this.keyQueueProcessing, cb);
+    }
+    waitForMessage(cb) {
+        this.redisClient.brpoplpush(this.keyQueuePending, this.keyQueueProcessing, 0, cb);
+    }
+    dequeueMessage(cb) {
+        this.redisClient.rpoplpush(this.keyQueuePending, this.keyQueueProcessing, cb);
+    }
+    dequeue() {
+        const cb = (err, reply) => {
+            if (err) {
+                this.ticker.abort();
+                this.messageHandler.handleError(err);
+            }
+            else if (typeof reply === 'string') {
+                const message = message_1.Message.createFromMessage(reply);
+                this.messageHandler.emit(events_1.events.MESSAGE_RECEIVED, message);
+            }
+            else {
+                this.ticker.nextTick();
+            }
+        };
+        const deq = () => {
+            if (this.usingPriorityQueuing)
+                this.dequeueMessageWithPriority(cb);
+            else
+                this.dequeueMessage(cb);
+        };
+        if (this.usingPriorityQueuing || this.queueRateLimit) {
+            if (this.queueRateLimit) {
+                queue_manager_1.queueManager.hasQueueRateLimitExceeded(this.redisClient, this.queue, this.queueRateLimit, (err, isExceeded) => {
+                    if (err)
+                        this.messageHandler.handleError(err);
+                    else if (isExceeded)
+                        this.ticker.nextTick();
+                    else
+                        deq();
+                });
+            }
+            else
+                deq();
+        }
+        else {
+            this.waitForMessage(cb);
+        }
+    }
+    run(cb) {
+        queue_manager_1.queueManager.getQueueRateLimit(this.redisClient, this.queue, (err, rateLimit) => {
+            if (err)
+                cb(err);
+            else {
+                this.queueRateLimit = rateLimit !== null && rateLimit !== void 0 ? rateLimit : null;
+                const multi = this.redisClient.multi();
+                queue_manager_1.queueManager.setUpMessageQueue(multi, this.queue);
+                consumer_queues_1.consumerQueues.addConsumer(multi, this.queue, this.consumerId);
+                processing_queue_1.processingQueue.setUpProcessingQueue(multi, this.queue, this.consumerId);
+                this.redisClient.execMulti(multi, (err) => cb(err));
+            }
+        });
+    }
+    quit(cb) {
+        this.ticker.once(events_1.events.DOWN, cb);
+        this.ticker.quit();
+    }
+}
+exports.DequeueMessage = DequeueMessage;
+//# sourceMappingURL=dequeue-message.js.map

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

@@ -0,0 +1,30 @@
+import { Consumer } from '../consumer';
+import { MessageHandler } from './message-handler';
+import { ICallback, ICompatibleLogger, IRequiredConfig, TConsumerMessageHandler, TConsumerMessageHandlerParams, TQueueParams } from '../../../../../types';
+import { RedisClient } from '../../../common/redis-client/redis-client';
+import { ConsumerMessageRate } from '../consumer-message-rate';
+export declare class MessageHandlerRunner {
+    protected consumer: Consumer;
+    protected sharedRedisClient: RedisClient | null;
+    protected messageHandlerInstances: MessageHandler[];
+    protected messageHandlers: TConsumerMessageHandlerParams[];
+    protected config: IRequiredConfig;
+    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 createMessageHandlerInstance(redisClient: RedisClient, handlerParams: TConsumerMessageHandlerParams): MessageHandler;
+    protected runMessageHandler(handlerParams: TConsumerMessageHandlerParams, cb: ICallback<void>): void;
+    protected shutdownMessageHandler(messageHandler: MessageHandler, cb: ICallback<void>): void;
+    protected getSharedRedisClient(): 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,152 @@
+"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.sharedRedisClient = null;
+        this.messageHandlerInstances = [];
+        this.messageHandlers = [];
+        this.consumer = consumer;
+        this.config = (0, configuration_1.getConfiguration)();
+        this.logger = (0, logger_1.getNamespacedLogger)(`${consumer.constructor.name}/${consumer.getId()}/MessageHandlerRunner`);
+    }
+    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));
+        messageHandler.on(events_1.events.MESSAGE_RECEIVED, (...args) => this.consumer.emit(events_1.events.MESSAGE_RECEIVED, ...args));
+    }
+    getMessageHandlerInstance(queue) {
+        return this.messageHandlerInstances.find((i) => {
+            const q = i.getQueue();
+            return q.name === queue.name && q.ns === queue.ns;
+        });
+    }
+    getMessageHandler(queue) {
+        return this.messageHandlers.find((i) => i.queue.name === queue.name && i.queue.ns === queue.ns);
+    }
+    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);
+    }
+    createMessageHandlerInstance(redisClient, handlerParams) {
+        const sharedRedisClient = this.getSharedRedisClient();
+        const { queue, usePriorityQueuing, messageHandler } = handlerParams;
+        const messageRate = this.config.monitor.enabled
+            ? this.createMessageRateInstance(queue, sharedRedisClient)
+            : null;
+        const instance = new message_handler_1.MessageHandler(this.consumer.getId(), queue, messageHandler, usePriorityQueuing, redisClient, messageRate);
+        this.registerMessageHandlerEvents(instance);
+        this.messageHandlerInstances.push(instance);
+        this.logger.info(`Created a new instance (ID: ${instance.getId()}) for MessageHandler (${JSON.stringify(handlerParams)}).`);
+        return instance;
+    }
+    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 handler = this.createMessageHandlerInstance(client, handlerParams);
+                handler.run(cb);
+            }
+        });
+    }
+    shutdownMessageHandler(messageHandler, cb) {
+        const queue = messageHandler.getQueue();
+        const redisClient = this.getSharedRedisClient();
+        messageHandler.shutdown(redisClient, () => {
+            this.messageHandlerInstances = this.messageHandlerInstances.filter((handler) => {
+                const q = handler.getQueue();
+                return !(q.name === queue.name && q.ns === queue.ns);
+            });
+            cb();
+        });
+    }
+    getSharedRedisClient() {
+        if (!this.sharedRedisClient) {
+            throw new panic_error_1.PanicError('Expected a non-empty value');
+        }
+        return this.sharedRedisClient;
+    }
+    run(redisClient, cb) {
+        this.sharedRedisClient = redisClient;
+        (0, async_1.each)(this.messageHandlers, (handlerParams, _, done) => {
+            this.runMessageHandler(handlerParams, done);
+        }, cb);
+    }
+    shutdown(cb) {
+        (0, async_1.each)(this.messageHandlerInstances, (handler, queue, done) => {
+            this.shutdownMessageHandler(handler, done);
+        }, (err) => {
+            if (err)
+                cb(err);
+            else {
+                this.sharedRedisClient = null;
+                cb();
+            }
+        });
+    }
+    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();
+        }
+    }
+    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);
+        }
+    }
+    getQueues() {
+        return this.messageHandlers.map((i) => ({
+            queue: i.queue,
+            usingPriorityQueuing: i.usePriorityQueuing,
+        }));
+    }
+}
+exports.MessageHandlerRunner = MessageHandlerRunner;
+//# sourceMappingURL=message-handler-runner.js.map

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

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+import { ICallback, ICompatibleLogger, TConsumerMessageHandler, TQueueParams, TRedisClientMulti } from '../../../../../types';
+import { RedisClient } from '../../../common/redis-client/redis-client';
+import { EventEmitter } from 'events';
+import { PowerManager } from '../../../common/power-manager/power-manager';
+import { ConsumerMessageRate } from '../consumer-message-rate';
+import { DequeueMessage } from './dequeue-message';
+import { ConsumeMessage } from './consume-message';
+export declare class MessageHandler extends EventEmitter {
+    protected id: string;
+    protected consumerId: string;
+    protected queue: TQueueParams;
+    protected redisClient: RedisClient;
+    protected powerManager: PowerManager;
+    protected messageRate: ConsumerMessageRate | null;
+    protected usingPriorityQueuing: boolean;
+    protected logger: ICompatibleLogger;
+    protected dequeueMessage: DequeueMessage;
+    protected consumeMessage: ConsumeMessage;
+    protected handler: TConsumerMessageHandler;
+    constructor(consumerId: string, queue: TQueueParams, handler: TConsumerMessageHandler, usePriorityQueuing: boolean, redisClient: RedisClient, messageRate?: ConsumerMessageRate | null);
+    protected registerEventsHandlers(): void;
+    handleError(err: Error): void;
+    dequeue(): void;
+    run(cb: ICallback<void>): void;
+    shutdown(redisClient: RedisClient, cb: ICallback<void>): void;
+    getQueue(): TQueueParams;
+    isUsingPriorityQueuing(): boolean;
+    getConsumerId(): string;
+    getId(): string;
+    isRunning(): boolean;
+    getHandler(): TConsumerMessageHandler;
+    static cleanUp(redisClient: RedisClient, consumerId: string, queue: TQueueParams, pendingMulti: TRedisClientMulti | undefined, cb: ICallback<void>): void;
+}