qdone 1.7.0 → 2.0.0-alpha

package/commonjs/src/idleQueues.js

@@ -0,0 +1,466 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.idleQueues = exports.processQueuePair = exports.processQueue = exports.deleteQueue = exports.checkIdle = exports.getMetric = exports.cheapIdleCheck = exports._cheapIdleCheck = exports.attributeNames = void 0;
+/**
+ * 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 AWS = require('aws-sdk')
+var debug_1 = __importDefault(require("debug"));
+var debug = (0, debug_1.default)('qdone:idleQueues');
+// Queue attributes we check to determine idle
+exports.attributeNames = [
+    'ApproximateNumberOfMessages',
+    'ApproximateNumberOfMessagesNotVisible',
+    'ApproximateNumberOfMessagesDelayed'
+];
+// CloudWatch metrics we check to determine idle
+var metricNames = [
+    'NumberOfMessagesSent',
+    'NumberOfMessagesReceived',
+    'NumberOfMessagesDeleted',
+    'ApproximateNumberOfMessagesVisible',
+    'ApproximateNumberOfMessagesNotVisible',
+    'ApproximateNumberOfMessagesDelayed',
+    //    'NumberOfEmptyReceives',
+    'ApproximateAgeOfOldestMessage'
+];
+/**
+ * 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;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    client = (0, sqs_js_1.getSQSClient)();
+                    cmd = new client_sqs_1.GetQueueAttributesCommand({ AttributeNames: exports.attributeNames, QueueUrl: qrl });
+                    return [4 /*yield*/, client.send(cmd)
+                        // debug('data', data)
+                    ];
+                case 1:
+                    data = _a.sent();
+                    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(function (k) { return result[k] === '0'; }).length === exports.attributeNames.length;
+                    return [2 /*return*/, { result: result, SQS: 1 }];
+            }
+        });
+    });
+}
+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 }];
+            }
+        });
+    });
+}
+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)];
+            }
+        });
+    });
+}
+exports.getMetric = getMetric;
+/**
+ * Checks if a single queue is idle. First queries the cheap ($0.40/1M) SQS API and
+ * continues to the expensive ($10/1M) CloudWatch API, checking to make sure there
+ * were no messages in the queue in the specified time period. Only if all relevant
+ * metrics show no messages, is it ok to delete the queue.
+ *
+ * Realistically, the number of CloudWatch calls will depend on usage patterns, but
+ * I see a ~70% reduction in calls by checking metrics in the given order.
+ * 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];
+            }
+        });
+    });
+}
+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 }
+                        }];
+            }
+        });
+    });
+}
+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*/];
+            }
+        });
+    });
+}
+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_1, 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)(qrl, 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_1 = _b.sent();
+                    // Handle the case where the fail queue has been deleted or was never
+                    // created for some reason
+                    if (!(e_1 instanceof client_sqs_1.QueueDoesNotExist))
+                        throw e_1;
+                    // 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*/];
+            }
+        });
+    });
+}
+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'];
+            }
+        });
+    });
+}
+exports.idleQueues = idleQueues;
+debug('loaded');