qdone 2.0.28-alpha → 2.0.30-alpha

package/commonjs/src/idleQueues.js

@@ -1,49 +1,4 @@
 "use strict";
-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) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -52,17 +7,17 @@ exports.idleQueues = exports.processQueuePair = exports.processQueue = exports.d
 /**
  * Implementation of checks and caching of checks to determine if queues are idle.
  */
-var chalk_1 = __importDefault(require("chalk"));
-var sqs_js_1 = require("./sqs.js");
-var cloudWatch_js_1 = require("./cloudWatch.js");
-var defaults_js_1 = require("./defaults.js");
-var client_sqs_1 = require("@aws-sdk/client-sqs");
-var client_cloudwatch_1 = require("@aws-sdk/client-cloudwatch");
-var qrlCache_js_1 = require("./qrlCache.js");
-var cache_js_1 = require("./cache.js");
+const chalk_1 = __importDefault(require("chalk"));
+const sqs_js_1 = require("./sqs.js");
+const cloudWatch_js_1 = require("./cloudWatch.js");
+const defaults_js_1 = require("./defaults.js");
+const client_sqs_1 = require("@aws-sdk/client-sqs");
+const client_cloudwatch_1 = require("@aws-sdk/client-cloudwatch");
+const qrlCache_js_1 = require("./qrlCache.js");
+const cache_js_1 = require("./cache.js");
 // const AWS = require('aws-sdk')
-var debug_1 = __importDefault(require("debug"));
-var debug = (0, debug_1.default)('qdone:idleQueues');
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)('qdone:idleQueues');
 // Queue attributes we check to determine idle
 exports.attributeNames = [
     'ApproximateNumberOfMessages',
@@ -70,7 +25,7 @@ exports.attributeNames = [
     'ApproximateNumberOfMessagesDelayed'
 ];
 // CloudWatch metrics we check to determine idle
-var metricNames = [
+const metricNames = [
     'NumberOfMessagesSent',
     'NumberOfMessagesReceived',
     'NumberOfMessagesDeleted',
@@ -83,114 +38,79 @@ var metricNames = [
 /**
  * Actual SQS call, used in conjunction with cache.
  */
-function _cheapIdleCheck(qname, qrl, opt) {
-    return __awaiter(this, void 0, void 0, function () {
-        var client, cmd, data, result_1, e_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 2, , 3]);
-                    client = (0, sqs_js_1.getSQSClient)();
-                    cmd = new client_sqs_1.GetQueueAttributesCommand({ AttributeNames: exports.attributeNames, QueueUrl: qrl });
-                    return [4 /*yield*/, client.send(cmd)];
-                case 1:
-                    data = _a.sent();
-                    debug('data', data);
-                    result_1 = data.Attributes;
-                    result_1.queue = qname.slice(opt.prefix.length);
-                    // We are idle if all the messages attributes are zero
-                    result_1.idle = exports.attributeNames.filter(function (k) { return result_1[k] === '0'; }).length === exports.attributeNames.length;
-                    return [2 /*return*/, { result: result_1, SQS: 1 }];
-                case 2:
-                    e_1 = _a.sent();
-                    if (e_1 instanceof client_sqs_1.QueueDoesNotExist) {
-                        // Count deleted queues as idle
-                        return [2 /*return*/, { idle: true, SQS: 1 }];
-                    }
-                    else {
-                        throw e_1;
-                    }
-                    return [3 /*break*/, 3];
-                case 3: return [2 /*return*/];
-            }
-        });
-    });
+async function _cheapIdleCheck(qname, qrl, opt) {
+    try {
+        const client = (0, sqs_js_1.getSQSClient)();
+        const cmd = new client_sqs_1.GetQueueAttributesCommand({ AttributeNames: exports.attributeNames, QueueUrl: qrl });
+        const data = await client.send(cmd);
+        debug('data', data);
+        const result = data.Attributes;
+        result.queue = qname.slice(opt.prefix.length);
+        // We are idle if all the messages attributes are zero
+        result.idle = exports.attributeNames.filter(k => result[k] === '0').length === exports.attributeNames.length;
+        return { result, SQS: 1 };
+    }
+    catch (e) {
+        if (e instanceof client_sqs_1.QueueDoesNotExist) {
+            // Count deleted queues as idle
+            return { idle: true, SQS: 1 };
+        }
+        else {
+            throw e;
+        }
+    }
 }
 exports._cheapIdleCheck = _cheapIdleCheck;
 /**
  * Gets queue attributes from the SQS api and assesses whether queue is idle
  * at this immediate moment.
  */
