qdone 2.1.0 → 2.1.1

package/commonjs/src/idleQueues.js

@@ -0,0 +1,333 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.idleQueues = exports.stripSuffixes = exports.processQueueSet = 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.
+ */
+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')
+const debug_1 = __importDefault(require("debug"));
+const 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
+const metricNames = [
+    'NumberOfMessagesSent',
+    'NumberOfMessagesReceived',
+    'NumberOfMessagesDeleted',
+    'ApproximateNumberOfMessagesVisible',
+    'ApproximateNumberOfMessagesNotVisible',
+    'ApproximateNumberOfMessagesDelayed',
+    //    'NumberOfEmptyReceives',
+    'ApproximateAgeOfOldestMessage'
+];
+/**
+ * Actual SQS call, used in conjunction with cache.
+ */
+async function _cheapIdleCheck(qname, qrl, opt) {
+    debug('_cheapIdleCheck', qname, qrl);
+    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;
+        result.exists = true;
+        debug({ result, SQS: 1 });
+        return { result, SQS: 1 };
+    }
+    catch (e) {
+        debug({ _cheapIdleCheck: e });
+        if (e instanceof client_sqs_1.QueueDoesNotExist) {
+            return { result: { idle: undefined, exists: false }, 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.
+ */
+async function cheapIdleCheck(qname, qrl, opt) {
+    debug('cheapIdleCheck', qname, qrl);
+    // 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.
+ */
+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;
+/**
+ * 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.
+ */
+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 is conclusive
+    if (cheapResult.idle === false || cheapResult.exists === false) {
+        return {
+            queue: qname.slice(opt.prefix.length),
+            cheap: { SQS, result: cheapResult },
+            idle: cheapResult.idle,
+            exists: cheapResult.exists,
+            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, 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,
+        exists: true
+    }, ...results // merge in results from CloudWatch
+    );
+    debug('checkIdle stats', stats);
+    return stats;
+}
+exports.checkIdle = checkIdle;
+/**
+ * Just deletes a queue.
+ */
+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 queue and its fail and delete queue, treating them as a unit.
+ */
+async function processQueueSet(qname, qrl, opt) {
+    const isFifo = qname.endsWith('.fifo');
+    const normalizeOptions = Object.assign({}, opt, { fifo: isFifo });
+    // Generate DLQ name/url
+    const dqname = (0, qrlCache_js_1.normalizeDLQName)(qname, normalizeOptions);
+    const dqrl = (0, qrlCache_js_1.normalizeDLQName)(dqname, normalizeOptions);
+    // Generate fail queue name/url
+    const fqname = (0, qrlCache_js_1.normalizeFailQueueName)(qname, normalizeOptions);
+    const fqrl = (0, qrlCache_js_1.normalizeFailQueueName)(fqname, normalizeOptions);
+    debug({ qname, qrl, dqname, dqrl, fqname, fqrl });
+    // Idle check
+    const qresult = await checkIdle(qname, qrl, opt);
+    const fqresult = await checkIdle(fqname, fqrl, opt);
+    const dqresult = await checkIdle(dqname, dqrl, opt);
+    debug({ qresult, fqresult, dqresult });
+    // Start building return value
+    const result = Object.assign({
+        queue: qname,
+        idle: (qresult.idle &&
+            (!fqresult.exists || fqresult.idle) &&
+            (!fqresult.exists || dqresult.idle)),
+        apiCalls: {
+            SQS: qresult.apiCalls.SQS + fqresult.apiCalls.SQS + dqresult.apiCalls.SQS,
+            CloudWatch: qresult.apiCalls.CloudWatch + fqresult.apiCalls.CloudWatch + dqresult.apiCalls.CloudWatch
+        }
+    });
+    // Queue is idle
+    if (qresult.idle && 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 (fqresult.idle && 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.'));
+    if (dqresult.idle && opt.verbose)
+        console.error(chalk_1.default.blue('Queue ') + dqname.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.'));
+    // Delete if all are idle
+    const canDelete = ((qresult.idle || qresult.exists === false) &&
+        (fqresult.idle || fqresult.exists === false) &&
+        (dqresult.idle || dqresult.exists === false));
+    debug({ canDelete });
+    if (opt.delete && canDelete) {
+        // Normal
+        const qdresult = await (async () => {
+            debug({ qresult });
+            try {
+                if (qresult.idle)
+                    return deleteQueue(qname, qrl, opt);
+            }
+            catch (e) {
+                if (!(e instanceof client_sqs_1.QueueDoesNotExist))
+                    throw e;
+            }
+        })();
+        if (qdresult) {
+            result.apiCalls.SQS += qdresult.apiCalls.SQS;
+        }
+        debug({ qdresult });
+        // Fail
+        const fqdresult = await (async () => {
+            debug({ fqresult });
+            try {
+                if (fqresult.idle)
+                    return deleteQueue(fqname, fqrl, opt);
+            }
+            catch (e) {
+                if (!(e instanceof client_sqs_1.QueueDoesNotExist))
+                    throw e;
+            }
+        })();
+        if (fqdresult) {
+            result.apiCalls.SQS += fqdresult.apiCalls.SQS;
+        }
+        debug({ fqdresult });
+        // Dead
+        const dqdresult = await (async () => {
+            debug({ dqresult });
+            try {
+                if (dqresult.idle)
+                    return deleteQueue(dqname, dqrl, opt);
+            }
+            catch (e) {
+                if (!(e instanceof client_sqs_1.QueueDoesNotExist))
+                    throw e;
+            }
+        })();
+        if (dqdresult) {
+            result.apiCalls.SQS += dqdresult.apiCalls.SQS;
+        }
+        debug({ dqdresult });
+    }
+    return result;
+}
+exports.processQueueSet = processQueueSet;
+//
+// Strips failed and dlq suffix from a queue name or URL
+//
+function stripSuffixes(queueName, opt) {
+    const suffixFinder = new RegExp(`(${opt.dlqSuffix}|${opt.failSuffix}){1}(|${qrlCache_js_1.fifoSuffix})$`);
+    return queueName.replace(suffixFinder, '$2');
+}
+exports.stripSuffixes = stripSuffixes;
+//
+// Resolve queues for listening loop listen
+//
+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 failed and dead queues, but if we have an orphaned fail or
+    // dead queue, keep the original parent queue name so that orphans can be
+    // deleted.
+    const queueNames = new Set();
+    const filteredEntries = entries.filter(entry => {
+        const stripped = stripSuffixes(entry.qname, opt);
+        if (queueNames.has(stripped))
+            return false;
+        queueNames.add(stripped);
+        entry.qname = stripped;
+        entry.qrl = stripSuffixes(entry.qrl, opt);
+        return true;
+    });
+    // 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
+        return Promise.all(filteredEntries.map(e => processQueueSet(e.qname, e.qrl, opt)));
+    }
+    // Otherwise, let caller know
+    return 'noQueues';
+}
+exports.idleQueues = idleQueues;
+debug('loaded');

package/commonjs/src/monitor.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Multi-queue monitoring functionaliry
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAggregateData = exports.interpretWildcard = exports.monitor = void 0;
+const sqs_js_1 = require("./sqs.js");
+const cloudWatch_js_1 = require("./cloudWatch.js");
+const defaults_js_1 = require("./defaults.js");
+const qrlCache_js_1 = require("./qrlCache.js");
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)('qdone:monitor');
+/**
+ * Splits a queue name with a single wildcard into prefix and suffix regex.
+ */
+async function monitor(queue, save, options) {
+    if (queue.endsWith('.fifo'))
+        options.fifo = true;
+    const opt = (0, defaults_js_1.getOptionsWithDefaults)(options);
+    const queueName = (0, qrlCache_js_1.normalizeQueueName)(queue, opt);
+    debug({ options, opt, queue, queueName });
+    const data = await getAggregateData(queueName);
+    console.log(data);
+    if (save) {
+        if (opt.verbose)
+            process.stderr.write('Saving to CloudWatch...');
+        await (0, cloudWatch_js_1.putAggregateData)(data);
+        if (opt.verbose)
+            process.stderr.write('done\n');
+    }
+}
+exports.monitor = monitor;
+/**
+ * Splits a queue name with a single wildcard into prefix and suffix regex.
+ */
+function interpretWildcard(queueName) {
+    const [prefix, suffix] = queueName.split('*');
+    // Strip anything that could cause backreferences
+    const safeSuffix = (suffix || '').replace(/[^a-zA-Z0-9_.]+/g, '').replace(/\./g, '\\.');
+    const suffixRegex = new RegExp(`${safeSuffix}$`);
+    // debug({ prefix, suffix, safeSuffix, suffixRegex })
+    return { prefix, suffix, safeSuffix, suffixRegex };
+}
+exports.interpretWildcard = interpretWildcard;
+/**
+ * Aggregates inmportant attributes across queues and reports a summary.
+ * Attributes:
+ *  - ApproximateNumberOfMessages: Sum
+ *  - ApproximateNumberOfMessagesDelayed: Sum
+ *  - ApproximateNumberOfMessagesNotVisible: Sum
+ */
+async function getAggregateData(queueName) {
+    const { prefix, suffixRegex } = interpretWildcard(queueName);
+    const qrls = await (0, sqs_js_1.getMatchingQueues)(prefix, suffixRegex);
+    // debug({ qrls })
+    const data = await (0, sqs_js_1.getQueueAttributes)(qrls);
+    // debug({ data })
+    const total = { totalQueues: 0, contributingQueueNames: new Set() };
+    for (const { queue, result } of data) {
+        // debug({ row })
+        total.totalQueues++;
+        for (const key in result.Attributes) {
+            const newAtrribute = parseInt(result.Attributes[key], 10);
+            if (newAtrribute > 0) {
+                total.contributingQueueNames.add(queue);
+                total[key] = (total[key] || 0) + newAtrribute;
+            }
+        }
+    }
+    // debug({ total })
+    // convert set to array
+    total.contributingQueueNames = [...total.contributingQueueNames.values()];
+    total.queueName = queueName;
+    return total;
+}
+exports.getAggregateData = getAggregateData;
+debug('loaded');

package/commonjs/src/qrlCache.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * A cache for maintaining queue urls. Avoids having to call the GetQueueUrl
+ * api too often.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQnameUrlPairs = exports.getMatchingQueues = exports.ingestQRLs = exports.qrlCacheInvalidate = exports.qrlCacheSet = exports.qrlCacheGet = exports.qrlCacheClear = exports.normalizeDLQName = exports.normalizeFailQueueName = exports.normalizeQueueName = exports.fifoSuffix = void 0;
+const url_1 = require("url");
+const path_1 = require("path");
+const client_sqs_1 = require("@aws-sdk/client-sqs");
+const sqs_js_1 = require("./sqs.js");
+const debug_1 = __importDefault(require("debug"));
+const debug = (0, debug_1.default)('qdone:qrlCache');
+// The actual cache is shared across callers.
+const qcache = new Map();
+//
+// Normalizes a queue name to end with .fifo if opt.fifo is set
+//
+exports.fifoSuffix = '.fifo';
+function normalizeQueueName(qname, opt) {
+    const hasFifo = qname.endsWith(exports.fifoSuffix);
+    const needsFifo = opt.fifo && qname.slice(-1) !== '*';
+    const needsPrefix = !qname.startsWith(opt.prefix);
+    const base = hasFifo ? qname.slice(0, -exports.fifoSuffix.length) : qname;
+    return (needsPrefix ? opt.prefix : '') + base + (needsFifo ? exports.fifoSuffix : '');
+}
+exports.normalizeQueueName = normalizeQueueName;
+//
+// Normalizes fail queue name, appending both --fail-suffix and .fifo depending on opt
+//
+function normalizeFailQueueName(fqname, opt) {
+    const newopt = Object.assign({}, opt, { fifo: false });
+    const base = normalizeQueueName(fqname, newopt); // strip fifo
+    debug({ fqname, base, opt });
+    const needsFail = !base.endsWith(opt.failSuffix);
+    return base + (needsFail ? opt.failSuffix : '') + (opt.fifo ? exports.fifoSuffix : '');
+}
+exports.normalizeFailQueueName = normalizeFailQueueName;
+//
+// Normalizes dlq queue name, appending both --dlq-suffix and .fifo depending on opt
+//
+function normalizeDLQName(dqname, opt) {
+    const newopt = Object.assign({}, opt, { fifo: false });
+    const base = normalizeQueueName(dqname, newopt); // strip fifo
+    const needsDead = !base.endsWith(opt.dlqSuffix);
+    return base + (needsDead ? opt.dlqSuffix : '') + (opt.fifo ? exports.fifoSuffix : '');
+}
+exports.normalizeDLQName = normalizeDLQName;
+//
+// Clear cache
+//
+function qrlCacheClear() {
+    qcache.clear();
+}
+exports.qrlCacheClear = qrlCacheClear;
+//
+// Get QRL (Queue URL)
+// Returns a promise for the queue name
+//
+async function qrlCacheGet(qname) {
+    debug('get', qname, qcache);
+    if (qcache.has(qname))
+        return qcache.get(qname);
+    const client = (0, sqs_js_1.getSQSClient)();
+    const input = { QueueName: qname };
+    const cmd = new client_sqs_1.GetQueueUrlCommand(input);
+    // debug({ cmd })
+    const result = await client.send(cmd);
+    // debug('result', result)
+    if (!result) {
+        qrlCacheInvalidate(qname);
+        throw new client_sqs_1.QueueDoesNotExist(qname);
+    }
+    const { QueueUrl: qrl } = result;
+    // debug('getQueueUrl returned', data)
+    qcache.set(qname, qrl);
+    // debug('qcache', Object.keys(qcache), 'get', qname, ' => ', qcache[qname])
+    return qrl;
+}
+exports.qrlCacheGet = qrlCacheGet;
+//
+// Set QRL (Queue URL)
+// Immediately updates the cache
+//
+function qrlCacheSet(qname, qrl) {
+    if (qrl)
+        qcache.set(qname, qrl);
+    // debug('qcache', Object.keys(qcache), 'set', qname, ' => ', qcache[qname])
+}
+exports.qrlCacheSet = qrlCacheSet;
+//
+// Invalidate cache for given qname
+//
+function qrlCacheInvalidate(qname) {
+    // debug('qcache', Object.keys(qcache), 'delete', qname, ' (was ', qcache[qname], ')')
+    qcache.delete(qname);
+}
+exports.qrlCacheInvalidate = qrlCacheInvalidate;
+//
+// Ingets multiple QRLs
+// Extracts queue names from an array of QRLs and immediately updates the cache.
+//
+function ingestQRLs(qrls) {
+    const pairs = [];
+    debug('ingestQRLs', qrls);
+    for (const qrl of qrls) {
+        const qname = (0, path_1.basename)((new url_1.URL(qrl)).pathname);
+        qrlCacheSet(qname, qrl);
+        pairs.push({ qname, qrl });
+        // debug('qcache', Object.keys(qcache), 'ingestQRLs', qname, ' => ', qcache[qname])
+    }
+    return pairs;
+}
+exports.ingestQRLs = ingestQRLs;
+/**
+ * Returns qrls for queues matching the given prefix and regex.
+ */
+async function getMatchingQueues(prefix, nextToken) {
+    debug('getMatchingQueues', prefix, nextToken);
+    const input = { QueueNamePrefix: prefix, MaxResults: 1000 };
+    if (nextToken)
+        input.NextToken = nextToken;
+    const client = (0, sqs_js_1.getSQSClient)();
+    const command = new client_sqs_1.ListQueuesCommand(input);
+    const result = await client.send(command);
+    debug({ result });
+    const { QueueUrls: qrls, NextToken: keepGoing } = result || {};
+    debug({ qrls, keepGoing });
+    if (keepGoing)
+        (qrls || []).push(...await getMatchingQueues(prefix, keepGoing));
+    return qrls || [];
+}
+exports.getMatchingQueues = getMatchingQueues;
+//
+// Resolves into a flattened aray of {qname: ..., qrl: ...} objects.
+//
+async function getQnameUrlPairs(qnames, opt) {
+    const promises = qnames.map(async function getQueueUrlOrUrls(qname) {
+        if (qname.slice(-1) === '*') {
+            // Wildcard queues support
+            const prefix = qname.slice(0, -1);
+            const queues = await getMatchingQueues(prefix);
+            debug('listQueues return', queues);
+            if (opt.fifo) {
+                // Remove non-fifo queues
+                const filteredQueues = queues.filter(url => url.slice(-exports.fifoSuffix.length) === exports.fifoSuffix);
+                return ingestQRLs(filteredQueues);
+            }
+            else {
+                return ingestQRLs(queues);
+            }
+        }
+        else {
+            // Normal, non wildcard queue support
+            try {
+                return { qname, qrl: await qrlCacheGet(qname) };
+            }
+            catch (err) {
+                if (!(err instanceof client_sqs_1.QueueDoesNotExist))
+                    throw err;
+            }
+        }
+    });
+    // Flatten nested results
+    const results = await Promise.all(promises);
+    return ([].concat.apply([], results)).filter(r => r);
+}
+exports.getQnameUrlPairs = getQnameUrlPairs;
+debug('loaded');