qdone 2.0.9-alpha → 2.0.11-alpha

package/commonjs/index.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DoNotProcess = exports.requestShutdown = exports.processMessages = exports.enqueueBatch = exports.enqueue = void 0;
+exports.requestShutdown = exports.processMessages = exports.enqueueBatch = exports.enqueue = void 0;
 var enqueue_js_1 = require("./src/enqueue.js");
 Object.defineProperty(exports, "enqueue", { enumerable: true, get: function () { return enqueue_js_1.enqueue; } });
 Object.defineProperty(exports, "enqueueBatch", { enumerable: true, get: function () { return enqueue_js_1.enqueueBatch; } });
 var consumer_js_1 = require("./src/consumer.js");
 Object.defineProperty(exports, "processMessages", { enumerable: true, get: function () { return consumer_js_1.processMessages; } });
 Object.defineProperty(exports, "requestShutdown", { enumerable: true, get: function () { return consumer_js_1.requestShutdown; } });
-Object.defineProperty(exports, "DoNotProcess", { enumerable: true, get: function () { return consumer_js_1.DoNotProcess; } });

package/commonjs/src/consumer.js

@@ -2,21 +2,6 @@
 /**
  * Consumer implementation.
  */
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -57,32 +42,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processMessages = exports.resolveQueues = exports.pollSingleQueue = exports.processMessage = exports.requestShutdown = exports.DoNotProcess = void 0;
+exports.processMessages = exports.getMessages = exports.requestShutdown = void 0;
 var client_sqs_1 = require("@aws-sdk/client-sqs");
 var chalk_1 = __importDefault(require("chalk"));
 var debug_1 = __importDefault(require("debug"));
-var qrlCache_js_1 = require("./qrlCache.js");
-var idleQueues_js_1 = require("./idleQueues.js");
+var systemMonitor_js_1 = require("./scheduler/systemMonitor.js");
+var queueManager_js_1 = require("./scheduler/queueManager.js");
+var jobExecutor_js_1 = require("./scheduler/jobExecutor.js");
 var defaults_js_1 = require("./defaults.js");
 var sqs_js_1 = require("./sqs.js");
-//
-// Throwing an instance of this Error allows the processMessages callback to
-// refuse a message which then gets immediately returned to the queue.
-//
-// This has the side effect of throtting the queue since it stops polling on
-// the queue until the next queue resolution in processMessages.
-//
-// This is useful for implementing schedulers on top of qdone, for example, to
-// look at the queue name and decide whether to take on a new message.
-//
-var DoNotProcess = /** @class */ (function (_super) {
-    __extends(DoNotProcess, _super);
-    function DoNotProcess() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return DoNotProcess;
-}(Error));
-exports.DoNotProcess = DoNotProcess;
 var debug = (0, debug_1.default)('qdone:consumer');
 // Global flag for shutdown request
 var shutdownRequested = false;
@@ -99,421 +67,107 @@ function requestShutdown() {
     debug('requestShutdown done');
 }
 exports.requestShutdown = requestShutdown;