-function cheapIdleCheck(qname, qrl, opt) {
-    return __awaiter(this, void 0, void 0, function () {
-        var key, cacheResult, _a, result, SQS, ok;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    // Just call the API if we don't have a cache
-                    if (!opt.cacheUri)
-                        return [2 /*return*/, _cheapIdleCheck(qname, qrl, opt)
-                            // Otherwise check cache
-                        ];
-                    key = 'cheap-idle-check:' + qrl;
-                    return [4 /*yield*/, (0, cache_js_1.getCache)(key, opt)];
-                case 1:
-                    cacheResult = _b.sent();
-                    debug({ cacheResult: cacheResult });
-                    if (!cacheResult) return [3 /*break*/, 2];
-                    debug({ action: 'return resolved' });
-                    return [2 /*return*/, { result: cacheResult, SQS: 0 }];
-                case 2:
-                    // Cache miss, make call
-                    debug({ action: 'do real check' });
-                    return [4 /*yield*/, _cheapIdleCheck(qname, qrl, opt)];
-                case 3:
-                    _a = _b.sent(), result = _a.result, SQS = _a.SQS;
-                    debug({ action: 'setCache', key: key, result: result });
-                    return [4 /*yield*/, (0, cache_js_1.setCache)(key, result, opt)];
-                case 4:
-                    ok = _b.sent();
-                    debug({ action: 'return result of set cache', ok: ok });
-                    return [2 /*return*/, { result: result, SQS: SQS }];
-            }
-        });
-    });
+async function cheapIdleCheck(qname, qrl, opt) {
+    // Just call the API if we don't have a cache
+    if (!opt.cacheUri)
+        return _cheapIdleCheck(qname, qrl, opt);
+    // Otherwise check cache
+    const key = 'cheap-idle-check:' + qrl;
+    const cacheResult = await (0, cache_js_1.getCache)(key, opt);
+    debug({ cacheResult });
+    if (cacheResult) {
+        debug({ action: 'return resolved' });
+        return { result: cacheResult, SQS: 0 };
+    }
+    else {
+        // Cache miss, make call
+        debug({ action: 'do real check' });
+        const { result, SQS } = await _cheapIdleCheck(qname, qrl, opt);
+        debug({ action: 'setCache', key, result });
+        const ok = await (0, cache_js_1.setCache)(key, result, opt);
+        debug({ action: 'return result of set cache', ok });
+        return { result, SQS };
+    }
 }
 exports.cheapIdleCheck = cheapIdleCheck;
 /**
  * Gets a single metric from the CloudWatch api.
  */
