redis-smq 7.0.0-rc.4 → 7.0.0-rc.7

package/.codecov.yml

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

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # CHANGELOG
 
+## 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)
+
+## 7.0.0-rc.5 (2022-05-31)
+
+* Bump up redis-smq-common to v1.0.0-rc.10 (e025525)
+* Update docs (738d9d0)
+
 ## 7.0.0-rc.4 (2022-05-30)
 
 * Update README.md (fef27c1)

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,19 +19,19 @@ RedisSMQ is a Node.js library for queuing messages (aka jobs) and processing the
 
 ## Features
 
-* **[High-performance message processing](docs/performance.md)**
+* **[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.
-* **[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.
-* **[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)**: A feature which allows message handlers to use a single redis connection to dequeue and consume messages.  
+* **[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.
+* **[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)**: 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.
-* **[Configurable](docs/configuration.md)**: Many options and features can be configured.
+* **[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).
@@ -41,7 +41,7 @@ RedisSMQ is a Node.js library for queuing messages (aka jobs) and processing the
 
 &nbsp;
 
-![RedisSMQ Overview](docs/redis-smq-overview.png)
+![RedisSMQ Overview](/docs/redis-smq-overview.png)
 
 ## Table of Content
 
@@ -53,17 +53,18 @@ 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)
-      3. [Queue Rate Limiting](docs/queue-rate-limiting.md)
-      4. [Multiplexing](docs/multiplexing.md)
-      5. [Message Manager](docs/api/message-manager.md)
-      6. [Queue Manager](docs/api/queue-manager.md)
+      1. [Scheduling Messages](/docs/scheduling-messages.md)
+      2. [Priority Queues](/docs/priority-queues.md)
+      3. [Queue Rate Limiting](/docs/queue-rate-limiting.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](https://github.com/weyoss/redis-smq-monitor)
       8. [Web UI](https://github.com/weyoss/redis-smq-monitor-client)
       9. [Logs](https://github.com/weyoss/redis-smq-common/blob/master/docs/logs.md)
-5. [RedisSMQ Architecture](docs/redis-smq-architecture.md)
+5. [RedisSMQ Architecture](/docs/redis-smq-architecture.md)
 6. [Performance](#performance)
 7. [Contributing](#contributing)
 8. [License](#license)
@@ -88,7 +89,7 @@ Considerations:
 
 ## Configuration
 
-See [Configuration](docs/configuration.md) for more details.
+See [Configuration](/docs/configuration.md) for more details.
 
 ## Usage
 
@@ -129,11 +130,11 @@ message
 
 The `Message` class provides many methods for setting up different message parameters such as message body, message priority, message TTL, etc. 
 
-See [Message Reference](docs/api/message.md) for more details.
+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.
 
@@ -162,23 +163,21 @@ producer.produce(message, (err) => {
 });
 ```
 
-See [Producer Reference](docs/api/producer.md) for more details.
+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,33 +201,37 @@ 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.
+See [Consumer Reference](/docs/api/consumer.md) for more details.
 
 ### Advanced Topics
 
-* [Scheduling Messages](docs/scheduling-messages.md)
+* [Scheduling Messages](/docs/scheduling-messages.md)
 
-* [Priority Queues](docs/priority-queues.md)
+* [Priority Queues](/docs/priority-queues.md)
 
-* [Queue Rate Limiting](docs/queue-rate-limiting.md)
+* [Queue Rate Limiting](/docs/queue-rate-limiting.md)
 
-* [Multiplexing](docs/multiplexing.md)
+* [Multiplexing](/docs/multiplexing.md)
   
-* [Message Manager](docs/api/message-manager.md)
+* [Message Manager](/docs/api/message-manager.md)
 
-* [Queue Manager](docs/api/queue-manager.md)
+* [Queue Manager](/docs/api/queue-manager.md)
 
 * [HTTP API](https://github.com/weyoss/redis-smq-monitor)
 
@@ -238,11 +241,11 @@ See [Consumer Reference](docs/api/consumer.md) for more details.
 
 ## RedisSMQ Architecture
 
-* See [Architecture Overview](docs/redis-smq-architecture.md).
+* See [Architecture Overview](/docs/redis-smq-architecture.md).
 
 ## Performance
 
-See [Performance](docs/performance.md) for more details.
+See [Performance](/docs/performance.md) for more details.
 
 ## Contributing
 

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/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

@@ -14,8 +14,8 @@ export declare class DequeueMessage {
     protected priorityQueuing: boolean;
     constructor(messageHandler: MessageHandler, redisClient: RedisClient);
     protected dequeueMessageWithPriority(cb: ICallback<string>): void;
-    protected waitForMessage(cb: ICallback<string>): void;
-    protected dequeueMessage(cb: ICallback<string>): void;
+    protected waitForMessage(cb: ICallback<string | null>): void;
+    protected dequeueMessage(cb: ICallback<string | null>): void;
     dequeue(): void;
     run(cb: ICallback<void>): void;
     quit(cb: ICallback<void>): 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 { EventEmitter } from 'events';
+import { TCleanUpStatus } from './processing-queue';
 import { DequeueMessage } from './dequeue-message';
 import { ConsumeMessage } from './consume-message';
 import { Consumer } from '../consumer';
@@ -22,6 +23,8 @@ export declare class MessageHandler extends EventEmitter {
     constructor(consumer: Consumer, queue: TQueueParams, handler: TConsumerMessageHandler, dequeueRedisClient: RedisClient, sharedRedisClient: RedisClient, logger: ICompatibleLogger);
     protected registerEventsHandlers(): void;
     protected initPlugins(): void;
+    protected cleanUp(cb: ICallback<void>): void;
+    protected tearDownPlugins(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;
 }

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

@@ -10,6 +10,7 @@ const dequeue_message_1 = require("./dequeue-message");
 const consume_message_1 = require("./consume-message");
 const plugins_1 = require("../../../plugins/plugins");
 const redis_smq_common_1 = require("redis-smq-common");
+const retry_message_1 = require("./retry-message");
 class MessageHandler extends events_2.EventEmitter {
     constructor(consumer, queue, handler, dequeueRedisClient, sharedRedisClient, logger) {
         super();
@@ -24,7 +25,7 @@ class MessageHandler extends events_2.EventEmitter {
         this.powerManager = new redis_smq_common_1.PowerManager();
         this.logger = logger;
         this.dequeueMessage = new dequeue_message_1.DequeueMessage(this, dequeueRedisClient);
-        this.consumeMessage = new consume_message_1.ConsumeMessage(this, dequeueRedisClient);
+        this.consumeMessage = new consume_message_1.ConsumeMessage(this, dequeueRedisClient, logger);
         this.registerEventsHandlers();
         this.initPlugins();
     }
@@ -63,6 +64,30 @@ class MessageHandler extends events_2.EventEmitter {
             this.plugins.push(plugin);
         });
     }
+    cleanUp(cb) {
+        MessageHandler.cleanUp(this.getConfig(), this.sharedRedisClient, this.consumerId, this.queue, undefined, (err, reply) => {
+            if (err)
+                cb(err);
+            else if (reply) {
+                this.logger.debug(`Message ID ${reply.message.getId()} has been ${reply.status === retry_message_1.ERetryStatus.MESSAGE_DEAD_LETTERED
+                    ? 'dead-lettered'
+                    : 'unacknowledged'}.`);
+                cb();
+            }
+            else
+                cb();
+        });
+    }
+    tearDownPlugins(cb) {
+        redis_smq_common_1.async.each(this.plugins, (plugin, index, done) => plugin.quit(done), (err) => {
+            if (err)
+                cb(err);
+            else {
+                this.plugins = [];
+                cb();
+            }
+        });
+    }
     handleError(err) {
         if (this.powerManager.isRunning() || this.powerManager.isGoingUp()) {
             this.emit(events_1.events.ERROR, err);
@@ -87,25 +112,10 @@ class MessageHandler extends events_2.EventEmitter {
         const goDown = () => {
             this.powerManager.goingDown();
             redis_smq_common_1.async.waterfall([
-                (cb) => {
-                    this.dequeueMessage.quit(cb);
-                },
-                (cb) => {
-                    redis_smq_common_1.async.each(this.plugins, (plugin, index, done) => plugin.quit(done), (err) => {
-                        if (err)
-                            cb(err);
-                        else {
-                            this.plugins = [];
-                            cb();
-                        }
-                    });
-                },
-                (cb) => {
-                    MessageHandler.cleanUp(this.getConfig(), this.sharedRedisClient, this.consumerId, this.queue, undefined, cb);
-                },
-                (cb) => {
-                    this.dequeueRedisClient.halt(cb);
-                },
+                (cb) => this.dequeueMessage.quit(cb),
+                (cb) => this.tearDownPlugins(cb),
+                (cb) => this.cleanUp(cb),
+                (cb) => this.dequeueRedisClient.halt(cb),
             ], (err) => {
                 if (err)
                     cb(err);
@@ -141,9 +151,17 @@ class MessageHandler extends events_2.EventEmitter {
     }
     static cleanUp(config, redisClient, consumerId, queue, pendingMulti, cb) {
         const multi = pendingMulti !== null && pendingMulti !== void 0 ? pendingMulti : redisClient.multi();
+        let status = false;
         redis_smq_common_1.async.waterfall([
             (cb) => {
-                processing_queue_1.processingQueue.cleanUpProcessingQueue(config, redisClient, consumerId, queue, multi, cb);
+                processing_queue_1.processingQueue.cleanUpProcessingQueue(config, redisClient, consumerId, queue, multi, (err, reply) => {
+                    if (err)
+                        cb(err);
+                    else {
+                        status = reply !== null && reply !== void 0 ? reply : false;
+                        cb();
+                    }
+                });
             },
             (cb) => {
                 consumer_queues_1.consumerQueues.removeConsumer(multi, queue, consumerId);
@@ -153,9 +171,14 @@ class MessageHandler extends events_2.EventEmitter {
             if (err)
                 cb(err);
             else if (pendingMulti)
-                cb();
+                cb(null, status);
             else
-                multi.exec((err) => cb(err));
+                multi.exec((err) => {
+                    if (err)
+                        cb(err);
+                    else
+                        cb(null, status);
+                });
         });
     }
 }

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

@@ -22,22 +22,9 @@ class MultiplexedMessageHandler extends message_handler_1.MessageHandler {
         const goDown = () => {
             this.powerManager.goingDown();
             redis_smq_common_1.async.waterfall([
-                (cb) => {
-                    this.dequeueMessage.quit(cb);
-                },
-                (cb) => {
-                    redis_smq_common_1.async.each(this.plugins, (plugin, index, done) => plugin.quit(done), (err) => {
-                        if (err)
-                            cb(err);
-                        else {
-                            this.plugins = [];
-                            cb();
-                        }
-                    });
-                },
-                (cb) => {
-                    message_handler_1.MessageHandler.cleanUp(this.getConfig(), this.sharedRedisClient, this.consumerId, this.queue, undefined, cb);
-                },
+                (cb) => this.dequeueMessage.quit(cb),
+                (cb) => this.tearDownPlugins(cb),
+                (cb) => this.cleanUp(cb),
             ], (err) => {
                 if (err)
                     cb(err);

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

@@ -1,8 +1,10 @@
 import { IRequiredConfig, TQueueParams } from '../../../../types';
 import { RedisClient } from 'redis-smq-common';
 import { ICallback, IRedisClientMulti } from 'redis-smq-common/dist/types';
+import { TRetryStatus } from './retry-message';
+export declare type TCleanUpStatus = TRetryStatus | false;
 export declare const processingQueue: {
-    cleanUpProcessingQueue(config: IRequiredConfig, redisClient: RedisClient, consumerId: string, queue: TQueueParams, multi: IRedisClientMulti, cb: ICallback<void>): void;
+    cleanUpProcessingQueue(config: IRequiredConfig, redisClient: RedisClient, consumerId: string, queue: TQueueParams, multi: IRedisClientMulti, cb: ICallback<TCleanUpStatus>): void;
     setUpProcessingQueue(multi: IRedisClientMulti, queue: TQueueParams, consumerId: string): void;
     getQueueProcessingQueues(redisClient: RedisClient, queue: TQueueParams, cb: ICallback<Record<string, string>>): void;
 };

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

@@ -5,8 +5,8 @@ const types_1 = require("../../../../types");
 const message_1 = require("../../message/message");
 const redis_smq_common_1 = require("redis-smq-common");
 const redis_keys_1 = require("../../../common/redis-keys/redis-keys");
-const retry_message_1 = require("../../broker/retry-message");
-function fetchProcessingQueueMessage(redisClient, consumerId, keyQueueProcessing, cb) {
+const retry_message_1 = require("./retry-message");
+function fetchProcessingQueueMessage(redisClient, keyQueueProcessing, cb) {
     redisClient.lrange(keyQueueProcessing, 0, 0, (err, range) => {
         if (err)
             cb(err);
@@ -27,13 +27,14 @@ function deleteProcessingQueue(multi, queue, processingQueue) {
 exports.processingQueue = {
     cleanUpProcessingQueue(config, redisClient, consumerId, queue, multi, cb) {
         const { keyQueueProcessing } = redis_keys_1.redisKeys.getQueueConsumerKeys(queue, consumerId);
+        let status = false;
         redis_smq_common_1.async.waterfall([
             (cb) => {
-                fetchProcessingQueueMessage(redisClient, consumerId, keyQueueProcessing, (err, msg) => {
+                fetchProcessingQueueMessage(redisClient, keyQueueProcessing, (err, msg) => {
                     if (err)
                         cb(err);
                     else if (msg) {
-                        const deadLettered = (0, retry_message_1.retryMessage)(config, multi, keyQueueProcessing, msg, types_1.EMessageUnacknowledgedCause.RECOVERY);
+                        status = (0, retry_message_1.retryMessage)(config, multi, keyQueueProcessing, msg, types_1.EMessageUnacknowledgedCause.OFFLINE_CONSUMER);
                         cb();
                     }
                     else
@@ -44,7 +45,12 @@ exports.processingQueue = {
                 deleteProcessingQueue(multi, queue, keyQueueProcessing);
                 cb();
             },
-        ], cb);
+        ], (err) => {
+            if (err)
+                cb(err);
+            else
+                cb(null, status);
+        });
     },
     setUpProcessingQueue(multi, queue, consumerId) {
         const { keyQueueProcessing, keyProcessingQueues, keyQueueProcessingQueues, } = redis_keys_1.redisKeys.getQueueConsumerKeys(queue, consumerId);

package/dist/src/lib/{broker → consumer/consumer-message-handler}/requeue-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 requeueMessage(mixed: IRedisClientMulti, message: Message, keyQueueProcessing: string, unacknowledgedCause: EMessageUnacknowledgedCause): void;

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requeueMessage = 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 requeueMessage(mixed, message, keyQueueProcessing, unacknowledgedCause, cb) {
     const queue = message.getRequiredQueue();

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

@@ -0,0 +1,15 @@
+import { 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 enum ERetryStatus {
+    MESSAGE_DELAYED = 0,
+    MESSAGE_REQUEUED = 1,
+    MESSAGE_DEAD_LETTERED = 2
+}
+export declare type TRetryStatus = {
+    status: ERetryStatus;
+    message: Message;
+};
+export declare function retryMessage(config: IRequiredConfig, mixed: IRedisClientMulti, processingQueue: string, message: Message, unacknowledgedCause: EMessageUnacknowledgedCause): TRetryStatus;
+export declare function retryMessage(config: IRequiredConfig, mixed: RedisClient, processingQueue: string, message: Message, unacknowledgedCause: EMessageUnacknowledgedCause, cb: ICallback<TRetryStatus>): void;

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.retryMessage = void 0;
-const types_1 = require("../../../types");
+exports.retryMessage = exports.ERetryStatus = void 0;
+const types_1 = require("../../../../types");
 const dead_letter_message_1 = require("./dead-letter-message");
 const requeue_message_1 = require("./requeue-message");
 const delay_message_1 = require("./delay-message");
@@ -12,6 +12,12 @@ var EValidateAction;
     EValidateAction[EValidateAction["REQUEUE"] = 1] = "REQUEUE";
     EValidateAction[EValidateAction["DELAY"] = 2] = "DELAY";
 })(EValidateAction || (EValidateAction = {}));
+var ERetryStatus;
+(function (ERetryStatus) {
+    ERetryStatus[ERetryStatus["MESSAGE_DELAYED"] = 0] = "MESSAGE_DELAYED";
+    ERetryStatus[ERetryStatus["MESSAGE_REQUEUED"] = 1] = "MESSAGE_REQUEUED";
+    ERetryStatus[ERetryStatus["MESSAGE_DEAD_LETTERED"] = 2] = "MESSAGE_DEAD_LETTERED";
+})(ERetryStatus = exports.ERetryStatus || (exports.ERetryStatus = {}));
 function getRetryAction(message, unacknowledgedCause) {
     if (unacknowledgedCause === types_1.EMessageUnacknowledgedCause.TTL_EXPIRED ||
         message.getSetExpired()) {
@@ -46,12 +52,14 @@ function retryTransaction(config, mixed, processingQueue, message, unacknowledge
     const r = getRetryAction(message, unacknowledgedCause);
     if (r.action === EValidateAction.DEAD_LETTER) {
         (0, dead_letter_message_1.deadLetterMessage)(config, mixed, message, processingQueue, unacknowledgedCause, r.deadLetterCause);
-        return r.deadLetterCause;
+        return { message, status: ERetryStatus.MESSAGE_DEAD_LETTERED };
     }
     if (r.action === EValidateAction.REQUEUE) {
-        return (0, requeue_message_1.requeueMessage)(mixed, message, processingQueue, unacknowledgedCause);
+        (0, requeue_message_1.requeueMessage)(mixed, message, processingQueue, unacknowledgedCause);
+        return { message, status: ERetryStatus.MESSAGE_REQUEUED };
     }
-    return (0, delay_message_1.delayMessage)(mixed, message, processingQueue, unacknowledgedCause);
+    (0, delay_message_1.delayMessage)(mixed, message, processingQueue, unacknowledgedCause);
+    return { message, status: ERetryStatus.MESSAGE_DELAYED };
 }
 function retryMessage(config, mixed, processingQueue, message, unacknowledgedCause, cb) {
     if (mixed instanceof redis_smq_common_1.RedisClient) {
@@ -63,13 +71,23 @@ function retryMessage(config, mixed, processingQueue, message, unacknowledgedCau
                 if (err)
                     cb(err);
                 else
-                    cb(null, r.deadLetterCause);
+                    cb(null, { message, status: ERetryStatus.MESSAGE_DEAD_LETTERED });
             });
         }
         if (r.action === EValidateAction.DELAY) {
-            return (0, delay_message_1.delayMessage)(mixed, message, processingQueue, unacknowledgedCause, cb);
+            return (0, delay_message_1.delayMessage)(mixed, message, processingQueue, unacknowledgedCause, (err) => {
+                if (err)
+                    cb(err);
+                else
+                    cb(null, { message, status: ERetryStatus.MESSAGE_DELAYED });
+            });
         }
-        return (0, requeue_message_1.requeueMessage)(mixed, message, processingQueue, unacknowledgedCause, cb);
+        return (0, requeue_message_1.requeueMessage)(mixed, message, processingQueue, unacknowledgedCause, (err) => {
+            if (err)
+                cb(err);
+            else
+                cb(null, { message, status: ERetryStatus.MESSAGE_REQUEUED });
+        });
     }
     else {
         return retryTransaction(config, mixed, processingQueue, message, unacknowledgedCause);

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

@@ -1,19 +1,21 @@
 import { TConsumerMessageHandler, TConsumerRedisKeys, TConsumerInfo, TQueueParams, IConfig } from '../../../types';
+import { ConsumerHeartbeat } from './consumer-heartbeat';
 import { Base } from '../base';
-import { RedisClient } from 'redis-smq-common';
+import { MessageHandlerRunner } from './consumer-message-handler/message-handler-runner';
+import { RedisClient, WorkerRunner } from 'redis-smq-common';
 import { ICallback, TUnaryFunction } from 'redis-smq-common/dist/types';
 export declare class Consumer extends Base {
-    private readonly redisKeys;
-    private readonly messageHandlerRunner;
-    private heartbeat;
-    private workerRunner;
+    protected readonly redisKeys: TConsumerRedisKeys;
+    protected readonly messageHandlerRunner: MessageHandlerRunner;
+    protected heartbeat: ConsumerHeartbeat | null;
+    protected workerRunner: WorkerRunner | null;
     constructor(config?: IConfig, useMultiplexing?: boolean);
-    private setUpHeartbeat;
-    private tearDownHeartbeat;
-    private setUpConsumerWorkers;
-    private tearDownConsumerWorkers;
-    private runMessageHandlers;
-    private shutdownMessageHandlers;
+    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 runMessageHandlers: (cb: ICallback<void>) => void;
+    protected shutdownMessageHandlers: (cb: ICallback<void>) => void;
     protected goingUp(): TUnaryFunction<ICallback<void>>[];
     protected goingDown(): TUnaryFunction<ICallback<void>>[];
     consume(queue: string | TQueueParams, messageHandler: TConsumerMessageHandler, cb: ICallback<void>): void;

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

@@ -11,7 +11,7 @@ const multiplexed_message_handler_runner_1 = require("./consumer-message-handler
 const queue_1 = require("../queue-manager/queue");
 const redis_smq_common_1 = require("redis-smq-common");
 const delay_worker_1 = require("../../workers/delay.worker");
-const heartbeat_monitor_worker_1 = require("../../workers/heartbeat-monitor.worker");
+const watchdog_worker_1 = require("../../workers/watchdog.worker");
 const requeue_worker_1 = require("../../workers/requeue.worker");
 const schedule_worker_1 = require("../../workers/schedule.worker");
 class Consumer extends base_1.Base {
@@ -50,7 +50,7 @@ class Consumer extends base_1.Base {
             this.workerRunner.on(events_1.events.ERROR, (err) => this.emit(events_1.events.ERROR, err));
             this.workerRunner.once(events_1.events.UP, cb);
             this.workerRunner.addWorker(new delay_worker_1.default(redisClient, true));
-            this.workerRunner.addWorker(new heartbeat_monitor_worker_1.default(redisClient, this.config, true));
+            this.workerRunner.addWorker(new watchdog_worker_1.default(redisClient, this.config, true, this.logger));
             this.workerRunner.addWorker(new requeue_worker_1.default(redisClient, true));
             this.workerRunner.addWorker(new schedule_worker_1.default(redisClient, true));
             this.workerRunner.run();

package/dist/src/lib/producer/producer.js

@@ -10,7 +10,7 @@ const plugins_1 = require("../../plugins/plugins");
 const message_queue_required_error_1 = require("./errors/message-queue-required.error");
 const message_already_published_error_1 = require("./errors/message-already-published.error");
 const redis_client_1 = require("../../common/redis-client/redis-client");
-const schedule_message_1 = require("../broker/schedule-message");
+const schedule_message_1 = require("./schedule-message");
 const queue_1 = require("../queue-manager/queue");
 class Producer extends base_1.Base {
     constructor(config = {}) {

package/dist/src/lib/{broker → producer}/schedule-message.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scheduleMessage = void 0;
 const redis_keys_1 = require("../../common/redis-keys/redis-keys");
-const message_not_scheduled_error_1 = require("../producer/errors/message-not-scheduled.error");
+const message_not_scheduled_error_1 = require("./errors/message-not-scheduled.error");
 const redis_smq_common_1 = require("redis-smq-common");
 const redis_client_1 = require("../../common/redis-client/redis-client");
 function scheduleMessageTransaction(multi, message) {

package/dist/src/lib/queue-manager/queue-rate-limit.d.ts

@@ -8,7 +8,7 @@ export declare class QueueRateLimit {
     constructor(config: IRequiredConfig, redisClient: RedisClient, logger: ICompatibleLogger);
     clear(queue: string | TQueueParams, cb: ICallback<void>): void;
     set(queue: string | TQueueParams, rateLimit: TQueueRateLimit, cb: ICallback<void>): void;
-    get(queue: string | TQueueParams, cb: ICallback<TQueueRateLimit>): void;
+    get(queue: string | TQueueParams, cb: ICallback<TQueueRateLimit | null>): void;
     static hasExceeded(redisClient: RedisClient, queue: TQueueParams, rateLimit: TQueueRateLimit, cb: ICallback<boolean>): void;
-    static get(config: IRequiredConfig, redisClient: RedisClient, queue: string | TQueueParams, cb: ICallback<TQueueRateLimit>): void;
+    static get(config: IRequiredConfig, redisClient: RedisClient, queue: string | TQueueParams, cb: ICallback<TQueueRateLimit | null>): void;
 }

package/dist/src/workers/delay.worker.js

@@ -4,7 +4,7 @@ exports.DelayWorker = void 0;
 const redis_keys_1 = require("../common/redis-keys/redis-keys");
 const message_1 = require("../lib/message/message");
 const redis_smq_common_1 = require("redis-smq-common");
-const schedule_message_1 = require("../lib/broker/schedule-message");
+const schedule_message_1 = require("../lib/producer/schedule-message");
 class DelayWorker extends redis_smq_common_1.Worker {
     constructor(redisClient, managed) {
         super(managed);

package/dist/src/workers/{heartbeat-monitor.worker.d.ts → watchdog.worker.d.ts}

@@ -1,10 +1,11 @@
 import { RedisClient, Worker } from 'redis-smq-common';
-import { ICallback } from 'redis-smq-common/dist/types';
+import { ICallback, ICompatibleLogger } from 'redis-smq-common/dist/types';
 import { IRequiredConfig } from '../../types';
-export declare class HeartbeatMonitorWorker extends Worker {
+export declare class WatchdogWorker extends Worker {
     protected redisClient: RedisClient;
     protected config: IRequiredConfig;
-    constructor(redisClient: RedisClient, config: IRequiredConfig, managed: boolean);
+    protected logger: ICompatibleLogger;
+    constructor(redisClient: RedisClient, config: IRequiredConfig, managed: boolean, logger: ICompatibleLogger);
     work: (cb: ICallback<void>) => void;
 }
-export default HeartbeatMonitorWorker;
+export default WatchdogWorker;

package/dist/src/workers/watchdog.worker.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchdogWorker = void 0;
+const consumer_heartbeat_1 = require("../lib/consumer/consumer-heartbeat");
+const redis_smq_common_1 = require("redis-smq-common");
+const consumer_queues_1 = require("../lib/consumer/consumer-queues");
+const message_handler_1 = require("../lib/consumer/consumer-message-handler/message-handler");
+const retry_message_1 = require("../lib/consumer/consumer-message-handler/retry-message");
+class WatchdogWorker extends redis_smq_common_1.Worker {
+    constructor(redisClient, config, managed, logger) {
+        super(managed);
+        this.work = (cb) => {
+            consumer_heartbeat_1.ConsumerHeartbeat.getExpiredHeartbeatIds(this.redisClient, (err, reply) => {
+                if (err)
+                    cb(err);
+                else {
+                    const ids = reply !== null && reply !== void 0 ? reply : [];
+                    if (ids.length) {
+                        const statuses = [];
+                        const multi = this.redisClient.multi();
+                        redis_smq_common_1.async.each(ids, (consumerId, key, callback) => {
+                            consumer_heartbeat_1.ConsumerHeartbeat.handleExpiredHeartbeatId(consumerId, multi);
+                            consumer_queues_1.consumerQueues.getConsumerQueues(this.redisClient, consumerId, (err, reply) => {
+                                if (err)
+                                    callback(err);
+                                else {
+                                    const queues = reply !== null && reply !== void 0 ? reply : [];
+                                    redis_smq_common_1.async.each(queues, (queue, _, done) => {
+                                        message_handler_1.MessageHandler.cleanUp(this.config, this.redisClient, consumerId, queue, multi, (err, reply) => {
+                                            if (err)
+                                                done(err);
+                                            else {
+                                                statuses.push(reply !== null && reply !== void 0 ? reply : false);
+                                                done();
+                                            }
+                                        });
+                                    }, callback);
+                                }
+                            });
+                        }, (err) => {
+                            if (err)
+                                cb(err);
+                            else {
+                                multi.exec((err) => {
+                                    if (err)
+                                        cb(err);
+                                    else {
+                                        statuses.forEach((cleanUpStatus) => {
+                                            if (cleanUpStatus) {
+                                                this.logger.debug(`Message ID ${cleanUpStatus.message.getId()} has been ${cleanUpStatus.status ===
+                                                    retry_message_1.ERetryStatus.MESSAGE_DEAD_LETTERED
+                                                    ? 'dead-lettered'
+                                                    : 'unacknowledged'}.`);
+                                            }
+                                        });
+                                        cb();
+                                    }
+                                });
+                            }
+                        });
+                    }
+                    else
+                        cb();
+                }
+            });
+        };
+        this.redisClient = redisClient;
+        this.config = config;
+        this.logger = logger;
+    }
+}
+exports.WatchdogWorker = WatchdogWorker;
+exports.default = WatchdogWorker;
+//# sourceMappingURL=watchdog.worker.js.map

package/dist/types/index.d.ts

@@ -56,9 +56,9 @@ export declare enum EMessageDeadLetterCause {
 }
 export declare enum EMessageUnacknowledgedCause {
     TIMEOUT = "timeout",
-    CAUGHT_ERROR = "caught_error",
+    CONSUME_ERROR = "consumer_error",
     UNACKNOWLEDGED = "unacknowledged",
-    RECOVERY = "recovery",
+    OFFLINE_CONSUMER = "offline_consumer",
     TTL_EXPIRED = "ttl_expired"
 }
 export declare type TQueueParams = {

package/dist/types/index.js

@@ -10,9 +10,9 @@ var EMessageDeadLetterCause;
 var EMessageUnacknowledgedCause;
 (function (EMessageUnacknowledgedCause) {
     EMessageUnacknowledgedCause["TIMEOUT"] = "timeout";
-    EMessageUnacknowledgedCause["CAUGHT_ERROR"] = "caught_error";
+    EMessageUnacknowledgedCause["CONSUME_ERROR"] = "consumer_error";
     EMessageUnacknowledgedCause["UNACKNOWLEDGED"] = "unacknowledged";
-    EMessageUnacknowledgedCause["RECOVERY"] = "recovery";
+    EMessageUnacknowledgedCause["OFFLINE_CONSUMER"] = "offline_consumer";
     EMessageUnacknowledgedCause["TTL_EXPIRED"] = "ttl_expired";
 })(EMessageUnacknowledgedCause = exports.EMessageUnacknowledgedCause || (exports.EMessageUnacknowledgedCause = {}));
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redis-smq",
-  "version": "7.0.0-rc.4",
+  "version": "7.0.0-rc.7",
   "description": "A simple high-performance Redis message queue for Node.js.",
   "author": "Weyoss <weyoss@protonmail.com>",
   "license": "MIT",
@@ -36,7 +36,7 @@
     "bluebird": "3.7.2",
     "cron-parser": "3.5.0",
     "lodash": "4.17.21",
-    "redis-smq-common": "1.0.0-rc.8",
+    "redis-smq-common": "1.0.0-rc.11",
     "uuid": "8.3.2"
   },
   "devDependencies": {

package/dist/src/lib/broker/retry-message.d.ts

@@ -1,6 +0,0 @@
-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 retryMessage(config: IRequiredConfig, mixed: IRedisClientMulti, processingQueue: string, message: Message, unacknowledgedCause: EMessageUnacknowledgedCause): EMessageDeadLetterCause | void;
-export declare function retryMessage(config: IRequiredConfig, mixed: RedisClient, processingQueue: string, message: Message, unacknowledgedCause: EMessageUnacknowledgedCause, cb: ICallback<EMessageDeadLetterCause | void>): void;

package/dist/src/lib/consumer/offline-consumers.d.ts

@@ -1,4 +0,0 @@
-import { IRequiredConfig } from '../../../types';
-import { ICallback, IRedisClientMulti } from 'redis-smq-common/dist/types';
-import { RedisClient } from 'redis-smq-common';
-export declare function handleOfflineConsumer(config: IRequiredConfig, multi: IRedisClientMulti, redisClient: RedisClient, consumerId: string, cb: ICallback<void>): void;

package/dist/src/lib/consumer/offline-consumers.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleOfflineConsumer = void 0;
-const redis_smq_common_1 = require("redis-smq-common");
-const consumer_queues_1 = require("./consumer-queues");
-const message_handler_1 = require("./consumer-message-handler/message-handler");
-function handleOfflineConsumer(config, multi, redisClient, consumerId, cb) {
-    redis_smq_common_1.async.waterfall([
-        (cb) => consumer_queues_1.consumerQueues.getConsumerQueues(redisClient, consumerId, cb),
-        (queues, cb) => {
-            redis_smq_common_1.async.each(queues, (queue, _, done) => {
-                message_handler_1.MessageHandler.cleanUp(config, redisClient, consumerId, queue, multi, done);
-            }, cb);
-        },
-    ], cb);
-}
-exports.handleOfflineConsumer = handleOfflineConsumer;
-//# sourceMappingURL=offline-consumers.js.map

package/dist/src/workers/heartbeat-monitor.worker.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HeartbeatMonitorWorker = void 0;
-const consumer_heartbeat_1 = require("../lib/consumer/consumer-heartbeat");
-const redis_smq_common_1 = require("redis-smq-common");
-class HeartbeatMonitorWorker extends redis_smq_common_1.Worker {
-    constructor(redisClient, config, managed) {
-        super(managed);
-        this.work = (cb) => {
-            redis_smq_common_1.async.waterfall([
-                (cb) => consumer_heartbeat_1.ConsumerHeartbeat.getExpiredHeartbeatIds(this.redisClient, cb),
-                (consumerIds, cb) => {
-                    consumer_heartbeat_1.ConsumerHeartbeat.handleExpiredHeartbeatIds(this.config, this.redisClient, consumerIds, cb);
-                },
-            ], cb);
-        };
-        this.redisClient = redisClient;
-        this.config = config;
-    }
-}
-exports.HeartbeatMonitorWorker = HeartbeatMonitorWorker;
-exports.default = HeartbeatMonitorWorker;
-//# sourceMappingURL=heartbeat-monitor.worker.js.map