-function processMessage(message, callback, qname, qrl, opt) {
-    return __awaiter(this, void 0, void 0, function () {
-        function extendTimeout() {
-            return __awaiter(this, void 0, void 0, function () {
-                var maxJobRun, jobRunTime, result, err_2;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            debug('extendTimeout');
-                            maxJobRun = 12 * 60 * 60;
-                            jobRunTime = ((new Date()) - jobStart) / 1000;
-                            // Double every time, up to max
-                            visibilityTimeout = Math.min(visibilityTimeout * 2, maxJobRun - jobRunTime, opt.killAfter - jobRunTime);
-                            if (opt.verbose) {
-                                console.error(chalk_1.default.blue('  Ran for ') + jobRunTime +
-                                    chalk_1.default.blue(' seconds, requesting another ') + visibilityTimeout +
-                                    chalk_1.default.blue(' seconds'));
-                            }
-                            _a.label = 1;
-                        case 1:
-                            _a.trys.push([1, 3, , 4]);
-                            return [4 /*yield*/, (0, sqs_js_1.getSQSClient)().send(new client_sqs_1.ChangeMessageVisibilityCommand({
-                                    QueueUrl: qrl,
-                                    ReceiptHandle: message.ReceiptHandle,
-                                    VisibilityTimeout: visibilityTimeout
-                                }))];
-                        case 2:
-                            result = _a.sent();
-                            debug('ChangeMessageVisibility returned', result);
-                            if (jobRunTime + visibilityTimeout >= maxJobRun ||
-                                jobRunTime + visibilityTimeout >= opt.killAfter) {
-                                if (opt.verbose)
-                                    console.error(chalk_1.default.yellow('  warning: this is our last time extension'));
-                            }
-                            else {
-                                // Extend when we get 50% of the way to timeout
-                                timeoutExtender = setTimeout(extendTimeout, visibilityTimeout * 1000 * 0.5);
-                            }
-                            return [3 /*break*/, 4];
-                        case 3:
-                            err_2 = _a.sent();
-                            debug('ChangeMessageVisibility threw', err_2);
-                            // Rejection means we're ouuta time, whatever, let the job die
-                            if (opt.verbose) {
-                                console.error(chalk_1.default.red('  failed to extend job: ') + err_2);
-                            }
-                            else if (!opt.disableLog) {
-                                // Production error logging
-                                console.log(JSON.stringify({
-                                    event: 'MESSAGE_PROCESSING_FAILED',
-                                    reason: 'ran longer than --kill-after',
-                                    timestamp: new Date(),
-                                    messageId: message.MessageId,
-                                    payload: payload,
-                                    errorMessage: err_2.toString().split('\n').slice(1).join('\n').trim() || undefined,
-                                    err: err_2
-                                }));
-                            }
-                            return [3 /*break*/, 4];
-                        case 4: return [2 /*return*/];
-                    }
-                });
-            });
-        }
-        var payload, jobStart, visibilityTimeout, timeoutExtender, queue, result, err_1, result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    debug('processMessage', message, qname, qrl);
-                    payload = opt.json ? JSON.parse(message.Body) : message.Body;
-                    if (opt.verbose) {
-                        console.error(chalk_1.default.blue('  Processing payload:'), payload);
-                    }
-                    else if (!opt.disableLog) {
-                        console.log(JSON.stringify({
-                            event: 'MESSAGE_PROCESSING_START',
-                            timestamp: new Date(),
-                            messageId: message.MessageId,
-                            payload: payload
-                        }));
-                    }
-                    jobStart = new Date();
-                    visibilityTimeout = 30 // this should be the queue timeout
-                    ;
-                    // Extend when we get 50% of the way to timeout
-                    timeoutExtender = setTimeout(extendTimeout, visibilityTimeout * 1000 * 0.5);
-                    debug('timeout', visibilityTimeout * 1000 * 0.5);
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 4, , 7]);
-                    queue = qname.slice(opt.prefix.length);
-                    return [4 /*yield*/, callback(queue, payload)];
-                case 2:
-                    result = _a.sent();
-                    debug('processMessage callback finished', { payload: payload, result: result });
-                    clearTimeout(timeoutExtender);
-                    if (opt.verbose) {
-                        console.error(chalk_1.default.green('  SUCCESS'));
-                        console.error(chalk_1.default.blue('  cleaning up (removing message) ...'));
-                    }
-                    return [4 /*yield*/, (0, sqs_js_1.getSQSClient)().send(new client_sqs_1.DeleteMessageCommand({
-                            QueueUrl: qrl,
-                            ReceiptHandle: message.ReceiptHandle
-                        }))];
-                case 3:
-                    _a.sent();
-                    if (opt.verbose) {
-                        console.error(chalk_1.default.blue('  done'));
-                        console.error();
-                    }
-                    else if (!opt.disableLog) {
-                        console.log(JSON.stringify({
-                            event: 'MESSAGE_PROCESSING_COMPLETE',
-                            timestamp: new Date(),
-                            messageId: message.MessageId,
-                            payload: payload
-                        }));
-                    }
-                    return [2 /*return*/, { noJobs: 0, jobsSucceeded: 1, jobsFailed: 0 }];
-                case 4:
-                    err_1 = _a.sent();
-                    debug('exec.catch');
-                    clearTimeout(timeoutExtender);
-                    if (!(err_1 instanceof DoNotProcess)) return [3 /*break*/, 6];
-                    if (opt.verbose) {
-                        console.error(chalk_1.default.blue('  callback ') + chalk_1.default.yellow('REFUSED'));
-                        console.error(chalk_1.default.blue('  cleaning up (removing message) ...'));
-                    }
-                    return [4 /*yield*/, (0, sqs_js_1.getSQSClient)().send(new client_sqs_1.ChangeMessageVisibilityCommand({
-                            QueueUrl: qrl,
-                            ReceiptHandle: message.ReceiptHandle,
-                            VisibilityTimeout: 0
-                        }))];
-                case 5:
-                    result = _a.sent();
-                    debug('ChangeMessageVisibility returned', result);
-                    return [2 /*return*/, { noJobs: 1, jobsSucceeded: 0, jobsFailed: 0 }];
-                case 6:
-                    // Fail path for job execution
-                    if (opt.verbose) {
-                        console.error(chalk_1.default.red('  FAILED'));
-                        console.error(chalk_1.default.blue('  error : ') + err_1);
-                    }
-                    else if (!opt.disableLog) {
-                        // Production error logging
-                        console.log(JSON.stringify({
-                            event: 'MESSAGE_PROCESSING_FAILED',
-                            reason: 'exception thrown',
-                            timestamp: new Date(),
-                            messageId: message.MessageId,
-                            payload: payload,
-                            errorMessage: err_1.toString().split('\n').slice(1).join('\n').trim() || undefined,
-                            err: err_1
-                        }));
-                    }
-                    return [2 /*return*/, { noJobs: 0, jobsSucceeded: 0, jobsFailed: 1 }];
-                case 7: return [2 /*return*/];
-            }
-        });
-    });
-}
-exports.processMessage = processMessage;
-//
-// Pull work off of a single queue
-//
-function pollSingleQueue(qname, qrl, callback, opt) {
+function getMessages(qrl, opt, maxMessages) {
     return __awaiter(this, void 0, void 0, function () {
-        var params, response, message;
+        var params, response;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    debug('pollSingleQueue', { qname: qname, qrl: qrl, callback: callback, opt: opt });
                     params = {
                         AttributeNames: ['All'],
-                        MaxNumberOfMessages: 1,
+                        MaxNumberOfMessages: maxMessages,
                         MessageAttributeNames: ['All'],
                         QueueUrl: qrl,
                         VisibilityTimeout: 30,
                         WaitTimeSeconds: opt.waitTime
                     };
-                    return [4 /*yield*/, (0, sqs_js_1.getSQSClient)().send(new client_sqs_1.ReceiveMessageCommand(params))];
-                case 1:
-                    response = _a.sent();
-                    debug('ReceiveMessage response', response);
-                    if (shutdownRequested)
-                        return [2 /*return*/, { noJobs: 0, jobsSucceeded: 0, jobsFailed: 0 }];
-                    if (response.Messages) {
-                        message = response.Messages[0];
-                        if (opt.verbose)
-                            console.error(chalk_1.default.blue('  Found message ' + message.MessageId));
-                        return [2 /*return*/, processMessage(message, callback, qname, qrl, opt)];
-                    }
-                    else {
-                        return [2 /*return*/, { noJobs: 1, jobsSucceeded: 0, jobsFailed: 0 }];
-                    }
-                    return [2 /*return*/];
-            }
-        });
-    });
-}
-exports.pollSingleQueue = pollSingleQueue;
-//
-// Resolve a set of queues
-//
-function resolveQueues(queues, opt) {
-    return __awaiter(this, void 0, void 0, function () {
-        var qnames, pairs, activePairs, selectedPairs;
-        var _this = this;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    // Start processing
-                    if (opt.verbose)
-                        console.error(chalk_1.default.blue('Resolving queues: ') + queues.join(' '));
-                    qnames = queues.map(function (queue) { return (0, qrlCache_js_1.normalizeQueueName)(queue, opt); });
-                    return [4 /*yield*/, (0, qrlCache_js_1.getQnameUrlPairs)(qnames, opt)
-                        // Figure out which pairs are active
+                    return [4 /*yield*/, (0, sqs_js_1.getSQSClient)().send(new client_sqs_1.ReceiveMessageCommand(params))
+                        // debug('ReceiveMessage response', response)
                     ];
                 case 1:
-                    pairs = _a.sent();
-                    activePairs = [];
-                    if (!opt.activeOnly) return [3 /*break*/, 3];
-                    debug({ pairsBeforeCheck: pairs });
-                    return [4 /*yield*/, Promise.all(pairs.map(function (pair) { return __awaiter(_this, void 0, void 0, function () {
-                            var idle;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, (0, idleQueues_js_1.cheapIdleCheck)(pair.qname, pair.qrl, opt)];
-                                    case 1:
-                                        idle = (_a.sent()).idle;
-                                        if (!idle)
-                                            activePairs.push(pair);
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); }))];
-                case 2:
-                    _a.sent();
-                    _a.label = 3;
-                case 3:
-                    // Finished resolving
-                    debug('getQnameUrlPairs.then');
-                    if (opt.verbose) {
-                        console.error(chalk_1.default.blue('  done'));
-                        console.error();
-                    }
-                    selectedPairs = (opt.activeOnly ? activePairs : pairs)
-                        .filter(function (_a) {
-                        var qname = _a.qname;
-                        var suf = opt.failSuffix + (opt.fifo ? '.fifo' : '');
-                        var isFailQueue = qname.slice(-suf.length) === suf;
-                        var shouldInclude = opt.includeFailed ? true : !isFailQueue;
-                        return shouldInclude;
-                    });
-                    return [2 /*return*/, selectedPairs];
+                    response = _a.sent();
+                    // debug('ReceiveMessage response', response)
+                    return [2 /*return*/, response.Messages || []];
             }
         });
     });
 }
