redis-smq 3.0.3 → 3.2.0

package/CHANGELOG.md

@@ -1,9 +1,29 @@
 # CHANGELOG
 
-## 3.0.3 (2021-09-08)
+## 3.2.0 (2021-10-01)
+
+- Run tests in Node.js v12, v14, and v16
+- Run tests in Redis v2.6.17, v3, v4, v5, and v6
+- Made redis-smq-monitor server an integral part of redis-smq
+- Implemented Scheduler HTTP API endpoints
+- Various fixes and improvements
+
+## 3.1.1 (2021-09-16)
+
+* Added Github CI
+
+## 3.1.0 (2021-09-15)
 
-* Fixed .npmignore
+* Added Scheduler API docs.
+* Added new methods to fetch and delete scheduled messages.
+
+## 3.0.4 (2021-09-08)
+
+* Updated examples.
+
+## 3.0.3 (2021-09-08)
 
+* Fixed .npmignore.
 
 ## 3.0.2 (2021-09-08)
 
@@ -15,10 +35,11 @@
 
 ## 3.0.0 (2021-09-08)
 
-* A major release v3.0.0 is out.
+* A major release v3 is out.
+* Starting from this release, only active LTS and maintenance LTS Node.js releases are supported. 
 * Upgrading your installation to the newest version should be straightforward as most APIs are compatible with some exceptions.
-* Project codebase has been migrated to TypeScript to make use of strong typings.
-* JavaScript's users are always first class citizens and backward compatibility with old NodeJS versions has been kept, down to v7.0.0.
+* Project codebase has been migrated to TypeScript to make use of strong typings. 
+* JavaScript's users are always first class citizens.
 * Fixed a compatibility issue between ioredis and redis when calling multi.exec().
 * Fixed typing inconsistencies (ConfigRedisDriver and RedisDriver types) between redis-smq and redis-smq-monitor.
 * Improved scheduler mechanics, refactored GC, and updated tests.

package/README.md

@@ -1,5 +1,12 @@
 # RedisSMQ - Yet another simple Redis message queue
 
