redis-smq 7.0.0-rc.6 → 7.0.0

package/.codecov.yml

@@ -0,0 +1,5 @@
+coverage:
+  status:
+    patch:
+      default:
+        target: 80%

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # CHANGELOG
 
+## 7.0.0 (2022-06-18)
+
+* Fix typing issue (cd8bf6a)
+* Bump up redis-smq-common to v1.0.0 (02c353d)
+* Update callback vs promise vs async/await benchmarks (6fca49c)
+* Update README.md (7fbdcbf)
+
+## 7.0.0-rc.8 (2022-06-09)
+
+* Update docs (96a45e7)
+* Test consumers/producers event listeners (856e12d)
+* Implement consumers/producers event listeners (6f5d603)
+
+## 7.0.0-rc.7 (2022-06-07)
+
+* Update redis keys prefix (a6ca852)
+* Use codecov instead of coveralls (d8b5f83)
+* Improve consuming-messages/test00013 (5cd823c)
+* Improve consuming-messages/test00010 (a9a4f47)
+* Test WatchdogWorker (73fbe9a)
+* Clean up (aa9a51a)
+* Improve unacknowleged messages handling, refactor (005c6a0)
+* Fix outdated javascript examples (e31f89c)
+* Keep a clean directory structure (642739f)
+* Update README.md (5c011e3)
+* Clean up tests (10ebb77)
+
 ## 7.0.0-rc.6 (2022-05-31)
 
 * Bump up redis-smq-common to v1.0.0-rc.11 (43717f0)

package/README.md

@@ -7,7 +7,7 @@
 
 <p>
    <a href="https://github.com/weyoss/redis-smq/actions/workflows/tests.yml"><img src="https://github.com/weyoss/redis-smq/actions/workflows/tests.yml/badge.svg" alt="Tests" style="max-width:100%;" /></a>
-   <a href="https://coveralls.io/r/weyoss/redis-smq?branch=master" rel="nofollow"><img src="https://img.shields.io/coveralls/github/weyoss/redis-smq.svg" alt="Coverage Status" /></a>
+   <a href="https://codecov.io/github/weyoss/redis-smq?branch=master" rel="nofollow"><img src="https://img.shields.io/codecov/c/github/weyoss/redis-smq" alt="Coverage Status" /></a>
    <a href="https://npmjs.org/package/redis-smq" rel="nofollow"><img src="https://img.shields.io/npm/v/redis-smq.svg" alt="NPM version" /></a>
    <a href="https://npmjs.org/package/redis-smq" rel="nofollow"><img src="https://img.shields.io/npm/dm/redis-smq.svg" alt="NPM downloads" /></a>
    <a href="https://lgtm.com/projects/g/weyoss/redis-smq/context:javascript" rel="nofollow"><img src="https://img.shields.io/lgtm/grade/javascript/github/weyoss/redis-smq.svg?logo=lgtm&logoWidth=18" alt="Code quality" /></a>
@@ -19,9 +19,9 @@ RedisSMQ is a Node.js library for queuing messages (aka jobs) and processing the
 
 ## Features
 