-exports.resolveQueues = resolveQueues;
+exports.getMessages = getMessages;
 //
 // Consumer
 //
 function processMessages(queues, callback, options) {
     return __awaiter(this, void 0, void 0, function () {
-        // Callback to help facilitate better UX at shutdown
-        function shutdownCallback() {
-            if (opt.verbose) {
-                debug({ activeLoops: activeLoops, completedLoops: completedLoops });
-                if (activeLoops.length) {
-                    console.error(chalk_1.default.blue('Waiting for work to finish on the following queues: '));
-                    for (var _i = 0, activeLoops_2 = activeLoops; _i < activeLoops_2.length; _i++) {
-                        var _a = activeLoops_2[_i], id = _a[0], _b = _a[1], qname = _b.qname, qrl = _b.qrl, promise = _b.promise;
-                        console.error('    ' + qname + "job ".concat(id));
-                    }
-                }
-                // clearTimeout(delayTimeout)
-            }
-        }
-        // Listen to a queue until it is out of messages
-        function listenLoop(qname, qrl, loopId) {
-            return __awaiter(this, void 0, void 0, function () {
-                var _a, noJobs, jobsSucceeded, jobsFailed, err_3;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
-                        case 0:
-                            _b.trys.push([0, 2, 3, 4]);
-                            if (shutdownRequested)
-                                return [2 /*return*/];
-                            if (opt.verbose) {
-                                console.error(chalk_1.default.blue('Looking for work on ') +
-                                    qname.slice(opt.prefix.length) +
-                                    chalk_1.default.blue(' (' + qrl + ')'));
-                            }
-                            return [4 /*yield*/, pollSingleQueue(qname, qrl, callback, opt)];
-                        case 1:
-                            _a = _b.sent(), noJobs = _a.noJobs, jobsSucceeded = _a.jobsSucceeded, jobsFailed = _a.jobsFailed;
-                            debug('pollSingleQueue return');
-                            stats.noJobs += noJobs;
-                            stats.jobsFailed += jobsFailed;
-                            stats.jobsSucceeded += jobsSucceeded;
-                            debug({ stats: stats, noJobs: noJobs });
-                            // No work? Shutdown requested? Return to outer loop
-                            debug({ noJobs: noJobs, shutdownRequested: shutdownRequested });
-                            if (noJobs || shutdownRequested)
-                                return [2 /*return*/];
-                            // Otherwise keep going
-                            return [2 /*return*/, listenLoop(qname, qrl)];
-                        case 2:
-                            err_3 = _b.sent();
-                            // TODO: Sentry
-                            console.error(chalk_1.default.red('  ERROR in listenLoop'));
-                            console.error(chalk_1.default.blue('  error : ') + err_3);
-                            return [3 /*break*/, 4];
-                        case 3:
-                            completedLoops.set(loopId, activeLoops.get(loopId));
-                            return [7 /*endfinally*/];
-                        case 4: return [2 /*return*/];
-                    }
-                });
-            });
-        }
-        var opt, loopCounter, stats, maxActiveLoops, activeLoops, completedLoops, delayTimeout, delay, start, selectedPairs, _i, selectedPairs_1, _a, qname, qrl, loopId, msSoFar, msUntilNextResolve, _b, completedLoops_1, _c, id, _d, qname, qrl, promise, _e, activeLoops_1, _f, id, _g, qname, qrl, promise;
-        return __generator(this, function (_h) {
-            switch (_h.label) {
+        var opt, systemMonitor, jobExecutor, queueManager, maxActiveJobs, delayTimeout, delay, activeQrls, maxReturnCount, listen, allowedJobs, maxLatency, latency, latencyFactor, targetJobs, jobsLeft, _i, _a, _b, qname, qrl, maxMessages;
+        var _this = this;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
                 case 0:
                     opt = (0, defaults_js_1.getOptionsWithDefaults)(options);
                     debug('processMessages', { queues: queues, callback: callback, options: options, opt: opt });
-                    loopCounter = 0;
-                    stats = { noJobs: 0, jobsSucceeded: 0, jobsFailed: 0 };
-                    maxActiveLoops = 10;
-                    activeLoops = new Map();
-                    completedLoops = new Map();
+                    systemMonitor = new systemMonitor_js_1.SystemMonitor(opt);
+                    jobExecutor = new jobExecutor_js_1.JobExecutor(opt);
+                    queueManager = new queueManager_js_1.QueueManager(opt, queues);
+                    maxActiveJobs = 100;
+                    debug({ systemMonitor: systemMonitor, jobExecutor: jobExecutor, queueManager: queueManager });
+                    shutdownCallbacks.push(function () {
+                        systemMonitor.shutdown();
+                        queueManager.shutdown();
+                        jobExecutor.shutdown();
+                    });
                     delay = function (ms) { return new Promise(function (resolve) {
                         delayTimeout = setTimeout(resolve, ms);
                     }); };
-                    shutdownCallbacks.push(shutdownCallback);
-                    _h.label = 1;
+                    activeQrls = new Set();
+                    maxReturnCount = 0;
+                    listen = function (qname, qrl, maxMessages) { return __awaiter(_this, void 0, void 0, function () {
+                        var messages, _i, messages_1, message;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    activeQrls.add(qrl);
+                                    maxReturnCount += maxMessages;
+                                    return [4 /*yield*/, getMessages(qrl, opt, maxMessages)];
+                                case 1:
+                                    messages = _a.sent();
+                                    for (_i = 0, messages_1 = messages; _i < messages_1.length; _i++) {
+                                        message = messages_1[_i];
+                                        jobExecutor.executeJob(message, callback, qname, qrl);
+                                    }
+                                    maxReturnCount -= maxMessages;
+                                    activeQrls.delete(qrl);
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); };
+                    _c.label = 1;
                 case 1:
-                    if (!!shutdownRequested) return [3 /*break*/, 9];
-                    start = new Date();
-                    return [4 /*yield*/, resolveQueues(queues, opt)];
-                case 2:
-                    selectedPairs = _h.sent();
-                    debug({ selectedPairs: selectedPairs });
-                    if (shutdownRequested)
-                        return [3 /*break*/, 9];
-                    // But only if we have queues to listen on
-                    if (selectedPairs.length) {
-                        // Randomize order
-                        selectedPairs.sort(function () { return 0.5 - Math.random(); });
+                    if (!!shutdownRequested) return [3 /*break*/, 3];
+                    allowedJobs = maxActiveJobs - jobExecutor.activeJobCount() - maxReturnCount;
+                    maxLatency = 100;
+                    latency = systemMonitor.getLatency().setTimeout;
+                    latencyFactor = 1 - Math.abs(Math.min(latency / maxLatency, 1)) // 0 if latency is at max, 1 if latency 0
+                    ;
+                    targetJobs = Math.round(allowedJobs * latencyFactor);
+                    debug({ allowedJobs: allowedJobs, maxLatency: maxLatency, latency: latency, latencyFactor: latencyFactor, targetJobs: targetJobs, activeQrls: activeQrls });
+                    jobsLeft = targetJobs;
+                    for (_i = 0, _a = queueManager.getPairs(); _i < _a.length; _i++) {
+                        _b = _a[_i], qname = _b.qname, qrl = _b.qrl;
+                        if (jobsLeft <= 0 || activeQrls.has(qrl))
+                            continue;
+                        maxMessages = Math.min(10, jobsLeft);
+                        listen(qname, qrl, maxMessages);
+                        jobsLeft -= maxMessages;
                         if (opt.verbose) {
-                            console.error(chalk_1.default.blue('Listening to queues (in this order):'));
-                            console.error(selectedPairs.map(function (_a) {
-                                var qname = _a.qname, qrl = _a.qrl;
-                                return '  ' + qname.slice(opt.prefix.length) + chalk_1.default.blue(' - ' + qrl);
-                            }).join('\n'));
-                            console.error();
-                        }
-                        // Launch listen loop for each queue
-                        for (_i = 0, selectedPairs_1 = selectedPairs; _i < selectedPairs_1.length; _i++) {
-                            _a = selectedPairs_1[_i], qname = _a.qname, qrl = _a.qrl;
-                            // Bail if we already have too many
-                            if (activeLoops.size >= maxActiveLoops) {
-                                if (opt.verbose)
-                                    console.error(chalk_1.default.yellow('Hit active worker limit of ') + maxActiveLoops);
-                                break;
-                            }
-                            loopId = loopCounter++;
-                            activeLoops.set(loopId, { qname: qname, qrl: qrl, promise: listenLoop(qname, qrl, loopId) });
+                            console.error(chalk_1.default.blue('Listening on: '), qname);
                         }
+                        debug({ listenedTo: { qname: qname, maxMessages: maxMessages, jobsLeft: jobsLeft } });
                     }
-                    if (!!shutdownRequested) return [3 /*break*/, 4];
-                    msSoFar = Math.max(0, new Date() - start);
-                    msUntilNextResolve = Math.max(0, /*opt.waitTime **/ 1000 - msSoFar);
-                    debug({ msSoFar: msSoFar, msUntilNextResolve: msUntilNextResolve });
-                    if (!msUntilNextResolve) return [3 /*break*/, 4];
-                    if (opt.verbose)
-                        console.error(chalk_1.default.blue('Will resolve queues again in ' + Math.round(msUntilNextResolve / 1000) + ' seconds'));
-                    return [4 /*yield*/, delay(msUntilNextResolve)];
+                    return [4 /*yield*/, delay(1000)];
+                case 2:
+                    _c.sent();
+                    return [3 /*break*/, 1];
                 case 3:
-                    _h.sent();
-                    _h.label = 4;
-                case 4:
-                    _b = 0, completedLoops_1 = completedLoops;
-                    _h.label = 5;
-                case 5:
-                    if (!(_b < completedLoops_1.length)) return [3 /*break*/, 8];
-                    _c = completedLoops_1[_b], id = _c[0], _d = _c[1], qname = _d.qname, qrl = _d.qrl, promise = _d.promise;
-                    return [4 /*yield*/, promise]; // make sure the promise resolves
-                case 6:
-                    _h.sent(); // make sure the promise resolves
-                    debug('Cleaning up', { id: id, qname: qname, qrl: qrl, promise: promise });
-                    activeLoops.delete(id);
-                    _h.label = 7;
-                case 7:
-                    _b++;
-                    return [3 /*break*/, 5];
-                case 8: return [3 /*break*/, 1];
-                case 9:
-                    debug('out here', { activeLoops: activeLoops });
-                    _e = 0, activeLoops_1 = activeLoops;
-                    _h.label = 10;
-                case 10:
-                    if (!(_e < activeLoops_1.length)) return [3 /*break*/, 13];
-                    _f = activeLoops_1[_e], id = _f[0], _g = _f[1], qname = _g.qname, qrl = _g.qrl, promise = _g.promise;
-                    debug('Waiting on active loop', id);
-                    return [4 /*yield*/, promise]; // make sure the promise resolves
-                case 11:
-                    _h.sent(); // make sure the promise resolves
-                    _h.label = 12;
-                case 12:
-                    _e++;
-                    return [3 /*break*/, 10];
-                case 13:
                     debug('after all');
                     return [2 /*return*/];
             }
@@ -521,4 +175,3 @@ function processMessages(queues, callback, options) {
     });
 }
 exports.processMessages = processMessages;
-debug('loaded');