qdone 1.7.0 → 2.0.0-alpha

package/src/idleQueues.js

@@ -1,12 +1,21 @@
+/**
+ * Implementation of checks and caching of checks to determine if queues are idle.
+ */
+import chalk from 'chalk'
+import { getSQSClient } from './sqs.js'
+import { getCloudWatchClient } from './cloudWatch.js'
+import { getOptionsWithDefaults } from './defaults.js'
+import { GetQueueAttributesCommand, DeleteQueueCommand, QueueDoesNotExist } from '@aws-sdk/client-sqs'
+import { GetMetricStatisticsCommand } from '@aws-sdk/client-cloudwatch'
+import { normalizeFailQueueName, getQnameUrlPairs, fifoSuffix } from './qrlCache.js'
+import { getCache, setCache } from './cache.js'
+// const AWS = require('aws-sdk')
 
-const debug = require('debug')('qdone:idleQueues')
-const chalk = require('chalk')
-const qrlCache = require('./qrlCache')
-const cache = require('./cache')
-const AWS = require('aws-sdk')
+import Debug from 'debug'
+const debug = Debug('qdone:idleQueues')
 
 // Queue attributes we check to determine idle
-const attributeNames = [
+export const attributeNames = [
   'ApproximateNumberOfMessages',
   'ApproximateNumberOfMessagesNotVisible',
   'ApproximateNumberOfMessagesDelayed'
@@ -24,58 +33,55 @@ const metricNames = [
   'ApproximateAgeOfOldestMessage'
 ]
 
-function _cheapIdleCheck (qname, qrl, options) {
-  const sqs = new AWS.SQS()
-  return sqs
-    .getQueueAttributes({ AttributeNames: attributeNames, QueueUrl: qrl })
-    .promise()
-    .then(data => {
-      // debug('data', data)
-      const result = data.Attributes
-      result.queue = qname.slice(options.prefix.length)
-      result.idle = attributeNames.filter(k => result[k] === '0').length === attributeNames.length
-      return Promise.resolve({ result, SQS: 1 })
-    })
+/**
+ * Actual SQS call, used in conjunction with cache.
+ */
+export async function _cheapIdleCheck (qname, qrl, opt) {
+  const client = getSQSClient()
+  const cmd = new GetQueueAttributesCommand({ AttributeNames: 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 = attributeNames.filter(k => result[k] === '0').length === attributeNames.length
+  return { result, SQS: 1 }
 }
 
 /**
  * Gets queue attributes from the SQS api and assesses whether queue is idle
  * at this immediate moment.
  */
-function cheapIdleCheck (qname, qrl, options) {
-  if (options['cache-uri']) {
-    const key = 'cheap-idle-check:' + qrl
-    return cache.getCache(key, options).then(cacheResult => {
-      debug({ cacheResult })
-      if (cacheResult) {
-        debug({ action: 'return resolved' })
-        return Promise.resolve({ result: cacheResult, SQS: 0 })
-      } else {
-        // Cache miss, make actual call
-        debug({ action: 'do real check' })
-        return _cheapIdleCheck(qname, qrl, options).then(({ result, SQS }) => {
-          debug({ action: 'setCache', key, result })
-          return cache.setCache(key, result, options).then(ok => {
-            debug({ action: 'return result of set cache', result })
-            return Promise.resolve({ result, SQS })
-          })
-        })
-      }
-    })
+export 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 getCache(key, opt)
+  debug({ cacheResult })
+  if (cacheResult) {
+    debug({ action: 'return resolved' })
+    return { result: cacheResult, SQS: 0 }
   } else {
-    return _cheapIdleCheck(qname, qrl, options)
+    // 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 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, options) {
+export 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 * options['idle-for']),
+    StartTime: new Date(now.getTime() - 1000 * 60 * opt.idleFor),
     EndTime: now,
     MetricName: metricName,
     Namespace: 'AWS/SQS',
@@ -84,16 +90,13 @@ function getMetric (qname, qrl, metricName, options) {
     Statistics: ['Sum']
     // Unit: ['']
   }
-  const cloudwatch = new AWS.CloudWatch()
-  return cloudwatch
-    .getMetricStatistics(params)
-    .promise()
-    .then(data => {
-      debug('getMetric data', data)
-      return Promise.resolve({
-        [metricName]: data.Datapoints.map(d => d.Sum).reduce((a, b) => a + b, 0)
-      })
-    })
+  const client = getCloudWatchClient()
+  const cmd = new 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)
+  }
 }
 
 /**
@@ -107,208 +110,224 @@ function getMetric (qname, qrl, metricName, options) {
  * 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, options) {
+export 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)
-  return cheapIdleCheck(qname, qrl, options)
-    .then(({ result: cheapResult, SQS }) => {
-      debug('cheapResult', cheapResult)
-      // Short circuit further calls if cheap result shows data
-      if (cheapResult.idle === false) {
-        return {
-          queue: qname.slice(options.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
-      return metricNames.reduce((promiseChain, metricName) => {
-        return promiseChain.then((soFar = {
-          queue: qname.slice(options.prefix.length),
-          cheap: cheapResult,
-          idle: true,
-          apiCalls: { SQS: 1, CloudWatch: 0 }
-        }) => {
-          debug('soFar', soFar)
-          // Break out of our call chain if we find one failed check
-          if (soFar.idle === false) return Promise.resolve(soFar)
-          return getMetric(qname, qrl, metricName, options)
-            .then(result => {
-              debug('getMetric result', result)
-              return Object.assign(
-                soFar, // start with soFar object
-                result, // add in our metricName keyed result
-                { idle: result[metricName] === 0 }, // and recalculate idle
-                { apiCalls: {
-                  SQS: soFar.apiCalls.SQS,
-                  CloudWatch: soFar.apiCalls.CloudWatch + 1
-                } }
-              )
-            })
-        })
-      }, Promise.resolve())
-    })
+  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
 }
 
 /**
  * Just deletes a queue.
  */
-function deleteQueue (qname, qrl, options) {
-  const sqs = new AWS.SQS()
-  return sqs.deleteQueue({ QueueUrl: qrl })
-    .promise()
-    .then(result => {
-      debug(result)
-      if (options.verbose) console.error(chalk.blue('Deleted ') + qname.slice(options.prefix.length))
-      return Promise.resolve({
-        deleted: true,
-        apiCalls: { SQS: 1, CloudWatch: 0 }
-      })
-    })
+export async function deleteQueue (qname, qrl, opt) {
+  const cmd = new DeleteQueueCommand({ QueueUrl: qrl })
+  const result = await getSQSClient().send(cmd)
+  debug(result)
+  if (opt.verbose) console.error(chalk.blue('Deleted ') + qname.slice(opt.prefix.length))
+  return {
+    deleted: true,
+    apiCalls: { SQS: 1, CloudWatch: 0 }
+  }
 }
 
 /**
  * Processes a single queue, checking for idle, deleting if applicable.
  */
-function processQueue (qname, qrl, options) {
-  return checkIdle(qname, qrl, options)
-    .then(result => {
-      debug(qname, result)
-      if (result.idle) {
-        if (options.verbose) console.error(chalk.blue('Queue ') + qname.slice(options.prefix.length) + chalk.blue(' has been ') + 'idle' + chalk.blue(' for the last ') + options['idle-for'] + chalk.blue(' minutes.'))
-        // Trigger a delete if the user wants it
-        if (options.delete) {
-          // End this branch of the tree
-          return deleteQueue(qname, qrl, options)
-            .then(deleteResult => Object.assign(result, {
-              deleted: deleteResult.deleted,
-              apiCalls: {
-                SQS: result.apiCalls.SQS + deleteResult.apiCalls.SQS,
-                CloudWatch: result.apiCalls.CloudWatch + deleteResult.apiCalls.CloudWatch
-              }
-            }))
-        }
-      } else {
-        if (options.verbose) console.error(chalk.blue('Queue ') + qname.slice(options.prefix.length) + chalk.blue(' has been ') + 'active' + chalk.blue(' in the last ') + options['idle-for'] + chalk.blue(' minutes.'))
+export 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.blue('Queue ') + qname.slice(opt.prefix.length) + chalk.blue(' has been ') + 'active' + chalk.blue(' in the last ') + opt.idleFor + chalk.blue(' minutes.'))
+    return result
+  }
+
+  // Queue is idle
+  if (opt.verbose) console.error(chalk.blue('Queue ') + qname.slice(opt.prefix.length) + chalk.blue(' has been ') + 'idle' + chalk.blue(' for the last ') + opt.idleFor + chalk.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
       }
-      // End this branch of the tree
-      return Promise.resolve(result)
     })
+    return resultIncludingDelete
+  }
 }
 
 /**
  * Processes a queue and its fail queue, treating them as a unit.
  */
-function processQueuePair (qname, qrl, options) {
+export async function processQueuePair (qname, qrl, opt) {
   const isFifo = qname.endsWith('.fifo')
-  const normalizeOptions = Object.assign({}, options, { fifo: isFifo })
-  const fqname = qrlCache.normalizeFailQueueName(qname, normalizeOptions)
-  const fqrl = qrlCache.normalizeFailQueueName(qrl, normalizeOptions)
-  return checkIdle(qname, qrl, options).then(result => {
-    debug('result', result)
-    if (result.idle) {
-      if (options.verbose) console.error(chalk.blue('Queue ') + qname.slice(options.prefix.length) + chalk.blue(' has been ') + 'idle' + chalk.blue(' for the last ') + options['idle-for'] + chalk.blue(' minutes.'))
-      // Check fail queue if we get a positive result for normal queue
-      return checkIdle(fqname, fqrl, options).then(fresult => {
-        debug('fresult', fresult)
-        if (fresult.idle) {
-          if (options.verbose) console.error(chalk.blue('Queue ') + fqname.slice(options.prefix.length) + chalk.blue(' has been ') + 'idle' + chalk.blue(' for the last ') + options['idle-for'] + chalk.blue(' minutes.'))
-          // Trigger a delete if the user wants it
-          if (options.delete) {
-            // End this branch of the tree
-            return Promise.all([
-              deleteQueue(qname, qrl, options),
-              deleteQueue(fqname, fqrl, options)
-            ]).then(deleteResults =>
-              deleteResults.reduce((a, b) => Object.assign(a, { apiCalls: {
-                SQS: a.apiCalls.SQS + b.apiCalls.SQS,
-                CloudWatch: a.apiCalls.CloudWatch + b.apiCalls.CloudWatch
-              } }), Object.assign(result, { failq: fresult }, { apiCalls: {
-                SQS: result.apiCalls.SQS + fresult.apiCalls.SQS,
-                CloudWatch: result.apiCalls.CloudWatch + fresult.apiCalls.CloudWatch
-              } }))
-            )
-          }
-        } else {
-          if (options.verbose) console.error(chalk.blue('Queue ') + fqname.slice(options.prefix.length) + chalk.blue(' has been ') + 'active' + chalk.blue(' in the last ') + options['idle-for'] + chalk.blue(' minutes.'))
-        }
-        return Promise.resolve(Object.assign(result, { idle: result.idle && fresult.idle, failq: fresult }, { apiCalls: {
+  const normalizeOptions = Object.assign({}, opt, { fifo: isFifo })
+  // Generate fail queue name/url
+  const fqname = normalizeFailQueueName(qname, normalizeOptions)
+  const fqrl = normalizeFailQueueName(qrl, 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.blue('Queue ') + qname.slice(opt.prefix.length) + chalk.blue(' has been ') + 'active' + chalk.blue(' in the last ') + opt.idleFor + chalk.blue(' minutes.'))
+    return result
+  }
+
+  // Queue is idle
+  if (opt.verbose) console.error(chalk.blue('Queue ') + qname.slice(opt.prefix.length) + chalk.blue(' has been ') + 'idle' + chalk.blue(' for the last ') + opt.idleFor + chalk.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
-        } }))
-      })
-        .catch(e => {
-        // Handle the case where the fail queue has been deleted or was never created for some reason
-          if (e.code === 'AWS.SimpleQueueService.NonExistentQueue') {
-            if (options.verbose) console.error(chalk.blue('Queue ') + fqname.slice(options.prefix.length) + chalk.blue(' does not exist.'))
-            if (options.delete) {
-              return deleteQueue(qname, qrl, options)
-                .then(deleteResult => Object.assign(result, {
-                  deleted: deleteResult.deleted,
-                  apiCalls: {
-                    SQS: result.apiCalls.SQS + deleteResult.apiCalls.SQS,
-                    CloudWatch: result.apiCalls.CloudWatch + deleteResult.apiCalls.CloudWatch
-                  }
-                }))
-            } else {
-              return result
-            }
-          } else {
-            throw e
-          }
-        })
-    } else {
-      if (options.verbose) console.error(chalk.blue('Queue ') + qname.slice(options.prefix.length) + chalk.blue(' has been ') + 'active' + chalk.blue(' in the last ') + options['idle-for'] + chalk.blue(' minutes.'))
+        }
+      }
+    )
+
+    // Queue is active
+    const factive = !fresult.idle
+    if (factive) {
+      if (opt.verbose) console.error(chalk.blue('Queue ') + fqname.slice(opt.prefix.length) + chalk.blue(' has been ') + 'active' + chalk.blue(' in the last ') + opt.idleFor + chalk.blue(' minutes.'))
+      return idleCheckResult
     }
-    // End this branch of the tree
-    return result
-  })
+
+    // Queue is idle
+    if (opt.verbose) console.error(chalk.blue('Queue ') + fqname.slice(opt.prefix.length) + chalk.blue(' has been ') + 'idle' + chalk.blue(' for the last ') + opt.idleFor + chalk.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 QueueDoesNotExist)) throw e
+
+    // Fail queue doesn't exist if we get here
+    if (opt.verbose) console.error(chalk.blue('Queue ') + fqname.slice(opt.prefix.length) + chalk.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
+  }
 }
 
 //
 // Resolve queues for listening loop listen
 //
-exports.idleQueues = function idleQueues (queues, options) {
-  if (options.verbose) console.error(chalk.blue('Resolving queues: ') + queues.join(' '))
-  const qnames = queues.map(function (queue) { return options.prefix + queue })
-  return qrlCache
-    .getQnameUrlPairs(qnames, options)
-    .then(function (entries) {
-      debug('qrlCache.getQnameUrlPairs.then')
-      if (options.verbose) {
-        console.error(chalk.blue('  done'))
-        console.error()
-      }
+export async function idleQueues (queues, options) {
+  const opt = getOptionsWithDefaults(options)
+  if (opt.verbose) console.error(chalk.blue('Resolving queues: ') + queues.join(' '))
+  const qnames = queues.map(queue => opt.prefix + queue)
+  const entries = await getQnameUrlPairs(qnames, opt)
+  debug('getQnameUrlPairs.then')
+  if (opt.verbose) {
+    console.error(chalk.blue('  done'))
+    console.error()
+  }
 
-      // Filter out any queue ending in suffix unless --include-failed is set
-      entries = entries
-        .filter(function (entry) {
-          const suf = options['fail-suffix']
-          const sufFifo = options['fail-suffix'] + qrlCache.fifoSuffix
-          const isFail = entry.qname.endsWith(suf)
-          const isFifoFail = entry.qname.endsWith(sufFifo)
-          return options['include-failed'] ? true : (!isFail && !isFifoFail)
-        })
+  // 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 + 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 (entries.length) {
-        if (options.verbose) {
-          console.error(chalk.blue('Checking queues (in this order):'))
-          console.error(entries.map(e =>
-            '  ' + e.qname.slice(options.prefix.length) + chalk.blue(' - ' + e.qrl)
-          ).join('\n'))
-          console.error()
-        }
-        // Check each queue in parallel
-        if (options.unpair) return Promise.all(entries.map(e => processQueue(e.qname, e.qrl, options)))
-        return Promise.all(entries.map(e => processQueuePair(e.qname, e.qrl, options)))
-      }
+  // But only if we have queues to remove
+  if (filteredEntries.length) {
+    if (opt.verbose) {
+      console.error(chalk.blue('Checking queues (in this order):'))
+      console.error(filteredEntries.map(e =>
+        '  ' + e.qname.slice(opt.prefix.length) + chalk.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 Promise.resolve('noQueues')
-    })
+  // Otherwise, let caller know
+  return 'noQueues'
 }
 
 debug('loaded')

package/src/monitor.js

@@ -0,0 +1,53 @@
+/**
+ * Multi-queue monitoring functionaliry
+ */
+
+import { getMatchingQueues, getQueueAttributes } from './sqs.js'
+import Debug from 'debug'
+const debug = Debug('sd:utils:qmonitor:index')
+
+/**
+ * Splits a queue name with a single wildcard into prefix and suffix regex.
+ */
+export 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 }
+}
+
+/**
+ * Aggregates inmportant attributes across queues and reports a summary.
+ * Attributes:
+ *  - ApproximateNumberOfMessages: Sum
+ *  - ApproximateNumberOfMessagesDelayed: Sum
+ *  - ApproximateNumberOfMessagesNotVisible: Sum
+ */
+export async function getAggregateData (queueName) {
+  const { prefix, suffixRegex } = interpretWildcard(queueName)
+  const qrls = await getMatchingQueues(prefix, suffixRegex)
+  // debug({ qrls })
+  const data = await 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
+}
+
+debug('loaded')