-* **[High-performance message processing](/docs/performance.md)**
-* **[Multi-Queue Producers](#producer-class) & [Multi-Queue Consumers](#consumer-class)**: Offering very flexible models which make RedisSMQ an ideal message broker for your microservices. 
-* **[Supporting both at-least-once/at-most-once delivery](/docs/api/message.md#messageprototypesetretrythreshold)**: In case of failures, while delivering or processing a message, RedisSMQ can guaranty that the message will be not lost and redelivered again. When configured to do so, RedisSMQ can also ensure that the message is delivered at-most-once.
+* **[High-performance message processing](/docs/performance.md)**.
+* **[Multi-Queue Producers](#producer-class) & [Multi-Queue Consumers](#consumer-class)**: Offering flexible Producer/Consumer models, with focus on simplicity and without tons of features. This can make RedisSMQ an ideal message broker for your microservices. 
+* **[Supports both at-least-once/at-most-once delivery](/docs/api/message.md#messageprototypesetretrythreshold)**: In case of failures, while delivering or processing a message, RedisSMQ can guaranty that the message will be not lost and redelivered again. When configured to do so, RedisSMQ can also ensure that the message is delivered at-most-once.
 * **[Message Expiration](/docs/api/message.md#messageprototypesetttl)**: A message will not be delivered if it has been in a queue for longer than a given amount of time, called TTL (time-to-live).
 * **[Message Consumption Timeout](/docs/api/message.md#messageprototypesetconsumetimeout)**: Timeout for consuming messages.
 * **[Queue Rate Limiting](/docs/queue-rate-limiting.md)**: Allowing you to control the rate at which the messages are consumed from a given queue.
@@ -30,11 +30,10 @@ RedisSMQ is a Node.js library for queuing messages (aka jobs) and processing the
 * **[Multiplexing](/docs/multiplexing.md)**: A feature which allows message handlers to use a single redis connection to dequeue and consume messages.  
 * **[HTTP API](https://github.com/weyoss/redis-smq-monitor)**: an HTTP interface is provided to interact with the MQ.
 * **[Web UI](https://github.com/weyoss/redis-smq-monitor-client)**: RedisSMQ can be managed also from your web browser.
-* **[Logging](https://github.com/weyoss/redis-smq-common/blob/master/docs/logs.md)**: Comes with a built-in JSON logger. But you can also use your own logger instance.
+* **[Logging](https://github.com/weyoss/redis-smq-common/blob/master/docs/logs.md)**: RedisSMQ comes with a built-in JSON logger, but can also use your application logger.
 * **[Configurable](/docs/configuration.md)**: Many options and features can be configured.
-* **Both redis & ioredis clients are supported**: RedisSMQ can be configured to use either `redis` or `ioredis` to connect to Redis server.
-* **Rigorously tested**: With 100+ tests and code coverage no less than 80%.
-* **Highly optimized**: Strongly-typed and implemented using pure callbacks, with small memory footprint and no memory leaks. See [callbacks vs promises vs async/await benchmarks](http://bluebirdjs.com/docs/benchmarks.html).
+* **[Supports Multiple Redis clients](/docs/configuration.md)**: Depending on your preferences, RedisSMQ can use either [node-redis v3](https://github.com/redis/node-redis/tree/v3.1.2), [node-redis v4](https://github.com/redis/node-redis), or [ioredis](https://github.com/luin/ioredis).
+* **[Highly optimized](https://lgtm.com/projects/g/weyoss/redis-smq/context:javascript)**: Strongly-typed and implemented using pure callbacks, with small memory footprint and no memory leaks. See [Callback vs Promise vs Async/Await benchmarks](https://gist.github.com/weyoss/24f9ecbda175d943a48cb7ec38bde821).
 
 
 ### RedisSMQ Use Case: Multi-Queue Producers & Multi-Queue Consumers
@@ -53,6 +52,7 @@ RedisSMQ is a Node.js library for queuing messages (aka jobs) and processing the
        1. [Message Class](#message-class)
        2. [Producer Class](#producer-class)
        3. [Consumer Class](#consumer-class)
+          1. [Message Acknowledgement](#message-acknowledgement)
    2. Advanced Topics
       1. [Scheduling Messages](/docs/scheduling-messages.md)
       2. [Priority Queues](/docs/priority-queues.md)
@@ -133,7 +133,7 @@ See [Message Reference](/docs/api/message.md) for more details.
 
 #### Producer Class
 
-`Producer` class allows you to publish a message to a queue. 
+A `Producer` instance allows you to publish a message to a queue. 
 
 You can use a single `Producer` instance to produce messages, including messages with priority, to multiple queues.
 
@@ -166,19 +166,17 @@ See [Producer Reference](/docs/api/producer.md) for more details.
 
 #### Consumer Class
 
-`Consumer` class can be used to receive and consume messages from a queue.
+A `Consumer` instance can be used to receive and consume messages from one or multiple queues.
 
-Similarly to a `Producer` instance, a `Consumer` instance can consume messages from multiple queues.
+To consume messages from a queue, the `Consumer` class provides the [consume()](/docs/api/consumer.md#consumerprototypeconsume) method which allows you to register a `message handler`. 
 
-For consuming messages from a queue, the `Consumer` class provides the [consume()](/docs/api/consumer.md#consumerprototypeconsume) method which allows you to register a `message handler`. 
+A `message handler` is a function that receives a delivered message from a given queue. 
 
-A `message handler` is a function which get called once a message is received. 
+Message handlers can be registered at any time, before or after a consumer has been started. 
 
-Message handlers can be registered at any time, before or after you have started your consumer. 
+In contrast to producers, consumers are not automatically started upon creation. To start a consumer use the [run()](/docs/api/consumer.md#consumerprototyperun) method.
 
-A consumer can be started using the [run()](/docs/api/consumer.md#consumerprototyperun) method.
-
-To shut down and remove a given `message handler` from your consumer, use the [cancel()](/docs/api/consumer.md#consumerprototypecancel) method. 
+To stop consuming messages from a queue and to remove the associated `message handler` from your consumer, use the [cancel()](/docs/api/consumer.md#consumerprototypecancel) method. 
 
 To shut down completely your consumer and tear down all message handlers, use the [shutdown()](/docs/api/consumer.md#consumerprototypeshutdown) method.
 
@@ -202,17 +200,21 @@ consumer.consume('test_queue', messageHandler, (err) => {
 consumer.run();
 ```
 
+##### Message Acknowledgement
+
 Once a message is received, to acknowledge it, you invoke the callback function without arguments, as shown in the example above. 
 
-Message acknowledgment informs the MQ that a message has been successfully consumed.
+Message acknowledgment informs the MQ that the delivered message has been successfully consumed.
+
+If an error occurred while processing a message, you can unacknowledge it by passing in the error to the callback function.
 
-If an error occurred while processing a message, you can unacknowledge the message by passing the error to the callback function.
+By default, unacknowledged messages are re-queued and delivered again unless **message retry threshold** is exceeded. 
 
-By default, unacknowledged messages are re-queued and delivered again unless **message retry threshold** is exceeded. Then the messages are moved to a **dead-letter queue (DLQ)**. 
+Delivered messages that couldn't be processed or can not be delivered to consumers are moved to a system generated queue called **dead-letter queue (DLQ)**.
 
-A `dead-letter queue` is a system generated queue that holds all messages that couldn't be processed or can not be delivered to consumers.
+By default, RedisSMQ does not store acknowledged and dead-lettered messages for saving disk and memory spaces, and also to increase message processing performance. 
 
-By default, RedisSMQ does not store acknowledged and dead-lettered messages for saving disk and memory space, and also to increase message processing performance. If you need such feature, you can enable it from your [configuration](/docs/configuration.md) object.
+If you need such feature, you can enable it from your [configuration](/docs/configuration.md) object.
 
 See [Consumer Reference](/docs/api/consumer.md) for more details.
 

package/dist/index.d.ts

@@ -4,4 +4,3 @@ export { Producer } from './src/lib/producer/producer';
 export { Message } from './src/lib/message/message';
 export { MessageManager } from './src/lib/message-manager/message-manager';
 export { QueueManager } from './src/lib/queue-manager/queue-manager';
-export { registerProducerPlugin, registerConsumerPlugin, } from './src/plugins/plugins';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerConsumerPlugin = exports.registerProducerPlugin = exports.QueueManager = exports.MessageManager = exports.Message = exports.Producer = exports.Consumer = exports.events = void 0;
+exports.QueueManager = exports.MessageManager = exports.Message = exports.Producer = exports.Consumer = exports.events = void 0;
 var events_1 = require("./src/common/events/events");
 Object.defineProperty(exports, "events", { enumerable: true, get: function () { return events_1.events; } });
 var consumer_1 = require("./src/lib/consumer/consumer");
@@ -13,7 +13,4 @@ var message_manager_1 = require("./src/lib/message-manager/message-manager");
 Object.defineProperty(exports, "MessageManager", { enumerable: true, get: function () { return message_manager_1.MessageManager; } });
 var queue_manager_1 = require("./src/lib/queue-manager/queue-manager");
 Object.defineProperty(exports, "QueueManager", { enumerable: true, get: function () { return queue_manager_1.QueueManager; } });
-var plugins_1 = require("./src/plugins/plugins");
-Object.defineProperty(exports, "registerProducerPlugin", { enumerable: true, get: function () { return plugins_1.registerProducerPlugin; } });
-Object.defineProperty(exports, "registerConsumerPlugin", { enumerable: true, get: function () { return plugins_1.registerConsumerPlugin; } });
 //# sourceMappingURL=index.js.map

package/dist/src/common/event-listeners/event-provider.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { IEventProvider } from '../../../types';
+import { EventEmitter } from 'events';
+export declare class EventProvider implements IEventProvider {
+    protected eventEmitter: EventEmitter;
+    constructor(eventEmitter: EventEmitter);
+    on(event: string, listener: (...args: any[]) => void): void;
+}

package/dist/src/common/event-listeners/event-provider.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventProvider = void 0;
+class EventProvider {
+    constructor(eventEmitter) {
+        this.eventEmitter = eventEmitter;
+    }
+    on(event, listener) {
+        this.eventEmitter.on(event, listener);
+    }
+}
+exports.EventProvider = EventProvider;
+//# sourceMappingURL=event-provider.js.map

package/dist/src/common/redis-keys/redis-keys.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.redisKeys = void 0;
 const redis_keys_error_1 = require("./redis-keys.error");
 const keySegmentSeparator = ':';
-const nsPrefix = 'redis-smq-v700-rc0';
+const nsPrefix = 'redis-smq-v7';
 const globalNamespace = 'global';
 var ERedisKey;
 (function (ERedisKey) {

package/dist/src/config/configuration.js

@@ -5,12 +5,14 @@ const namespace_1 = require("./namespace");
 const redis_1 = require("./redis");
 const logger_1 = require("./logger");
 const messages_1 = require("./messages/messages");
+const event_listeners_1 = require("./event-listeners/event-listeners");
 function getConfiguration(config = {}) {
     return {
         namespace: (0, namespace_1.default)(config),
         redis: (0, redis_1.default)(config),
         logger: (0, logger_1.default)(config),
         messages: (0, messages_1.default)(config),
+        eventListeners: (0, event_listeners_1.EventListeners)(config),
     };
 }
 exports.getConfiguration = getConfiguration;

package/dist/src/config/event-listeners/event-listeners.d.ts

@@ -0,0 +1,2 @@
+import { IConfig, TRequiredEventListenersConfig } from '../../../types';
+export declare function EventListeners(userConfig: IConfig): TRequiredEventListenersConfig;

package/dist/src/config/event-listeners/event-listeners.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventListeners = void 0;
+const lodash_1 = require("lodash");
+const defaultConfig = {
+    consumerEventListeners: [],
+    producerEventListeners: [],
+};
+function EventListeners(userConfig) {
+    const { eventListeners = {} } = userConfig;
+    return (0, lodash_1.merge)({}, defaultConfig, eventListeners);
+}
+exports.EventListeners = EventListeners;
+//# sourceMappingURL=event-listeners.js.map

package/dist/src/lib/base.js

@@ -6,7 +6,6 @@ const events_1 = require("events");
 const events_2 = require("../common/events/events");
 const configuration_1 = require("../config/configuration");
 const redis_smq_common_1 = require("redis-smq-common");
-const plugins_1 = require("../plugins/plugins");
 class Base extends events_1.EventEmitter {
     constructor(config) {
         super();
@@ -38,7 +37,6 @@ class Base extends events_1.EventEmitter {
         this.config = (0, configuration_1.getConfiguration)(config);
         this.logger = redis_smq_common_1.logger.getNamespacedLogger(this.config.logger, `${this.constructor.name.toLowerCase()}:${this.id}`);
         this.registerEventsHandlers();
-        (0, plugins_1.disablePluginRegistration)();
     }
     registerEventsHandlers() {
         this.on(events_2.events.GOING_UP, () => this.logger.info(`Going up...`));

package/dist/src/lib/consumer/consumer-heartbeat.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="node" />
-import { IRequiredConfig, TConsumerHeartbeat } from '../../../types';
+import { TConsumerHeartbeat } from '../../../types';
 import { RedisClient, Ticker } from 'redis-smq-common';
 import { EventEmitter } from 'events';
 import { Consumer } from './consumer';
-import { ICallback } from 'redis-smq-common/dist/types';
+import { ICallback, IRedisClientMulti } from 'redis-smq-common/dist/types';
 export declare class ConsumerHeartbeat extends EventEmitter {
     protected static readonly heartbeatTTL: number;
     protected redisClient: RedisClient;
@@ -22,5 +22,5 @@ export declare class ConsumerHeartbeat extends EventEmitter {
     }[]>): void;
     static getValidHeartbeatIds(redisClient: RedisClient, cb: ICallback<string[]>): void;
     static getExpiredHeartbeatIds(redisClient: RedisClient, cb: ICallback<string[]>): void;
-    static handleExpiredHeartbeatIds(config: IRequiredConfig, redisClient: RedisClient, consumerIds: string[], cb: ICallback<void>): void;
+    static handleExpiredHeartbeatId(consumerId: string | string[], multi: IRedisClientMulti): void;
 }

package/dist/src/lib/consumer/consumer-heartbeat.js

@@ -7,7 +7,6 @@ const events_1 = require("../../common/events/events");
 const redis_keys_1 = require("../../common/redis-keys/redis-keys");
 const events_2 = require("events");
 const redis_smq_common_2 = require("redis-smq-common");
-const offline_consumers_1 = require("./offline-consumers");
 const cpuUsageStatsRef = {
     cpuUsage: process.cpuUsage(),
     time: process.hrtime(),
@@ -77,7 +76,11 @@ class ConsumerHeartbeat extends events_2.EventEmitter {
                 this.ticker.once(events_1.events.DOWN, cb);
                 this.ticker.quit();
             },
-            (cb) => ConsumerHeartbeat.handleExpiredHeartbeatIds(this.consumer.getConfig(), this.redisClient, [this.consumer.getId()], (err) => cb(err)),
+            (cb) => {
+                const multi = this.redisClient.multi();
+                ConsumerHeartbeat.handleExpiredHeartbeatId(this.consumer.getId(), multi);
+                multi.exec((err) => cb(err));
+            },
             (cb) => this.redisClient.halt(cb),
         ], cb);
     }
@@ -163,18 +166,13 @@ class ConsumerHeartbeat extends events_2.EventEmitter {
                 cb(null, consumerIds !== null && consumerIds !== void 0 ? consumerIds : []);
         });
     }
-    static handleExpiredHeartbeatIds(config, redisClient, consumerIds, cb) {
-        if (consumerIds.length) {
-            const { keyHeartbeats, keyHeartbeatConsumerWeight } = redis_keys_1.redisKeys.getMainKeys();
-            const multi = redisClient.multi();
-            redis_smq_common_2.async.each(consumerIds, (consumerId, _, done) => {
-                multi.hdel(keyHeartbeats, consumerId);
-                multi.zrem(keyHeartbeatConsumerWeight, consumerId);
-                (0, offline_consumers_1.handleOfflineConsumer)(config, multi, redisClient, consumerId, done);
-            }, () => multi.exec((err) => cb(err)));
-        }
-        else
-            cb();
+    static handleExpiredHeartbeatId(consumerId, multi) {
+        const { keyHeartbeats, keyHeartbeatConsumerWeight } = redis_keys_1.redisKeys.getMainKeys();
+        const ids = typeof consumerId === 'string' ? [consumerId] : consumerId;
+        ids.forEach((consumerId) => {
+            multi.hdel(keyHeartbeats, consumerId);
+            multi.zrem(keyHeartbeatConsumerWeight, consumerId);
+        });
     }
 }
 exports.ConsumerHeartbeat = ConsumerHeartbeat;

package/dist/src/lib/{broker → consumer/consumer-message-handler}/acknowledge-message.d.ts

@@ -1,5 +1,5 @@
 import { RedisClient } from 'redis-smq-common';
-import { Message } from '../message/message';
+import { Message } from '../../message/message';
 import { ICallback } from 'redis-smq-common/dist/types';
-import { IRequiredConfig } from '../../../types';
+import { IRequiredConfig } from '../../../../types';
 export declare function acknowledgeMessage(config: IRequiredConfig, redisClient: RedisClient, message: Message, keyQueueProcessing: string, cb: ICallback<void>): void;

package/dist/src/lib/{broker → consumer/consumer-message-handler}/acknowledge-message.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.acknowledgeMessage = void 0;
-const redis_keys_1 = require("../../common/redis-keys/redis-keys");
+const redis_keys_1 = require("../../../common/redis-keys/redis-keys");
 function acknowledgeMessage(config, redisClient, message, keyQueueProcessing, cb) {
     const queue = message.getRequiredQueue();
     const { store, queueSize, expire } = config.messages.store.acknowledged;

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

@@ -2,12 +2,14 @@ import { Message } from '../../message/message';
 import { EMessageUnacknowledgedCause } from '../../../../types';
 import { MessageHandler } from './message-handler';
 import { RedisClient } from 'redis-smq-common';
+import { ICompatibleLogger } from 'redis-smq-common/dist/types';
 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 logger: ICompatibleLogger;
+    constructor(messageHandler: MessageHandler, redisClient: RedisClient, logger: ICompatibleLogger);
+    protected unacknowledgeMessage(msg: Message, cause: EMessageUnacknowledgedCause): void;
     protected consumeMessage(msg: Message): void;
     handleReceivedMessage(message: Message): void;
 }

package/dist/src/lib/consumer/consumer-message-handler/consume-message.js

@@ -4,27 +4,28 @@ exports.ConsumeMessage = void 0;
 const message_1 = require("../../message/message");
 const types_1 = require("../../../../types");
 const events_1 = require("../../../common/events/events");
-const consumer_error_1 = require("../errors/consumer.error");
 const redis_keys_1 = require("../../../common/redis-keys/redis-keys");
-const retry_message_1 = require("../../broker/retry-message");
-const acknowledge_message_1 = require("../../broker/acknowledge-message");
+const redis_smq_common_1 = require("redis-smq-common");
+const retry_message_1 = require("./retry-message");
+const acknowledge_message_1 = require("./acknowledge-message");
 class ConsumeMessage {
-    constructor(messageHandler, redisClient) {
+    constructor(messageHandler, redisClient, logger) {
         this.redisClient = redisClient;
         this.messageHandler = messageHandler;
         const { keyQueueProcessing } = redis_keys_1.redisKeys.getQueueConsumerKeys(messageHandler.getQueue(), messageHandler.getConsumerId());
         this.keyQueueProcessing = keyQueueProcessing;
+        this.logger = logger;
     }
-    unacknowledgeMessage(msg, cause, err) {
-        if (err) {
-        }
-        (0, retry_message_1.retryMessage)(this.messageHandler.getConfig(), this.redisClient, this.keyQueueProcessing, msg, cause, (err, deadLetterCause) => {
+    unacknowledgeMessage(msg, cause) {
+        (0, retry_message_1.retryMessage)(this.messageHandler.getConfig(), this.redisClient, this.keyQueueProcessing, msg, cause, (err, retryStatus) => {
             if (err)
                 this.messageHandler.handleError(err);
+            else if (!retryStatus)
+                this.messageHandler.handleError(new redis_smq_common_1.errors.EmptyCallbackReplyError());
             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);
+                this.messageHandler.emit(events_1.events.MESSAGE_UNACKNOWLEDGED, msg, types_1.EMessageUnacknowledgedCause.CONSUME_ERROR);
+                if (retryStatus.status === retry_message_1.ERetryStatus.MESSAGE_DEAD_LETTERED) {
+                    this.messageHandler.emit(events_1.events.MESSAGE_DEAD_LETTERED, msg);
                 }
             }
         });
@@ -45,8 +46,10 @@ class ConsumeMessage {
                 if (this.messageHandler.isRunning() && !isTimeout) {
                     if (timer)
                         clearTimeout(timer);
-                    if (err)
-                        this.unacknowledgeMessage(msg, types_1.EMessageUnacknowledgedCause.UNACKNOWLEDGED, err);
+                    if (err) {
+                        this.logger.error(err);
+                        this.unacknowledgeMessage(msg, types_1.EMessageUnacknowledgedCause.UNACKNOWLEDGED);
+                    }
                     else {
                         (0, acknowledge_message_1.acknowledgeMessage)(this.messageHandler.getConfig(), this.redisClient, msg, this.keyQueueProcessing, (err) => {
                             if (err)
@@ -60,10 +63,8 @@ class ConsumeMessage {
             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);
+            this.logger.error(error);
+            this.unacknowledgeMessage(msg, types_1.EMessageUnacknowledgedCause.CONSUME_ERROR);
         }
     }
     handleReceivedMessage(message) {

package/dist/src/lib/{broker → consumer/consumer-message-handler}/dead-letter-message.d.ts

@@ -1,5 +1,5 @@
-import { EMessageDeadLetterCause, EMessageUnacknowledgedCause, IRequiredConfig } from '../../../types';
-import { Message } from '../message/message';
+import { EMessageDeadLetterCause, EMessageUnacknowledgedCause, IRequiredConfig } from '../../../../types';
+import { Message } from '../../message/message';
 import { ICallback, IRedisClientMulti } from 'redis-smq-common/dist/types';
 import { RedisClient } from 'redis-smq-common';
 export declare function deadLetterMessage(config: IRequiredConfig, mixed: IRedisClientMulti, message: Message, keyQueueProcessing: string, unacknowledgedCause: EMessageUnacknowledgedCause, deadLetterCause: EMessageDeadLetterCause): void;

package/dist/src/lib/{broker → consumer/consumer-message-handler}/dead-letter-message.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deadLetterMessage = void 0;
-const redis_keys_1 = require("../../common/redis-keys/redis-keys");
+const redis_keys_1 = require("../../../common/redis-keys/redis-keys");
 const redis_smq_common_1 = require("redis-smq-common");
 function deadLetterMessageTransaction(config, mixed, message, keyQueueProcessing) {
     const queue = message.getRequiredQueue();

package/dist/src/lib/{broker → consumer/consumer-message-handler}/delay-message.d.ts

@@ -1,5 +1,5 @@
-import { EMessageUnacknowledgedCause } from '../../../types';
-import { Message } from '../message/message';
+import { EMessageUnacknowledgedCause } from '../../../../types';
+import { Message } from '../../message/message';
 import { ICallback, IRedisClientMulti } from 'redis-smq-common/dist/types';
 import { RedisClient } from 'redis-smq-common';
 export declare function delayMessageTransaction(mixed: IRedisClientMulti, message: Message, keyQueueProcessing: string): void;

package/dist/src/lib/{broker → consumer/consumer-message-handler}/delay-message.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.delayMessage = exports.delayMessageTransaction = void 0;
-const redis_keys_1 = require("../../common/redis-keys/redis-keys");
+const redis_keys_1 = require("../../../common/redis-keys/redis-keys");
 const redis_smq_common_1 = require("redis-smq-common");
 function delayMessageTransaction(mixed, message, keyQueueProcessing) {
     const queue = message.getRequiredQueue();

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

@@ -13,7 +13,7 @@ export declare class DequeueMessage {
     protected messageHandler: MessageHandler;
     protected priorityQueuing: boolean;
     constructor(messageHandler: MessageHandler, redisClient: RedisClient);
-    protected dequeueMessageWithPriority(cb: ICallback<string>): void;
+    protected dequeueMessageWithPriority(cb: ICallback<string | null>): void;
     protected waitForMessage(cb: ICallback<string | null>): void;
     protected dequeueMessage(cb: ICallback<string | null>): void;
     dequeue(): void;

package/dist/src/lib/consumer/consumer-message-handler/message-handler.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
-import { IPlugin, IRequiredConfig, TConsumerMessageHandler, TQueueParams } from '../../../../types';
+import { IEventListener, IRequiredConfig, TConsumerMessageHandler, TQueueParams } from '../../../../types';
 import { EventEmitter } from 'events';
+import { TCleanUpStatus } from './processing-queue';
 import { DequeueMessage } from './dequeue-message';
 import { ConsumeMessage } from './consume-message';
 import { Consumer } from '../consumer';
@@ -18,10 +19,12 @@ export declare class MessageHandler extends EventEmitter {
     protected dequeueMessage: DequeueMessage;
     protected consumeMessage: ConsumeMessage;
     protected handler: TConsumerMessageHandler;
-    protected plugins: IPlugin[];
+    protected eventListeners: IEventListener[];
     constructor(consumer: Consumer, queue: TQueueParams, handler: TConsumerMessageHandler, dequeueRedisClient: RedisClient, sharedRedisClient: RedisClient, logger: ICompatibleLogger);
     protected registerEventsHandlers(): void;
-    protected initPlugins(): void;
+    protected initEventListeners(): void;
+    protected cleanUp(cb: ICallback<void>): void;
+    protected tearDownEventListeners(cb: ICallback<void>): void;
     handleError(err: Error): void;
     dequeue(): void;
     run(cb: ICallback<void>): void;
@@ -32,5 +35,5 @@ export declare class MessageHandler extends EventEmitter {
     getConfig(): IRequiredConfig;
     isRunning(): boolean;
     getHandler(): TConsumerMessageHandler;
-    static cleanUp(config: IRequiredConfig, redisClient: RedisClient, consumerId: string, queue: TQueueParams, pendingMulti: IRedisClientMulti | undefined, cb: ICallback<void>): void;
+    static cleanUp(config: IRequiredConfig, redisClient: RedisClient, consumerId: string, queue: TQueueParams, pendingMulti: IRedisClientMulti | undefined, cb: ICallback<TCleanUpStatus>): void;
 }