-function getMetric(qname, qrl, metricName, opt) {
-    return __awaiter(this, void 0, void 0, function () {
-        var now, params, client, cmd, data;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    debug('getMetric', qname, qrl, metricName);
-                    now = new Date();
-                    params = {
-                        StartTime: new Date(now.getTime() - 1000 * 60 * opt.idleFor),
-                        EndTime: now,
-                        MetricName: metricName,
-                        Namespace: 'AWS/SQS',
-                        Period: 3600,
-                        Dimensions: [{ Name: 'QueueName', Value: qname }],
-                        Statistics: ['Sum']
-                        // Unit: ['']
-                    };
-                    client = (0, cloudWatch_js_1.getCloudWatchClient)();
-                    cmd = new client_cloudwatch_1.GetMetricStatisticsCommand(params);
-                    return [4 /*yield*/, client.send(cmd)];
-                case 1:
-                    data = _b.sent();
-                    debug('getMetric data', data);
-                    return [2 /*return*/, (_a = {},
-                            _a[metricName] = data.Datapoints.map(function (d) { return d.Sum; }).reduce(function (a, b) { return a + b; }, 0),
-                            _a)];
-            }
-        });
-    });
+async function getMetric(qname, qrl, metricName, opt) {
+    debug('getMetric', qname, qrl, metricName);
+    const now = new Date();
+    const params = {
+        StartTime: new Date(now.getTime() - 1000 * 60 * opt.idleFor),
+        EndTime: now,
+        MetricName: metricName,
+        Namespace: 'AWS/SQS',
+        Period: 3600,
+        Dimensions: [{ Name: 'QueueName', Value: qname }],
+        Statistics: ['Sum']
+        // Unit: ['']
+    };
+    const client = (0, cloudWatch_js_1.getCloudWatchClient)();
+    const cmd = new client_cloudwatch_1.GetMetricStatisticsCommand(params);
+    const data = await client.send(cmd);
+    debug('getMetric data', data);
+    return {
+        [metricName]: data.Datapoints.map(d => d.Sum).reduce((a, b) => a + b, 0)
+    };
 }
 exports.getMetric = getMetric;
 /**
@@ -204,274 +124,213 @@ exports.getMetric = getMetric;
  * We could randomize the order, but for my test use case, it's always cheaper
  * to check NumberOfMessagesSent first, and is the primary indicator of use.
  */
-function checkIdle(qname, qrl, opt) {
-    return __awaiter(this, void 0, void 0, function () {
-        var _a, cheapResult, SQS, apiCalls, results, idle, _i, metricNames_1, metricName, result, stats;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    // Do the cheap check first to make sure there is no data in flight at the moment
-                    debug('checkIdle', qname, qrl);
-                    return [4 /*yield*/, cheapIdleCheck(qname, qrl, opt)];
-                case 1:
-                    _a = _b.sent(), cheapResult = _a.result, SQS = _a.SQS;
-                    debug('cheapResult', cheapResult);
-                    // Short circuit further calls if cheap result shows data
-                    if (cheapResult.idle === false) {
-                        return [2 /*return*/, {
-                                queue: qname.slice(opt.prefix.length),
-                                cheap: cheapResult,
-                                idle: false,
-                                apiCalls: { SQS: SQS, CloudWatch: 0 }
-                            }];
-                    }
-                    apiCalls = { SQS: 1, CloudWatch: 0 };
-                    results = [];
-                    idle = true;
-                    _i = 0, metricNames_1 = metricNames;
-                    _b.label = 2;
-                case 2:
-                    if (!(_i < metricNames_1.length)) return [3 /*break*/, 5];
-                    metricName = metricNames_1[_i];
-                    return [4 /*yield*/, getMetric(qname, qrl, metricName, opt)];
-                case 3:
-                    result = _b.sent();
-                    results.push(result);
-                    debug('getMetric result', result);
-                    apiCalls.CloudWatch++;
-                    // Recalculate idle
-                    idle = result[metricName] === 0;
-                    if (!idle)
-                        return [3 /*break*/, 5]; // and stop checking metrics if we find evidence of activity
-                    _b.label = 4;
-                case 4:
-                    _i++;
-                    return [3 /*break*/, 2];
-                case 5:
-                    stats = Object.assign.apply(Object, __spreadArray([{
-                            queue: qname.slice(opt.prefix.length),
-                            cheap: cheapResult,
-                            apiCalls: apiCalls,
-                            idle: idle
-                        }], results // merge in results from CloudWatch
-                    , false));
-                    debug('checkIdle stats', stats);
-                    return [2 /*return*/, stats];
-            }
-        });
-    });
+async function checkIdle(qname, qrl, opt) {
+    // Do the cheap check first to make sure there is no data in flight at the moment
+    debug('checkIdle', qname, qrl);
+    const { result: cheapResult, SQS } = await cheapIdleCheck(qname, qrl, opt);
+    debug('cheapResult', cheapResult);
+    // Short circuit further calls if cheap result shows data
+    if (cheapResult.idle === false) {
+        return {
+            queue: qname.slice(opt.prefix.length),
+            cheap: cheapResult,
+            idle: false,
+            apiCalls: { SQS, CloudWatch: 0 }
+        };
+    }
+    // If we get here, there's nothing in the queue at the moment,
+    // so we have to check metrics one at a time
+    const apiCalls = { SQS: 1, CloudWatch: 0 };
+    const results = [];
+    let idle = true;
+    for (const metricName of metricNames) {
+        // Check metrics in order
+        const result = await getMetric(qname, qrl, metricName, opt);
+        results.push(result);
+        debug('getMetric result', result);
+        apiCalls.CloudWatch++;
+        // Recalculate idle
+        idle = result[metricName] === 0;
+        if (!idle)
+            break; // and stop checking metrics if we find evidence of activity
+    }
+    // Calculate stats
+    const stats = Object.assign({
+        queue: qname.slice(opt.prefix.length),
+        cheap: cheapResult,
+        apiCalls,
+        idle
+    }, ...results // merge in results from CloudWatch
+    );
+    debug('checkIdle stats', stats);
+    return stats;
 }
 exports.checkIdle = checkIdle;
 /**
  * Just deletes a queue.
  */