+[![Tests](https://github.com/weyoss/redis-smq/actions/workflows/tests.yml/badge.svg)](https://github.com/weyoss/redis-smq/actions/workflows/tests.yml)
+[![Coverage Status](https://img.shields.io/coveralls/github/weyoss/redis-smq.svg)](https://coveralls.io/r/weyoss/redis-smq?branch=master)
+[![Dependencies Status](https://img.shields.io/david/weyoss/redis-smq.svg)]((https://david-dm.org/weyoss/redis-smq))
+[![NPM version](http://img.shields.io/npm/v/redis-smq.svg)](https://npmjs.org/package/redis-smq)
+[![NPM downloads](https://img.shields.io/npm/dm/redis-smq.svg)](https://npmjs.org/package/redis-smq)
+[![Code quality](https://img.shields.io/lgtm/grade/javascript/github/weyoss/redis-smq.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/weyoss/redis-smq/context:javascript)
+
 A simple high-performance Redis message queue for Node.js.
 
 For more details about RedisSMQ design see [https://medium.com/@weyoss/building-a-simple-message-queue-using-redis-server-and-node-js-964eda240a2a](https://medium.com/@weyoss/building-a-simple-message-queue-using-redis-server-and-node-js-964eda240a2a)
@@ -35,6 +42,7 @@ For more details about RedisSMQ design see [https://medium.com/@weyoss/building-
     1. [Message Class](#message-class)
     2. [Producer Class](#producer-class)
     3. [Consumer Class](#consumer-class)
+    4. [Message Scheduler](#message-scheduler)
 5. [Performance](#performance)
     1. [Scenarios](#scenarios)
     2. [Environment](#environment)
@@ -49,10 +57,10 @@ For more details about RedisSMQ design see [https://medium.com/@weyoss/building-
 
 **2021.09.08**
 
-- A major release v3.0.0 is out. 
+- A major release v3 is out. 
 - Upgrading your installation to the newest version should be straightforward as most APIs are compatible, [with some exceptions](docs/migrating-from-v2-to-v3.md).
 - The project's code base has been migrated to TypeScript to make use of strong typings. 
-- JavaScript's users are always first class citizens and backward compatibility with old NodeJS versions has been kept, down to v7.0.0
+- JavaScript's users are always first class citizens.
 
 See [CHANGELOG](CHANGELOG.md) for more details.
 
@@ -64,8 +72,8 @@ npm install redis-smq --save
 
 Considerations:
 
-- Minimal Node.js version support is 7.0.0 (with --harmony flag), 7.6.0 (without --harmony flag). The latest stable 
-  Node.js version is recommended.
+- RedisSMQ is targeted to be used in production environments. Therefore, only active LTS and maintenance LTS Node.js 
+  releases (v12, v14, and v16) are supported. The latest stable Node.js version is recommended.
 - Minimal Redis server version is 2.6.12.
 
 # Configuration
@@ -133,11 +141,11 @@ module.exports = {
 
 - `monitor` *(Object): Optional.* RedisSMQ monitor parameters.
 
-- `monitor.enabled` *(Boolean/Integer): Optional.* Enable/Disable the monitor. By default disabled.
+- `monitor.enabled` *(Boolean/Integer): Optional.* Enable/Disable the monitor. By default, disabled.
 
-- `monitor.host` *(String): Optional.* IP address of the monitor server. By default `0.0.0.0`.
+- `monitor.host` *(String): Optional.* IP address of the monitor server. By default, `0.0.0.0`.
 
-- `monitor.port` *(Integer): Optional.* Port of the monitor server. By default `7210`.
+- `monitor.port` *(Integer): Optional.* Port of the monitor server. By default, `7210`.
 
 ## Usage
 
@@ -149,11 +157,8 @@ Message class is the main component responsible for creating and handling messag
 the required methods needed to construct and deal with messages.
 
 ```javascript
-
 const { Message } = require('redis-smq');
-
 const message = new Message();
-
 message
     .setBody({hello: 'world'})
     .setTTL(3600000)
@@ -176,7 +181,7 @@ Each producer instance has an associated message queue and provides `produceMess
 message and decides to either send it to the message queue scheduler or to immediately enqueue it for delivery.
 
 ```javascript
-// filename: ./example/test-queue-producer.js
+// filename: ./examples/javascript/ns1-test-queue-producer.js
 
 'use strict';
 const { Message, Producer } = require('redis-smq');
@@ -185,8 +190,7 @@ const message = new Message();
 
 message
     .setBody({hello: 'world'})
-    .setTTL(3600000)
-    .setScheduledDelay(10);
+    .setTTL(3600000);
 
 const producer = new Producer('test_queue');
 producer.produceMessage(message, (err) => {
@@ -207,8 +211,7 @@ Consumer classes are saved per files. Each consumer file represents a consumer c
 A consumer class may look like:
 
 ```javascript
-// filename: ./example/test-queue-consumer.js
-
+// filename: ./examples/javascript/ns1-test-queue-consumer.js
 'use strict';
 
 const { Consumer } = require('redis-smq');
@@ -242,7 +245,7 @@ To start consuming messages, a consumer needs first to be launched from CLI to c
 and wait for messages: 
 
 ```text
-$ node ./example/test-queue-consumer.js
+$ node ./examples/javascript/test-queue-consumer.js
 ```
 
 Once a message is received and processed the consumer should acknowledge the message by invoking the callback function
@@ -257,6 +260,67 @@ corresponding queue called dead-letter queue where all failed to consume message
 
 See [Consumer API Reference](docs/api/consumer.md) for more details.
 
+### Message Scheduler
+
+Message Scheduler enables you to schedule a one-time or repeating messages in your MQ server.
+
+The [Message API](docs/api/message.md) provides many methods:
+
+- [setScheduledPeriod()](docs/api/message.md#messageprototypesetscheduledperiod) 
+- [setScheduledDelay()](docs/api/message.md#messageprototypesetscheduleddelay) 
+- [setScheduledCron()](docs/api/message.md#messageprototypesetscheduledcron)
+- [setScheduledRepeat()](docs/api/message.md#messageprototypesetscheduledrepeat)
+
+in order to set up scheduling parameters for a specific message. Once your message is ready, you can use 
+[producer.produceMessage()](docs/api/producer.md#producerprototypeproducemessage) to publish it. 
+
+Under the hood, the `producer` invokes `isSchedulable()` and `schedule()`  of the [Scheduler class](docs/api/scheduler.md) 
+to place your message in the delay queue.
+
+```javascript
+'use strict';
+const { Message, Producer } = require('redis-smq');
+
+const producer = new Producer('test_queue');
+
+const message = new Message();
+message
+    .setBody({hello: 'world'})
+    .setScheduledCron(`0 0 * * * *`);
+
+producer.produceMessage(message, (err) => {
+    if (err) console.log(err);
+    else console.log('Message has been succefully produced');
+})
+```
+
+Alternatively, you can also manually get the scheduler instance from the producer using `producer.getScheduler()` 
+and call the `schedule()` method as shown in the example bellow:
+
+```javascript
+'use strict';
+const { Message, Producer } = require('redis-smq');
+
+const producer = new Producer('test_queue');
+
+producer.getScheduler((err, scheduler) => {
+    if (err) console.log(err);
+    else {
+        const message = new Message();
+        message
+            .setBody({hello: 'world'})
+            .setScheduledCron(`0 0 * * * *`);
+        scheduler.schedule(message, (err, reply) => {
+            if (err) console.log(err);
+            else if (rely) console.log('Message has been succefully scheduled');
+            else console.log('Message has not been scheduled');
+        });
+    }
+})
+```
+
+See [Scheduler API Reference](docs/api/scheduler.md) for more details.
+
 ## Performance
 
 One key indicator about how RedisSMQ is fast and performant is Message throughput. Message throughput is the number of
@@ -315,23 +379,24 @@ $ node consumer | ./node_modules/.bin/bunyan
 ```
 ### Monitoring
 
-The RedisSMQ Monitor is an interface which let you monitor and debug your RedisSMQ server from a web browser in 
+The RedisSMQ Monitor is an interface which let you monitor, debug, and manage your RedisSMQ server from a web browser in 
 real-time.
 
-Starting from version v1.1.0, RedisSMQ Monitor has split up into a standalone project and was packaged under
-[RedisSMQ Monitor](https://github.com/weyoss/redis-smq-monitor)
+Starting from version v1.1.0, the frontend part of the RedisSMQ Monitor has split up into a standalone project and 
+is packaged under [RedisSMQ Monitor](https://github.com/weyoss/redis-smq-monitor)
 
-RedisSMQ includes the monitor as part of its package.
+Being an integral part of the MQ, the monitor can be launched and used by starting first the monitor server as shown 
+in the example bellow:
 
 ```javascript
-// filename: ./example/monitor.js
+// filename: ./examples/javascript/monitor.js
 'use strict';
 
 const config = require('./config');
-const { monitor } = require('redis-smq');
+const { MonitorServer } = require('redis-smq');
 
-monitor(config).listen(() => {
-    console.log('It works!')
+MonitorServer(config).listen(() => {
+    console.log('It works!');
 });
 ```
 ## Contributing

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { Consumer } from './src/consumer';
 export { Producer } from './src/producer';
 export { Message } from './src/message';
-export { MonitorServer } from 'redis-smq-monitor';
+export { MonitorServer } from './src/monitor-server';

package/dist/index.js

@@ -7,6 +7,6 @@ var producer_1 = require("./src/producer");
 Object.defineProperty(exports, "Producer", { enumerable: true, get: function () { return producer_1.Producer; } });
 var message_1 = require("./src/message");
 Object.defineProperty(exports, "Message", { enumerable: true, get: function () { return message_1.Message; } });
-var redis_smq_monitor_1 = require("redis-smq-monitor");
-Object.defineProperty(exports, "MonitorServer", { enumerable: true, get: function () { return redis_smq_monitor_1.MonitorServer; } });
+var monitor_server_1 = require("./src/monitor-server");
+Object.defineProperty(exports, "MonitorServer", { enumerable: true, get: function () { return monitor_server_1.MonitorServer; } });
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":";;;AAAA,2CAA0C;AAAjC,oGAAA,QAAQ,OAAA;AACjB,2CAA0C;AAAjC,oGAAA,QAAQ,OAAA;AACjB,yCAAwC;AAA/B,kGAAA,OAAO,OAAA;AAChB,uDAAkD;AAAzC,kHAAA,aAAa,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":";;;AAAA,2CAA0C;AAAjC,oGAAA,QAAQ,OAAA;AACjB,2CAA0C;AAAjC,oGAAA,QAAQ,OAAA;AACjB,yCAAwC;AAA/B,kGAAA,OAAO,OAAA;AAChB,uDAAqD;AAA5C,+GAAA,aAAa,OAAA"}

package/dist/src/consumer.d.ts

@@ -1,36 +1,34 @@
-import { IConfig, IConsumerConstructorOptions, TCallback } from '../types';
+import { IConfig, IConsumerConstructorOptions, ICallback, TUnaryFunction } from '../types';
 import { Instance } from './instance';
 import { Message } from './message';
 import { ConsumerStatsProvider } from './stats-provider/consumer-stats-provider';
-import { HeartBeat } from './heartbeat';
+import { Heartbeat } from './heartbeat';
 import { GarbageCollector } from './gc';
+import { SchedulerRunner } from './scheduler-runner';
+import { RedisClient } from './redis-client';
 export declare abstract class Consumer extends Instance {
-    protected readonly options: IConsumerConstructorOptions;
-    protected readonly consumerMessageTTL: number;
-    protected readonly consumerMessageConsumeTimeout: number;
-    protected readonly messageRetryThreshold: number;
-    protected readonly messageRetryDelay: number;
+    protected readonly options: Required<IConsumerConstructorOptions>;
+    protected schedulerRunnerInstance: SchedulerRunner | null;
     protected statsProvider: ConsumerStatsProvider | null;
     protected garbageCollectorInstance: GarbageCollector | null;
-    protected heartBeatInstance: ReturnType<typeof HeartBeat> | null;
+    protected heartbeatInstance: Heartbeat | null;
     constructor(queueName: string, config?: IConfig, options?: IConsumerConstructorOptions);
     getConsumerMessageConsumeTimeout(): number;
     getMessageRetryThreshold(): number;
     getConsumerMessageTTL(): number;
     getMessageRetryDelay(): number;
-    getOptions(): IConsumerConstructorOptions;
-    protected getStatsProvider(): ConsumerStatsProvider;
+    getOptions(): Required<IConsumerConstructorOptions>;
+    getStatsProvider(): ConsumerStatsProvider;
     protected getNextMessage(): void;
     protected hasGoneUp(): boolean;
     protected hasGoneDown(): boolean;
     protected registerEventsHandlers(): void;
-    protected setupHeartBeat(): void;
-    protected setupGarbageCollector(): void;
-    protected getGarbageCollectorInstance(): GarbageCollector;
-    protected getHeartBeatInstance(): ReturnType<typeof HeartBeat>;
-    protected setupQueues(): void;
-    protected completeBootstrap(): void;
+    protected getGarbageCollectorInstance(cb: TUnaryFunction<GarbageCollector>): void;
+    protected getHeartBeatInstance(cb: TUnaryFunction<Heartbeat>): void;
+    protected getSchedulerRunnerInstance(cb: TUnaryFunction<SchedulerRunner>): void;
+    protected setupQueues(client: RedisClient, cb: ICallback<void>): void;
+    protected bootstrap(cb: ICallback<void>): void;
     protected handleConsume(msg: Message): void;
     protected handleConsumeFailure(msg: Message, error: Error): void;
-    abstract consume(msg: Message, cb: TCallback<void>): void;
+    abstract consume(msg: Message, cb: ICallback<void>): void;
 }

package/dist/src/consumer.js

@@ -7,32 +7,34 @@ const consumer_stats_provider_1 = require("./stats-provider/consumer-stats-provi
 const events_1 = require("./events");
 const heartbeat_1 = require("./heartbeat");
 const gc_1 = require("./gc");
-const consumer_redis_keys_1 = require("./redis-keys/consumer-redis-keys");
+const scheduler_runner_1 = require("./scheduler-runner");
+const queue_helpers_1 = require("./queue-helpers");
 class Consumer extends instance_1.Instance {
     constructor(queueName, config = {}, options = {}) {
-        var _a, _b, _c, _d;
         super(queueName, config);
+        this.options = {
+            messageTTL: 0,
+            messageConsumeTimeout: 0,
+            messageRetryThreshold: 3,
+            messageRetryDelay: 60,
+        };
+        this.schedulerRunnerInstance = null;
         this.statsProvider = null;
         this.garbageCollectorInstance = null;
-        this.heartBeatInstance = null;
-        this.options = options;
-        this.consumerMessageTTL = +((_a = options.messageTTL) !== null && _a !== void 0 ? _a : 0);
-        this.consumerMessageConsumeTimeout = +((_b = options.messageConsumeTimeout) !== null && _b !== void 0 ? _b : 0);
-        this.messageRetryThreshold = +((_c = options.messageRetryThreshold) !== null && _c !== void 0 ? _c : 3);
-        this.messageRetryDelay = +((_d = options.messageRetryDelay) !== null && _d !== void 0 ? _d : 0);
-        this.redisKeys = new consumer_redis_keys_1.ConsumerRedisKeys(this.getQueueName(), this.getId());
+        this.heartbeatInstance = null;
+        this.options = Object.assign(Object.assign({}, this.options), options);
     }
     getConsumerMessageConsumeTimeout() {
-        return this.consumerMessageConsumeTimeout;
+        return this.options.messageConsumeTimeout;
     }
     getMessageRetryThreshold() {
-        return this.messageRetryThreshold;
+        return this.options.messageRetryThreshold;
     }
     getConsumerMessageTTL() {
-        return this.consumerMessageTTL;
+        return this.options.messageTTL;
     }
     getMessageRetryDelay() {
-        return this.messageRetryDelay;
+        return this.options.messageRetryDelay;
     }
     getOptions() {
         return this.options;
@@ -45,54 +47,59 @@ class Consumer extends instance_1.Instance {
     }
     getNextMessage() {
         this.loggerInstance.info('Waiting for new messages...');
-        const { keyQueue, keyConsumerProcessingQueue } = this.getInstanceRedisKeys();
-        this.getRedisInstance().brpoplpush(keyQueue, keyConsumerProcessingQueue, 0, (err, json) => {
-            if (err)
-                this.error(err);
-            else {
-                if (!json) {
-                    throw new Error(`Expected a non-empty string`);
+        const { keyQueue, keyConsumerProcessingQueue } = this.redisKeys;
+        this.getRedisInstance((client) => {
+            client.brpoplpush(keyQueue, keyConsumerProcessingQueue, 0, (err, json) => {
+                if (err)
+                    this.handleError(err);
+                else if (!json)
+                    this.handleError(new Error('Expected a non empty string'));
+                else {
+                    this.loggerInstance.info('Got new message...');
+                    const message = message_1.Message.createFromMessage(json);
+                    this.emit(events_1.events.MESSAGE_RECEIVED, message);
                 }
-                this.loggerInstance.info('Got new message...');
-                const message = message_1.Message.createFromMessage(json);
-                this.emit(events_1.events.MESSAGE_RECEIVED, message);
-            }
+            });
         });
     }
     hasGoneUp() {
         return (super.hasGoneUp() &&
             this.startupFiredEvents.includes(events_1.events.GC_UP) &&
-            this.startupFiredEvents.includes(events_1.events.HEARTBEAT_UP));
+            this.startupFiredEvents.includes(events_1.events.HEARTBEAT_UP) &&
+            this.startupFiredEvents.includes(events_1.events.SCHEDULER_RUNNER_UP));
     }
     hasGoneDown() {
         return (super.hasGoneDown() &&
             this.shutdownFiredEvents.includes(events_1.events.GC_DOWN) &&
-            this.shutdownFiredEvents.includes(events_1.events.HEARTBEAT_DOWN));
+            this.shutdownFiredEvents.includes(events_1.events.HEARTBEAT_DOWN) &&
+            this.shutdownFiredEvents.includes(events_1.events.SCHEDULER_RUNNER_DOWN));
     }
     registerEventsHandlers() {
         super.registerEventsHandlers();
         this.on(events_1.events.HEARTBEAT_UP, () => this.handleStartupEvent(events_1.events.HEARTBEAT_UP));
-        this.on(events_1.events.HEARTBEAT_DOWN, () => this.handleShutdownEvent(events_1.events.HEARTBEAT_DOWN));
+        this.on(events_1.events.HEARTBEAT_DOWN, () => {
+            this.heartbeatInstance = null;
+            this.handleShutdownEvent(events_1.events.HEARTBEAT_DOWN);
+        });
         this.on(events_1.events.GC_UP, () => this.handleStartupEvent(events_1.events.GC_UP));
-        this.on(events_1.events.GC_DOWN, () => this.handleShutdownEvent(events_1.events.GC_DOWN));
-        this.on(events_1.events.STATS_UP, () => {
-            this.getStatsInstance().startAggregator();
+        this.on(events_1.events.GC_DOWN, () => {
+            this.garbageCollectorInstance = null;
+            this.handleShutdownEvent(events_1.events.GC_DOWN);
         });
-        this.on(events_1.events.SCHEDULER_UP, () => {
-            this.getScheduler().runTicker();
+        this.on(events_1.events.SCHEDULER_RUNNER_UP, () => this.handleStartupEvent(events_1.events.SCHEDULER_RUNNER_UP));
+        this.on(events_1.events.SCHEDULER_RUNNER_DOWN, () => {
+            this.schedulerRunnerInstance = null;
+            this.handleShutdownEvent(events_1.events.SCHEDULER_RUNNER_DOWN);
         });
         this.on(events_1.events.GOING_UP, () => {
-            this.getHeartBeatInstance().start();
-            this.getGarbageCollectorInstance().start();
+            this.getHeartBeatInstance((hb) => hb.start());
+            this.getGarbageCollectorInstance((gc) => gc.start());
+            this.getSchedulerRunnerInstance((sr) => sr.start());
         });
         this.on(events_1.events.GOING_DOWN, () => {
-            this.getHeartBeatInstance().stop();
-            this.getGarbageCollectorInstance().stop();
-        });
-        this.on(events_1.events.DOWN, () => {
-            this.garbageCollectorInstance = null;
-            this.heartBeatInstance = null;
-            this.statsProvider = null;
+            this.getHeartBeatInstance((hb) => hb.stop());
+            this.getGarbageCollectorInstance((gc) => gc.stop());
+            this.getSchedulerRunnerInstance((sr) => sr.stop());
         });
         this.on(events_1.events.UP, () => {
             this.emit(events_1.events.MESSAGE_NEXT);
@@ -103,26 +110,32 @@ class Consumer extends instance_1.Instance {
             }
         });
         this.on(events_1.events.MESSAGE_RECEIVED, (message) => {
-            const messageCollector = this.getGarbageCollectorInstance().getMessageCollector();
             if (this.powerManager.isRunning()) {
-                if (this.statsProvider)
-                    this.statsProvider.incrementProcessingSlot();
-                if (messageCollector.hasMessageExpired(message)) {
-                    this.emit(events_1.events.MESSAGE_EXPIRED, message);
-                }
-                else
-                    this.handleConsume(message);
+                this.getGarbageCollectorInstance((gc) => {
+                    gc.getMessageCollector((messageCollector) => {
+                        if (this.statsProvider)
+                            this.statsProvider.incrementProcessingSlot();
+                        if (messageCollector.hasMessageExpired(message)) {
+                            this.emit(events_1.events.MESSAGE_EXPIRED, message);
+                        }
+                        else
+                            this.handleConsume(message);
+                    });
+                });
             }
         });
         this.on(events_1.events.MESSAGE_EXPIRED, (message) => {
             this.loggerInstance.info(`Message [${message.getId()}] has expired`);
             const { keyConsumerProcessingQueue } = this.getInstanceRedisKeys();
-            const messageCollector = this.getGarbageCollectorInstance().getMessageCollector();
-            messageCollector.collectExpiredMessage(message, keyConsumerProcessingQueue, () => {
-                if (this.statsProvider)
-                    this.statsProvider.incrementAcknowledgedSlot();
-                this.loggerInstance.info(`Message [${message.getId()}] successfully processed`);
-                this.emit(events_1.events.MESSAGE_NEXT);
+            this.getGarbageCollectorInstance((gc) => {
+                gc.getMessageCollector((messageCollector) => {
+                    messageCollector.collectExpiredMessage(message, keyConsumerProcessingQueue, () => {
+                        if (this.statsProvider)
+                            this.statsProvider.incrementAcknowledgedSlot();
+                        this.loggerInstance.info(`Message [${message.getId()}] successfully processed`);
+                        this.emit(events_1.events.MESSAGE_NEXT);
+                    });
+                });
             });
         });
         this.on(events_1.events.MESSAGE_ACKNOWLEDGED, () => {
@@ -134,52 +147,59 @@ class Consumer extends instance_1.Instance {
             if (this.statsProvider)
                 this.statsProvider.incrementUnacknowledgedSlot();
             const keys = this.getInstanceRedisKeys();
-            const messageCollector = this.getGarbageCollectorInstance().getMessageCollector();
-            messageCollector.collectMessage(msg, keys.keyConsumerProcessingQueue, (err) => {
-                if (err)
-                    this.error(err);
-                else
-                    this.emit(events_1.events.MESSAGE_NEXT);
+            this.getGarbageCollectorInstance((gc) => {
+                gc.getMessageCollector((messageCollector) => {
+                    messageCollector.collectMessage(msg, keys.keyConsumerProcessingQueue, (err) => {
+                        if (err)
+                            this.handleError(err);
+                        else
+                            this.emit(events_1.events.MESSAGE_NEXT);
+                    });
+                });
             });
         });
         this.on(events_1.events.MESSAGE_CONSUME_TIMEOUT, (message) => {
             this.handleConsumeFailure(message, new Error(`Consumer timed out after [${this.getConsumerMessageConsumeTimeout()}]`));
         });
     }
-    setupHeartBeat() {
-        this.heartBeatInstance = (0, heartbeat_1.HeartBeat)(this);
+    getGarbageCollectorInstance(cb) {
+        if (!this.garbageCollectorInstance)
+            this.emit(events_1.events.ERROR, new Error(`Expected an instance of GarbageCollector`));
+        else
+            cb(this.garbageCollectorInstance);
     }
-    setupGarbageCollector() {
-        this.garbageCollectorInstance = new gc_1.GarbageCollector(this);
+    getHeartBeatInstance(cb) {
+        if (!this.heartbeatInstance)
+            this.emit(events_1.events.ERROR, new Error(`Expected an instance of HeartBeat`));
+        else
+            cb(this.heartbeatInstance);
     }
-    getGarbageCollectorInstance() {
-        if (!this.garbageCollectorInstance) {
-            throw new Error(`Expected an instance of GarbageCollector`);
-        }
-        return this.garbageCollectorInstance;
+    getSchedulerRunnerInstance(cb) {
+        if (!this.schedulerRunnerInstance)
+            this.emit(events_1.events.ERROR, new Error('Expected instance of SchedulerRunner'));
+        else
+            cb(this.schedulerRunnerInstance);
     }
-    getHeartBeatInstance() {
-        if (!this.heartBeatInstance) {
-            throw new Error(`Expected an instance of HeartBeat`);
-        }
-        return this.heartBeatInstance;
-    }
-    setupQueues() {
-        const { keyConsumerProcessingQueue, keyIndexQueueProcessing, keyIndexQueueQueuesProcessing, } = this.getInstanceRedisKeys();
-        const multi = this.getRedisInstance().multi();
-        multi.hset(keyIndexQueueQueuesProcessing, keyConsumerProcessingQueue, this.getId());
-        multi.sadd(keyIndexQueueProcessing, keyConsumerProcessingQueue);
-        this.getRedisInstance().execMulti(multi, (err) => {
+    setupQueues(client, cb) {
+        super.setupQueues(client, (err) => {
             if (err)
-                this.error(err);
-            else
-                super.setupQueues();
+                cb(err);
+            else {
+                queue_helpers_1.queueHelpers.setupConsumerQueues(client, this.getQueueName(), this.getId(), cb);
+            }
         });
     }
-    completeBootstrap() {
-        this.setupHeartBeat();
-        this.setupGarbageCollector();
-        super.completeBootstrap();
+    bootstrap(cb) {
+        super.bootstrap((err) => {
+            if (err)
+                cb(err);
+            else {
+                this.heartbeatInstance = new heartbeat_1.Heartbeat(this);
+                this.garbageCollectorInstance = new gc_1.GarbageCollector(this);
+                this.schedulerRunnerInstance = new scheduler_runner_1.SchedulerRunner(this);
+                cb();
+            }
+        });
     }
     handleConsume(msg) {
         let isTimeout = false;
@@ -199,13 +219,15 @@ class Consumer extends instance_1.Instance {
                 }, consumeTimeout);
             }
             const acknowledgeMessage = () => {
-                this.getRedisInstance().rpop(keys.keyConsumerProcessingQueue, (err) => {
-                    if (err)
-                        this.error(err);
-                    else {
-                        this.loggerInstance.info(`Message [${msg.getId()}] successfully processed`);
-                        this.emit(events_1.events.MESSAGE_ACKNOWLEDGED, msg);
-                    }
+                this.getRedisInstance((client) => {
+                    client.rpop(keys.keyConsumerProcessingQueue, (err) => {
+                        if (err)
+                            this.handleError(err);
+                        else {
+                            this.loggerInstance.info(`Message [${msg.getId()}] successfully processed`);
+                            this.emit(events_1.events.MESSAGE_ACKNOWLEDGED, msg);
+                        }
+                    });
                 });
             };
             const onConsumed = (err) => {