redis-smq 8.0.0-rc.26 → 8.0.0-rc.28

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 
 
+## [8.0.0-rc.28](https://github.com/weyoss/redis-smq/compare/v8.0.0-rc.27...v8.0.0-rc.28) (2025-02-05)
+
+
+### Bug Fixes
+
+* **message:** revert back shutdown method to arrow function ([c4e5ceb](https://github.com/weyoss/redis-smq/commit/c4e5cebb4d9fbd91889618669765698cb80cd044))
+
+
+### Documentation
+
+* **api:** enhance class documentation with detailed descriptions and examples ([67f8a21](https://github.com/weyoss/redis-smq/commit/67f8a21c039e41301e8bfcf2c4ffc4319b02424d))
+* **api:** separate error classes from main classes ([4aa850e](https://github.com/weyoss/redis-smq/commit/4aa850ed5411906d4a38c32a673cf2021498c294))
+* **README:** update HTTP REST API reference link ([9e20a6c](https://github.com/weyoss/redis-smq/commit/9e20a6c08bf47b1a581129f922c9922c64cb7e3d))
+* update logo, improve content readability ([7c921d4](https://github.com/weyoss/redis-smq/commit/7c921d406e05961d92769f2a43c40f7fa955d5fa))
+
+
+### Codebase Refactoring
+
+* improve code structure and readability ([5b4a47c](https://github.com/weyoss/redis-smq/commit/5b4a47cdc1139507a724d1d48202f6d8c6074174))
+
+# Changelog
+
+## [8.0.0-rc.27](https://github.com/weyoss/redis-smq/compare/v8.0.0-rc.26...v8.0.0-rc.27) (2025-01-09)
+
+### Continuous Integration
+
+* fix broken CHANGELOG.md for v8.0.0-rc.26 ([a20b40e](https://github.com/weyoss/redis-smq/commit/a20b40ec343ab07a1a0ef80f4bf7625ed27ba9ec))
+
+## [8.0.0-rc.26](https://github.com/weyoss/redis-smq/compare/v8.0.0-rc.25...v8.0.0-rc.26) (2025-01-09)
+
+
+### Documentation
+* update API reference ([b7d0f6f](https://github.com/weyoss/redis-smq/commit/b7d0f6f4e078557021854d33fd301980dab7782b))
+
+### Codebase Refactoring
+* use queue-scoped workers instead of global ones ([ada94e0](https://github.com/weyoss/redis-smq/commit/ada94e09d17f58488b1596c70b4f657110cc8b79))
+
+### Continuous Integration
+* add support for node.js v22 ([a15d62e](https://github.com/weyoss/redis-smq/commit/a15d62e49b609fb63b90082af53a0a23613677e8))
+* upgrade eslint and other deprecated dependencies ([c948298](https://github.com/weyoss/redis-smq/commit/c94829850c5cf04ca3240163669c242ba50ba9e2))
+
 ## [8.0.0-rc.25](https://github.com/weyoss/redis-smq/compare/v8.0.0-rc.24...v8.0.0-rc.25) (2024-07-07)
 
 

package/CONTRIBUTING.md

@@ -0,0 +1,20 @@
+# Contributions
+
+If you want to make any project better, your contributions are very welcome!
+
+## Pull requests
+
+It is best to open an issue in GitHub about what you want to implement / change or to suggest new features.
+
+Before submitting any pull request please make sure that your code does not stick out and consistent with the project
+coding style. You can check the status of your coding style by simply running `npm run lint`.
+
+Cover your code with new tests if needed. Only fully tested changes are accepted.
+
+Each time when you are ready to submit your changes don't forget to run `npm test` to check that your code is complying
+with eslint project rules and that all of the tests are successfully completed.
+
+## Bugs
+
+If you find any bugs, please do not hesitate to open an issue in GitHub including the case to reproduce the bug
+when possible.

package/README.md

@@ -1,142 +1,74 @@
-> [!IMPORTANT]
-> Currently, RedisSMQ is going under heavy development. Pre-releases at any time may introduce new commits with breaking changes.
-> The master branch always reflects the most recent changes. To view the latest release reference see [RedisSMQ v7.2.3](https://github.com/weyoss/redis-smq/tree/v7.2.3)
+[![RedisSMQ](./logo.png)](https://github.com/weyoss/redis-smq)
 
-<div align="center" style="text-align: center">
-    <p><a href="https://github.com/weyoss/redis-smq"><img alt="RedisSMQ" src="./logo.png?v=202312182134" /></a></p>
-    <p>A simple high-performance Redis message queue for Node.js.</p>
-    <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://github.com/weyoss/redis-smq/actions/workflows/codeql.yml" rel="nofollow"><img src="https://github.com/weyoss/redis-smq/actions/workflows/codeql.yml/badge.svg" alt="Code quality" /></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>
-    </p>
-</div>
+A High-Performance Redis Simple Message Queue for Node.js
 
-# RedisSMQ
+[![Build](https://img.shields.io/github/actions/workflow/status/weyoss/redis-smq/tests.yml?style=flat-square)](https://github.com/weyoss/redis-smq/actions/workflows/tests.yml)
+[![Code Quality](https://img.shields.io/github/actions/workflow/status/weyoss/redis-smq/codeql.yml?style=flat-square&label=quality)](https://github.com/weyoss/redis-smq/actions/workflows/codeql.yml)
+[![Code Coverage](https://img.shields.io/codecov/c/github/weyoss/redis-smq?style=flat-square)](https://codecov.io/github/weyoss/redis-smq?branch=master)
+[![Latest Release](https://img.shields.io/github/v/release/weyoss/redis-smq?include_prereleases&label=release&color=green&style=flat-square)](https://github.com/weyoss/redis-smq/releases)
+![Downloads](https://img.shields.io/npm/dm/redis-smq.svg?style=flat-square)
 
-RedisSMQ is a Node.js library for queuing messages (aka jobs) and processing them asynchronously with consumers. Backed by Redis, it allows scaling up your typical applications with ease of use.
+**Key Features**
 
-## Features
+*   [High-performance message processing](docs/performance.md)
+*   [Flexible producer/consumer model with multi-queue producers and consumers](docs/consuming-messages.md)
+*   [Different exchange types (Direct, Topic, FanOut) for publishing messages to one or multiple queues](docs/message-exchanges.md)
+*   [Two delivery models (Point-2-Point and Pub/Sub)](docs/queue-delivery-models.md) with reliable delivery and configurable retry modes
+*   [Three queuing strategies (FIFO, LIFO, Priority Queues)](docs/queues.md)
+*   [Message handler worker threads for sandboxing and performance improvement](docs/message-handler-worker-threads.md)
+*   [Message expiration and consumption timeout](docs/messages.md)
+*   [Queue rate limiting for controlling message consumption rates](docs/queue-rate-limiting.md)
+*   [Built-in scheduler for delayed message delivery and repeating messages](docs/scheduling-messages.md)
+*   [RESTful API](docs/redis-smq-rest-api.md) and [Web UI](docs/redis-smq-web-ui.md) for interacting with the message queue
+*   [Support for ESM and CJS modules](docs/esm-cjs-modules.md)
 
-* [High-performance message processing](docs/performance.md).
-* Flexible Producer/Consumer model which offers [Multi-Queue Producers](docs/producing-messages.md) & [Multi-Queue Consumers](docs/consuming-messages.md).
-* RedisSMQ offers different exchange types: [Direct Exchange](docs/message-exchanges.md#direct-exchange), [Topic Exchange](docs/message-exchanges.md#topic-exchange), and [FanOut Exchange](docs/message-exchanges.md#fanout-exchange) for publishing a message to one or multiple queues.
-* Supports [Point-2-Point](docs/queue-delivery-models.md#point-2-point-delivery-model) and [Pub/Sub](docs/queue-delivery-models.md#pubsub-delivery-model) [delivery models](docs/queue-delivery-models.md).
-* Both [delivery models](docs/queue-delivery-models.md) are reliable. For cases of failure, while delivering/consuming messages, [at-least-once](docs/api/classes/ProducibleMessage.md#setretrythreshold) and [at-most-once](docs/api/classes/ProducibleMessage.md#setretrythreshold) modes may be configured.
-* [3 queuing strategies](docs/queues.md): [FIFO queues](docs/queues.md#fifo-first-in-first-out-queues), [LIFO queues](docs/queues.md#lifo-last-in-first-out-queues), and [Priority Queues](docs/queues.md#priority-queues).
-* [Message Handler Worker Threads](docs/message-handler-worker-threads.md) which allow sandboxing and running your message handler from a separate isolated thread and without affecting the performance of other message handlers from the same consumer.
-* Messages can be [set to expire](docs/api/classes/ProducibleMessage.md#setttl) when not delivered within a given amount of time or to have a [consumption timeout](docs/api/classes/ProducibleMessage.md#setconsumetimeout) while being in process.
-* Queues may be [rate Limited](docs/queue-rate-limiting.md) to control the rate at which the messages are consumed.
-* Has a builtin [scheduler](docs/scheduling-messages.md) allowing messages [to be delayed](docs/api/classes/ProducibleMessage.md#setscheduleddelay), [to be delivered for N times](docs/api/classes/ProducibleMessage.md#setscheduledrepeat) with an optional [period between deliveries](docs/api/classes/ProducibleMessage.md#setscheduledrepeatperiod), or simply [to be scheduled using CRON expressions](docs/api/classes/ProducibleMessage.md#setscheduledcron).
-* Provides [an HTTP interface](https://github.com/weyoss/redis-smq-rest-api) to interact with the message queue using a RESTful API.
-* RedisSMQ can be managed also from your [web browser](https://github.com/weyoss/redis-smq-monitor-client).
-* Either [node-redis](https://github.com/redis/node-redis) or [ioredis](https://github.com/luin/ioredis) can be used as a Redis client.
-* [Highly optimized](https://lgtm.com/projects/g/weyoss/redis-smq/context:javascript), 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).
-* [Both ESM & CJS modules are supported](docs/esm-cjs-modules.md).
+**Use Cases**
 
-## RedisSMQ Use Case: Multi-Queue Producers & Multi-Queue Consumers
+- Managing background tasks, such as email sending or data processing.
+- Efficiently scheduling and retrying tasks.
+- Communication between multiple services in microservices architectures.
+- Handling real-time events in gaming, IoT, or analytics systems.
 
-![RedisSMQ Multi-Queue Producers & Multi-Queue Consumers](docs/redis-smq-multi-queue-consumers-producers.png)
+**Installation and Usage**
 
-## What's new?
-
-:rocket: RC's are now available for RedisSMQ v8! The v8 release will bring major improvements and new features. Some of them are:
-
-- [x] Message queue codebase refactoring and optimizations.
-- [x] Message storage and handling improvements.
-- [x] Message status which allows to retrieve, at any time, the status of a message by its ID.
-- [x] [Pub/Sub Delivery Model and Consumer Groups](docs/queue-delivery-models.md#pubsub-delivery-model).
-- [x] Message handlers sandboxing and message processing performance improvement with [Message Handler Worker Threads](docs/message-handler-worker-threads.md).
-- [x] Cross-system event propagation based on [EventBus](docs/event-bus.md).
-- [x] Better error handling aiming at reporting fatal errors to the application whenever it is possible and without crashing the main process.
-- [x] [ESM Modules Support](docs/esm-cjs-modules.md).
-
-Current RedisSMQ v8 RC status:
-
-- [x] RedisSMQ Common Library
-- [x] RedisSMQ
-- [x] [RESTful API](https://github.com/weyoss/redis-smq-rest-api)
-- [ ] Web UI (WIP)
-
-If you wish to get the latest updates early feel free to try RedisSMQ v8 RC. Do not hesitate to report any bug or issue if encountered. 
-
-Otherwise, stay with [RedisSMQ v7](https://github.com/weyoss/redis-smq/tree/v7.2.3) if you are looking for a fully working release with an HTTP API and a Web UI.
-
-## Installation
-
-```shell
+To get started with RedisSMQ, you can install the library using npm:
+```bash
 npm i redis-smq@rc
 ```
-
-Considerations:
-
-- Minimal Node.js version is >= 18 (RedisSMQ is tested under current active LTS and maintenance LTS Node.js releases).
-- Minimal Redis server version is 4.0.0.
-
-## Usage
-
-RedisSMQ provides 3 classes in order to work with the message queue: `ProducibleMessage`, `Producer`, and `Consumer`.
-
-Producers and consumers exchange data using one or multiple queues that may be created using the [Queue Class](docs/api/classes/Queue.md).
-
-A queue is responsible for holding messages which are produced by producers and are delivered to consumers.
-
-### Creating a queue
-
+Create a queue, produce a message, and consume it using the provided classes and methods:
 ```javascript
+// Creating a queue
 const queue = new Queue();
-queue.save(
-  'my_queue',
-  EQueueType.LIFO_QUEUE,
-  EQueueDeliveryModel.POINT_TO_POINT,
-  (err) => {
+queue.save('my_queue', EQueueType.LIFO_QUEUE, EQueueDeliveryModel.POINT_TO_POINT, (err) => {
     if (err) console.error(err);
-  },
-);
-```
-
-In the example above we are defining a [LIFO queue](docs/queues.md#lifo-last-in-first-out-queues) with a [POINT-2-POINT delivery model](docs/queue-delivery-models.md#point-2-point-delivery-model).
-
-See [Queues](docs/queues.md) for more details.
-
-### Producing a message
+});
 
-```javascript
+// Producing a message
 const msg = new ProducibleMessage();
 msg.setQueue('my_queue').setBody('Hello Word!');
 producer.produce(msg, (err, ids) => {
-  if (err) console.error(err);
-  else console.log(`Produced message IDs are: ${ids.join(', ')}`);
+    if (err) console.error(err);
+    else console.log(`Produced message IDs are: ${ids.join(', ')}`);
 });
-```
-
-See [Producing Messages](docs/producing-messages.md) for more details.
 
-### Consuming a message
-
-```javascript
+// Consuming a message
 const consumer = new Consumer();
 const messageHandler = (msg, cb) => {
-  console.log(msg.body);
-  cb();
+    console.log(msg.body);
+    cb(); // Acknowledging
 };
 consumer.consume('my_queue', messageHandler, (err) => {
-  if (err) console.error(err);
+    if (err) console.error(err);
 });
 ```
+**Documentation**
 
-See [Consuming Messages](docs/consuming-messages.md) for more details.
-
-## Documentation
-
-See [RedisSMQ Docs](docs/README.md) for more details.
+For more information, visit the [RedisSMQ Docs](docs/README.md).
 
-## Contributing
+**Contributing**
 
-So you are interested in contributing to this project? Please see [CONTRIBUTING.md](https://github.com/weyoss/guidelines/blob/master/CONTRIBUTIONS.md).
+Interested in contributing to this project? Please check out our [CONTRIBUTING.md](CONTRIBUTING.md).
 
-## License
+**License**
 
-[MIT](https://github.com/weyoss/redis-smq/blob/master/LICENSE)
+RedisSMQ is released under the [MIT License](https://github.com/weyoss/redis-smq/blob/master/LICENSE).

package/dist/cjs/src/lib/consumer/consumer-queues.d.ts

@@ -1,10 +1,8 @@
-import { ICallback, IRedisClient, IRedisTransaction } from 'redis-smq-common';
+import { ICallback, IRedisClient } from 'redis-smq-common';
 import { IQueueParams, TQueueConsumer } from '../queue/index.js';
 export declare const consumerQueues: {
-    removeConsumer(multi: IRedisTransaction, queue: IQueueParams, consumerId: string): void;
     getQueueConsumers(client: IRedisClient, queue: IQueueParams, transform: boolean, cb: ICallback<Record<string, TQueueConsumer | string>>): void;
     getQueueConsumerIds(client: IRedisClient, queue: IQueueParams, cb: ICallback<string[]>): void;
-    countQueueConsumers(client: IRedisClient, queue: IQueueParams, cb: ICallback<number>): void;
     getConsumerQueues(client: IRedisClient, consumerId: string, cb: ICallback<IQueueParams[]>): void;
 };
 //# sourceMappingURL=consumer-queues.d.ts.map

package/dist/cjs/src/lib/consumer/consumer-queues.js

@@ -4,48 +4,32 @@ exports.consumerQueues = void 0;
 const redis_smq_common_1 = require("redis-smq-common");
 const redis_keys_js_1 = require("../../common/redis-keys/redis-keys.js");
 exports.consumerQueues = {
-    removeConsumer(multi, queue, consumerId) {
-        const { keyQueueConsumers } = redis_keys_js_1.redisKeys.getQueueKeys(queue, null);
-        const { keyConsumerQueues } = redis_keys_js_1.redisKeys.getConsumerKeys(consumerId);
-        multi.hdel(keyQueueConsumers, consumerId);
-        multi.srem(keyConsumerQueues, JSON.stringify(queue));
-    },
     getQueueConsumers(client, queue, transform, cb) {
         const { keyQueueConsumers } = redis_keys_js_1.redisKeys.getQueueKeys(queue, null);
         client.hgetall(keyQueueConsumers, (err, reply) => {
             if (err)
-                cb(err);
-            else {
-                const consumers = reply !== null && reply !== void 0 ? reply : {};
-                if (transform) {
-                    const data = {};
-                    redis_smq_common_1.async.eachIn(consumers, (item, key, done) => {
-                        data[key] = JSON.parse(item);
-                        done();
-                    }, () => cb(null, data));
-                }
-                else
-                    cb(null, consumers);
-            }
+                return cb(err);
+            const consumers = reply !== null && reply !== void 0 ? reply : {};
+            if (!transform)
+                return cb(null, consumers);
+            const data = {};
+            redis_smq_common_1.async.eachIn(consumers, (item, key, done) => {
+                data[key] = JSON.parse(item);
+                done();
+            }, () => cb(null, data));
         });
     },
     getQueueConsumerIds(client, queue, cb) {
         const { keyQueueConsumers } = redis_keys_js_1.redisKeys.getQueueKeys(queue, null);
         client.hkeys(keyQueueConsumers, cb);
     },
-    countQueueConsumers(client, queue, cb) {
-        const { keyQueueConsumers } = redis_keys_js_1.redisKeys.getQueueKeys(queue, null);
-        client.hlen(keyQueueConsumers, cb);
-    },
     getConsumerQueues(client, consumerId, cb) {
         const { keyConsumerQueues } = redis_keys_js_1.redisKeys.getConsumerKeys(consumerId);
         client.smembers(keyConsumerQueues, (err, reply) => {
             if (err)
-                cb(err);
-            else {
-                const queues = (reply !== null && reply !== void 0 ? reply : []).map((i) => JSON.parse(i));
-                cb(null, queues);
-            }
+                return cb(err);
+            const queues = (reply !== null && reply !== void 0 ? reply : []).map((i) => JSON.parse(i));
+            cb(null, queues);
         });
     },
 };

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

@@ -108,8 +108,7 @@ class MessageHandler extends redis_smq_common_1.Runnable {
     cleanUp(cb) {
         const redisClient = this.redisClient.getInstance();
         if (redisClient instanceof Error) {
-            cb();
-            return void 0;
+            return cb();
         }
         processing_queue_js_1.processingQueue.unknowledgeMessage(redisClient, this.consumerId, [this.queue.queueParams], this.logger, index_js_3.EMessageUnknowledgmentReason.OFFLINE_MESSAGE_HANDLER, () => cb());
     }
@@ -158,17 +157,18 @@ class MessageHandler extends redis_smq_common_1.Runnable {
                 return void 0;
             }
             redisClient.runScript(scripts_js_1.ELuaScriptName.FETCH_MESSAGE_FOR_PROCESSING, keys, argv, (err, reply) => {
-                if (err)
-                    this.handleError(err);
-                else if (!reply)
-                    this.handleError(new redis_smq_common_1.CallbackEmptyReplyError());
-                else if (!Array.isArray(reply))
-                    this.handleError(new redis_smq_common_1.CallbackInvalidReplyError());
-                else {
-                    const [state, msg] = reply;
-                    const message = (0, _from_message_js_1._fromMessage)(msg, index_js_2.EMessagePropertyStatus.PROCESSING, state);
-                    this.consumeMessage.handleReceivedMessage(message);
+                if (err) {
+                    return this.handleError(err);
+                }
+                if (!reply) {
+                    return this.handleError(new redis_smq_common_1.CallbackEmptyReplyError());
+                }
+                if (!Array.isArray(reply)) {
+                    return this.handleError(new redis_smq_common_1.CallbackInvalidReplyError());
                 }
+                const [state, msg] = reply;
+                const message = (0, _from_message_js_1._fromMessage)(msg, index_js_2.EMessagePropertyStatus.PROCESSING, state);
+                this.consumeMessage.handleReceivedMessage(message);
             });
         }
     }

package/dist/cjs/src/lib/consumer/message-handler/processing-queue/processing-queue.js

@@ -31,49 +31,40 @@ function getMessageUnknowledgementAction(message, unacknowledgedReason) {
         };
     }
     const delay = message.producibleMessage.getRetryDelay();
-    if (delay) {
-        return {
-            action: index_js_4.EMessageUnknowledgmentAction.DELAY,
-        };
-    }
-    return {
-        action: index_js_4.EMessageUnknowledgmentAction.REQUEUE,
-    };
+    return delay
+        ? { action: index_js_4.EMessageUnknowledgmentAction.DELAY }
+        : { action: index_js_4.EMessageUnknowledgmentAction.REQUEUE };
 }
 function unknowledgeProcessingQueueMessage(redisClient, consumerId, queue, unknowledgmentReason, keys, args, unacknowledgementStatus, done) {
-    args.push(JSON.stringify(queue));
-    args.push(consumerId);
+    args.push(JSON.stringify(queue), consumerId);
     const { keyConsumerQueues } = redis_keys_js_1.redisKeys.getConsumerKeys(consumerId);
     const { keyQueueProcessing } = redis_keys_js_1.redisKeys.getQueueConsumerKeys(queue, consumerId);
     const { keyQueueDL, keyQueueProcessingQueues, keyQueueConsumers, keyQueueProperties, keyQueueDelayed, keyQueueRequeued, } = redis_keys_js_1.redisKeys.getQueueKeys(queue, null);
     keys.push(keyQueueProcessing, keyQueueDelayed, keyQueueRequeued, keyQueueDL, keyQueueProcessingQueues, keyQueueConsumers, keyConsumerQueues, keyQueueProperties);
     exports.processingQueue.fetchProcessingQueueMessage(redisClient, keyQueueProcessing, (err, message) => {
         if (err)
-            done(err);
-        else {
-            if (message) {
-                const messageId = message.getId();
-                args.push(messageId);
-                const { keyMessage } = redis_keys_js_1.redisKeys.getMessageKeys(messageId);
-                keys.push(keyMessage);
-                const unknowledgementAction = getMessageUnknowledgementAction(message, unknowledgmentReason);
-                const { action } = unknowledgementAction;
-                const messageStatus = action === index_js_4.EMessageUnknowledgmentAction.DEAD_LETTER
-                    ? index_js_2.EMessagePropertyStatus.DEAD_LETTERED
-                    : action === index_js_4.EMessageUnknowledgmentAction.REQUEUE
-                        ? index_js_2.EMessagePropertyStatus.UNACK_REQUEUING
-                        : index_js_2.EMessagePropertyStatus.UNACK_DELAYING;
-                args.push(action, action === index_js_4.EMessageUnknowledgmentAction.DEAD_LETTER
-                    ? unknowledgementAction.deadLetterReason
-                    : '', unknowledgmentReason, messageStatus);
-                unacknowledgementStatus[messageId] = unknowledgementAction;
-            }
-            else {
-                keys.push('');
-                args.push('', '', '', unknowledgmentReason, '');
-            }
-            done();
+            return done(err);
+        if (!message) {
+            keys.push('');
+            args.push('', '', '', unknowledgmentReason, '');
+            return done();
         }
+        const messageId = message.getId();
+        const { keyMessage } = redis_keys_js_1.redisKeys.getMessageKeys(messageId);
+        keys.push(keyMessage);
+        args.push(messageId);
+        const unknowledgementAction = getMessageUnknowledgementAction(message, unknowledgmentReason);
+        const { action } = unknowledgementAction;
+        const messageStatus = action === index_js_4.EMessageUnknowledgmentAction.DEAD_LETTER
+            ? index_js_2.EMessagePropertyStatus.DEAD_LETTERED
+            : action === index_js_4.EMessageUnknowledgmentAction.REQUEUE
+                ? index_js_2.EMessagePropertyStatus.UNACK_REQUEUING
+                : index_js_2.EMessagePropertyStatus.UNACK_DELAYING;
+        args.push(action, action === index_js_4.EMessageUnknowledgmentAction.DEAD_LETTER
+            ? unknowledgementAction.deadLetterReason
+            : '', unknowledgmentReason, messageStatus);
+        unacknowledgementStatus[messageId] = unknowledgementAction;
+        done();
     });
 }
 exports.processingQueue = {
@@ -93,53 +84,58 @@ exports.processingQueue = {
         ];
         const messageHandlingStatus = {};
         redis_smq_common_1.async.waterfall([
-            (cb) => {
-                if (queues === null)
-                    consumer_queues_js_1.consumerQueues.getConsumerQueues(redisClient, consumerId, cb);
-                else
-                    cb(null, queues);
+            (next) => {
+                if (queues === null) {
+                    consumer_queues_js_1.consumerQueues.getConsumerQueues(redisClient, consumerId, next);
+                }
+                else {
+                    next(null, queues);
+                }
             },
-            (queueParams, cb) => {
-                if (queueParams.length) {
-                    redis_smq_common_1.async.eachOf(queueParams, (queue, _, done) => {
-                        unknowledgeProcessingQueueMessage(redisClient, consumerId, queue, unknowledgmentReason, keys, args, messageHandlingStatus, done);
-                    }, cb);
+            (queueParams, next) => {
+                if (!queueParams.length) {
+                    return next();
                 }
-                else
-                    cb();
+                redis_smq_common_1.async.eachOf(queueParams, (queue, _, done) => {
+                    unknowledgeProcessingQueueMessage(redisClient, consumerId, queue, unknowledgmentReason, keys, args, messageHandlingStatus, done);
+                }, next);
             },
         ], (err) => {
-            if (err)
-                cb(err);
-            else if (keys.length) {
-                redisClient.runScript(scripts_js_1.ELuaScriptName.HANDLE_PROCESSING_QUEUE, keys, args, (err, reply) => {
-                    if (err)
-                        cb(err);
-                    else if (reply !== 'OK')
-                        cb(new index_js_3.ConsumerError(reply ? String(reply) : undefined));
-                    else {
-                        for (const messageId in messageHandlingStatus) {
-                            logger.debug(`Message ID ${messageId} has been ${messageHandlingStatus[messageId].action ===
-                                index_js_4.EMessageUnknowledgmentAction.DEAD_LETTER
-                                ? 'dead-lettered'
-                                : 'unacknowledged'}.`);
-                        }
-                        cb(null, messageHandlingStatus);
-                    }
-                });
+            if (err) {
+                return cb(err);
             }
-            else
-                cb();
+            if (!keys.length) {
+                return cb();
+            }
+            redisClient.runScript(scripts_js_1.ELuaScriptName.HANDLE_PROCESSING_QUEUE, keys, args, (err, reply) => {
+                if (err) {
+                    return cb(err);
+                }
+                if (reply !== 'OK') {
+                    return cb(new index_js_3.ConsumerError(reply ? String(reply) : undefined));
+                }
+                Object.keys(messageHandlingStatus).forEach((messageId) => {
+                    const action = messageHandlingStatus[messageId].action ===
+                        index_js_4.EMessageUnknowledgmentAction.DEAD_LETTER
+                        ? 'dead-lettered'
+                        : 'unacknowledged';
+                    logger.debug(`Message ID ${messageId} has been ${action}.`);
+                });
+                cb(null, messageHandlingStatus);
+            });
         });
     },
     fetchProcessingQueueMessage(redisClient, keyQueueProcessing, cb) {
         redisClient.lrange(keyQueueProcessing, 0, 0, (err, range) => {
-            if (err)
-                cb(err);
-            else if (range && range.length)
+            if (err) {
+                return cb(err);
+            }
+            if (range && range.length) {
                 (0, _get_message_js_1._getMessage)(redisClient, range[0], cb);
-            else
+            }
+            else {
                 cb();
+            }
         });
     },
     getQueueProcessingQueues(redisClient, queue, cb) {