-function deleteQueue(qname, qrl, opt) {
-    return __awaiter(this, void 0, void 0, function () {
-        var cmd, result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    cmd = new client_sqs_1.DeleteQueueCommand({ QueueUrl: qrl });
-                    return [4 /*yield*/, (0, sqs_js_1.getSQSClient)().send(cmd)];
-                case 1:
-                    result = _a.sent();
-                    debug(result);
-                    if (opt.verbose)
-                        console.error(chalk_1.default.blue('Deleted ') + qname.slice(opt.prefix.length));
-                    return [2 /*return*/, {
-                            deleted: true,
-                            apiCalls: { SQS: 1, CloudWatch: 0 }
-                        }];
-            }
-        });
-    });
+async function deleteQueue(qname, qrl, opt) {
+    const cmd = new client_sqs_1.DeleteQueueCommand({ QueueUrl: qrl });
+    const result = await (0, sqs_js_1.getSQSClient)().send(cmd);
+    debug(result);
+    if (opt.verbose)
+        console.error(chalk_1.default.blue('Deleted ') + qname.slice(opt.prefix.length));
+    return {
+        deleted: true,
+        apiCalls: { SQS: 1, CloudWatch: 0 }
+    };
 }
 exports.deleteQueue = deleteQueue;
 /**
  * Processes a single queue, checking for idle, deleting if applicable.
  */
-function processQueue(qname, qrl, opt) {
-    return __awaiter(this, void 0, void 0, function () {
-        var result, deleteResult, resultIncludingDelete;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, checkIdle(qname, qrl, opt)];
-                case 1:
-                    result = _a.sent();
-                    debug(qname, result);
-                    // Queue is active
-                    if (!result.idle) {
-                        // Notify and return
-                        if (opt.verbose)
-                            console.error(chalk_1.default.blue('Queue ') + qname.slice(opt.prefix.length) + chalk_1.default.blue(' has been ') + 'active' + chalk_1.default.blue(' in the last ') + opt.idleFor + chalk_1.default.blue(' minutes.'));
-                        return [2 /*return*/, result];
-                    }
-                    // Queue is idle
-                    if (opt.verbose)
-                        console.error(chalk_1.default.blue('Queue ') + qname.slice(opt.prefix.length) + chalk_1.default.blue(' has been ') + 'idle' + chalk_1.default.blue(' for the last ') + opt.idleFor + chalk_1.default.blue(' minutes.'));
-                    if (!opt.delete) return [3 /*break*/, 3];
-                    return [4 /*yield*/, deleteQueue(qname, qrl, opt)];
-                case 2:
-                    deleteResult = _a.sent();
-                    resultIncludingDelete = Object.assign(result, {
-                        deleted: deleteResult.deleted,
-                        apiCalls: {
-                            SQS: result.apiCalls.SQS + deleteResult.apiCalls.SQS,
-                            CloudWatch: result.apiCalls.CloudWatch + deleteResult.apiCalls.CloudWatch
-                        }
-                    });
-                    return [2 /*return*/, resultIncludingDelete];
-                case 3: return [2 /*return*/];
+async function processQueue(qname, qrl, opt) {
+    const result = await checkIdle(qname, qrl, opt);
+    debug(qname, result);
+    // Queue is active
+    if (!result.idle) {
+        // Notify and return
+        if (opt.verbose)
+            console.error(chalk_1.default.blue('Queue ') + qname.slice(opt.prefix.length) + chalk_1.default.blue(' has been ') + 'active' + chalk_1.default.blue(' in the last ') + opt.idleFor + chalk_1.default.blue(' minutes.'));
+        return result;
+    }
+    // Queue is idle
+    if (opt.verbose)
+        console.error(chalk_1.default.blue('Queue ') + qname.slice(opt.prefix.length) + chalk_1.default.blue(' has been ') + 'idle' + chalk_1.default.blue(' for the last ') + opt.idleFor + chalk_1.default.blue(' minutes.'));
+    if (opt.delete) {
+        const deleteResult = await deleteQueue(qname, qrl, opt);
+        const resultIncludingDelete = Object.assign(result, {
+            deleted: deleteResult.deleted,
+            apiCalls: {
+                SQS: result.apiCalls.SQS + deleteResult.apiCalls.SQS,
+                CloudWatch: result.apiCalls.CloudWatch + deleteResult.apiCalls.CloudWatch
             }
         });
-    });
+        return resultIncludingDelete;
+    }
 }
 exports.processQueue = processQueue;
 /**
  * Processes a queue and its fail queue, treating them as a unit.
  */
-function processQueuePair(qname, qrl, opt) {
-    return __awaiter(this, void 0, void 0, function () {
-        var isFifo, normalizeOptions, fqname, fqrl, result, active, fresult, idleCheckResult, factive, _a, dresult, dfresult, e_2, deleteResult, resultIncludingDelete;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    isFifo = qname.endsWith('.fifo');
-                    normalizeOptions = Object.assign({}, opt, { fifo: isFifo });
-                    fqname = (0, qrlCache_js_1.normalizeFailQueueName)(qname, normalizeOptions);
-                    fqrl = (0, qrlCache_js_1.normalizeFailQueueName)(fqname, normalizeOptions);
-                    return [4 /*yield*/, checkIdle(qname, qrl, opt)];
-                case 1:
-                    result = _b.sent();
-                    debug('result', result);
-                    active = !result.idle;
-                    if (active) {
-                        if (opt.verbose)
-                            console.error(chalk_1.default.blue('Queue ') + qname.slice(opt.prefix.length) + chalk_1.default.blue(' has been ') + 'active' + chalk_1.default.blue(' in the last ') + opt.idleFor + chalk_1.default.blue(' minutes.'));
-                        return [2 /*return*/, result];
-                    }
-                    // Queue is idle
-                    if (opt.verbose)
-                        console.error(chalk_1.default.blue('Queue ') + qname.slice(opt.prefix.length) + chalk_1.default.blue(' has been ') + 'idle' + chalk_1.default.blue(' for the last ') + opt.idleFor + chalk_1.default.blue(' minutes.'));
-                    _b.label = 2;
-                case 2:
-                    _b.trys.push([2, 5, , 7]);
-                    return [4 /*yield*/, checkIdle(fqname, fqrl, opt)];
-                case 3:
-                    fresult = _b.sent();
-                    debug('fresult', fresult);
-                    idleCheckResult = Object.assign(result, { idle: result.idle && fresult.idle, failq: fresult }, {
-                        apiCalls: {
-                            SQS: result.apiCalls.SQS + fresult.apiCalls.SQS,
-                            CloudWatch: result.apiCalls.CloudWatch + fresult.apiCalls.CloudWatch
-                        }
-                    });
-                    factive = !fresult.idle;
-                    if (factive) {
-                        if (opt.verbose)
-                            console.error(chalk_1.default.blue('Queue ') + fqname.slice(opt.prefix.length) + chalk_1.default.blue(' has been ') + 'active' + chalk_1.default.blue(' in the last ') + opt.idleFor + chalk_1.default.blue(' minutes.'));
-                        return [2 /*return*/, idleCheckResult];
-                    }
-                    // Queue is idle
-                    if (opt.verbose)
-                        console.error(chalk_1.default.blue('Queue ') + fqname.slice(opt.prefix.length) + chalk_1.default.blue(' has been ') + 'idle' + chalk_1.default.blue(' for the last ') + opt.idleFor + chalk_1.default.blue(' minutes.'));
-                    // Trigger a delete if the user wants it
-                    if (!opt.delete)
-                        return [2 /*return*/, idleCheckResult];
-                    return [4 /*yield*/, Promise.all([
-                            deleteQueue(qname, qrl, opt),
-                            deleteQueue(fqname, fqrl, opt)
-                        ])];
-                case 4:
-                    _a = _b.sent(), dresult = _a[0], dfresult = _a[1];
-                    return [2 /*return*/, Object.assign(idleCheckResult, {
-                            apiCalls: {
-                                // Sum the SQS calls across all four
-                                SQS: [result, fresult, dresult, dfresult]
-                                    .map(function (r) { return r.apiCalls.SQS; })
-                                    .reduce(function (a, b) { return a + b; }, 0),
-                                // Sum the CloudWatch calls across all four
-                                CloudWatch: [result, fresult, dresult, dfresult]
-                                    .map(function (r) { return r.apiCalls.CloudWatch; })
-                                    .reduce(function (a, b) { return a + b; }, 0)
-                            }
-                        })];
-                case 5:
-                    e_2 = _b.sent();
-                    // Handle the case where the fail queue has been deleted or was never
-                    // created for some reason
-                    if (!(e_2 instanceof client_sqs_1.QueueDoesNotExist))
-                        throw e_2;
-                    // Fail queue doesn't exist if we get here
-                    if (opt.verbose)
-                        console.error(chalk_1.default.blue('Queue ') + fqname.slice(opt.prefix.length) + chalk_1.default.blue(' does not exist.'));
-                    // Handle delete
-                    if (!opt.delete)
-                        return [2 /*return*/, result];
-                    return [4 /*yield*/, deleteQueue(qname, qrl, opt)];
-                case 6:
-                    deleteResult = _b.sent();
-                    resultIncludingDelete = Object.assign(result, {
-                        deleted: deleteResult.deleted,
-                        apiCalls: {
-                            SQS: result.apiCalls.SQS + deleteResult.apiCalls.SQS,
-                            CloudWatch: result.apiCalls.CloudWatch + deleteResult.apiCalls.CloudWatch
-                        }
-                    });
-                    return [2 /*return*/, resultIncludingDelete];
-                case 7: return [2 /*return*/];
+async function processQueuePair(qname, qrl, opt) {
+    const isFifo = qname.endsWith('.fifo');
+    const normalizeOptions = Object.assign({}, opt, { fifo: isFifo });
+    // Generate fail queue name/url
+    const fqname = (0, qrlCache_js_1.normalizeFailQueueName)(qname, normalizeOptions);
+    const fqrl = (0, qrlCache_js_1.normalizeFailQueueName)(fqname, normalizeOptions);
+    // Idle check
+    const result = await checkIdle(qname, qrl, opt);
+    debug('result', result);
+    // Queue is active
+    const active = !result.idle;
+    if (active) {
+        if (opt.verbose)
+            console.error(chalk_1.default.blue('Queue ') + qname.slice(opt.prefix.length) + chalk_1.default.blue(' has been ') + 'active' + chalk_1.default.blue(' in the last ') + opt.idleFor + chalk_1.default.blue(' minutes.'));
+        return result;
+    }
+    // Queue is idle
+    if (opt.verbose)
+        console.error(chalk_1.default.blue('Queue ') + qname.slice(opt.prefix.length) + chalk_1.default.blue(' has been ') + 'idle' + chalk_1.default.blue(' for the last ') + opt.idleFor + chalk_1.default.blue(' minutes.'));
+    // Check fail queue
+    try {
+        const fresult = await checkIdle(fqname, fqrl, opt);
+        debug('fresult', fresult);
+        const idleCheckResult = Object.assign(result, { idle: result.idle && fresult.idle, failq: fresult }, {
+            apiCalls: {
+                SQS: result.apiCalls.SQS + fresult.apiCalls.SQS,
+                CloudWatch: result.apiCalls.CloudWatch + fresult.apiCalls.CloudWatch
             }
         });
-    });
+        // Queue is active
+        const factive = !fresult.idle;
+        if (factive) {
+            if (opt.verbose)
+                console.error(chalk_1.default.blue('Queue ') + fqname.slice(opt.prefix.length) + chalk_1.default.blue(' has been ') + 'active' + chalk_1.default.blue(' in the last ') + opt.idleFor + chalk_1.default.blue(' minutes.'));
+            return idleCheckResult;
+        }
+        // Queue is idle
+        if (opt.verbose)
+            console.error(chalk_1.default.blue('Queue ') + fqname.slice(opt.prefix.length) + chalk_1.default.blue(' has been ') + 'idle' + chalk_1.default.blue(' for the last ') + opt.idleFor + chalk_1.default.blue(' minutes.'));
+        // Trigger a delete if the user wants it
+        if (!opt.delete)
+            return idleCheckResult;
+        const [dresult, dfresult] = await Promise.all([
+            deleteQueue(qname, qrl, opt),
+            deleteQueue(fqname, fqrl, opt)
+        ]);
+        return Object.assign(idleCheckResult, {
+            apiCalls: {
+                // Sum the SQS calls across all four
+                SQS: [result, fresult, dresult, dfresult]
+                    .map(r => r.apiCalls.SQS)
+                    .reduce((a, b) => a + b, 0),
+                // Sum the CloudWatch calls across all four
+                CloudWatch: [result, fresult, dresult, dfresult]
+                    .map(r => r.apiCalls.CloudWatch)
+                    .reduce((a, b) => a + b, 0)
+            }
+        });
+    }
+    catch (e) {
+        // Handle the case where the fail queue has been deleted or was never
+        // created for some reason
+        if (!(e instanceof client_sqs_1.QueueDoesNotExist))
+            throw e;
+        // Fail queue doesn't exist if we get here
+        if (opt.verbose)
+            console.error(chalk_1.default.blue('Queue ') + fqname.slice(opt.prefix.length) + chalk_1.default.blue(' does not exist.'));
+        // Handle delete
+        if (!opt.delete)
+            return result;
+        const deleteResult = await deleteQueue(qname, qrl, opt);
+        const resultIncludingDelete = Object.assign(result, {
+            deleted: deleteResult.deleted,
+            apiCalls: {
+                SQS: result.apiCalls.SQS + deleteResult.apiCalls.SQS,
+                CloudWatch: result.apiCalls.CloudWatch + deleteResult.apiCalls.CloudWatch
+            }
+        });
+        return resultIncludingDelete;
+    }
 }
 exports.processQueuePair = processQueuePair;
 //
 // Resolve queues for listening loop listen
 //
-function idleQueues(queues, options) {
-    return __awaiter(this, void 0, void 0, function () {
-        var opt, qnames, entries, filteredEntries;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    opt = (0, defaults_js_1.getOptionsWithDefaults)(options);
-                    if (opt.verbose)
-                        console.error(chalk_1.default.blue('Resolving queues: ') + queues.join(' '));
-                    qnames = queues.map(function (queue) { return opt.prefix + queue; });
-                    return [4 /*yield*/, (0, qrlCache_js_1.getQnameUrlPairs)(qnames, opt)];
-                case 1:
-                    entries = _a.sent();
-                    debug('getQnameUrlPairs.then');
-                    if (opt.verbose) {
-                        console.error(chalk_1.default.blue('  done'));
-                        console.error();
-                    }
-                    filteredEntries = entries.filter(function (entry) {
-                        var suf = opt.failSuffix;
-                        var sufFifo = opt.failSuffix + qrlCache_js_1.fifoSuffix;
-                        var isFail = entry.qname.endsWith(suf);
-                        var isFifoFail = entry.qname.endsWith(sufFifo);
-                        return opt.includeFailed ? true : (!isFail && !isFifoFail);
-                    });
-                    // But only if we have queues to remove
-                    if (filteredEntries.length) {
-                        if (opt.verbose) {
-                            console.error(chalk_1.default.blue('Checking queues (in this order):'));
-                            console.error(filteredEntries.map(function (e) {
-                                return '  ' + e.qname.slice(opt.prefix.length) + chalk_1.default.blue(' - ' + e.qrl);
-                            }).join('\n'));
-                            console.error();
-                        }
-                        // Check each queue in parallel
-                        if (opt.unpair)
-                            return [2 /*return*/, Promise.all(filteredEntries.map(function (e) { return processQueue(e.qname, e.qrl, opt); }))];
-                        return [2 /*return*/, Promise.all(filteredEntries.map(function (e) { return processQueuePair(e.qname, e.qrl, opt); }))];
-                    }
-                    // Otherwise, let caller know
-                    return [2 /*return*/, 'noQueues'];
-            }
-        });
+async function idleQueues(queues, options) {
+    const opt = (0, defaults_js_1.getOptionsWithDefaults)(options);
+    if (opt.verbose)
+        console.error(chalk_1.default.blue('Resolving queues: ') + queues.join(' '));
+    const qnames = queues.map(queue => opt.prefix + queue);
+    const entries = await (0, qrlCache_js_1.getQnameUrlPairs)(qnames, opt);
+    debug('getQnameUrlPairs.then');
+    if (opt.verbose) {
+        console.error(chalk_1.default.blue('  done'));
+        console.error();
+    }
+    // Filter out any queue ending in suffix unless --include-failed is set
+    const filteredEntries = entries.filter(entry => {
+        const suf = opt.failSuffix;
+        const sufFifo = opt.failSuffix + qrlCache_js_1.fifoSuffix;
+        const isFail = entry.qname.endsWith(suf);
+        const isFifoFail = entry.qname.endsWith(sufFifo);
+        return opt.includeFailed ? true : (!isFail && !isFifoFail);
     });
+    // But only if we have queues to remove
+    if (filteredEntries.length) {
+        if (opt.verbose) {
+            console.error(chalk_1.default.blue('Checking queues (in this order):'));
+            console.error(filteredEntries.map(e => '  ' + e.qname.slice(opt.prefix.length) + chalk_1.default.blue(' - ' + e.qrl)).join('\n'));
+            console.error();
+        }
+        // Check each queue in parallel
+        if (opt.unpair)
+            return Promise.all(filteredEntries.map(e => processQueue(e.qname, e.qrl, opt)));
+        return Promise.all(filteredEntries.map(e => processQueuePair(e.qname, e.qrl, opt)));
+    }
+    // Otherwise, let caller know
+    return 'noQueues';
 }
 exports.idleQueues = idleQueues;
 debug('loaded');