Ability to provide insights from Redis Bull Queue data

So I've figured out how to pull the data I need. I'm not saying it's a good method, and I'm open to suggestions; but it seems to work to provide a filtered JSON return with the needed data, without changing how the queue functions.

Here's what it looks like:

// @route   GET /status/:listNum
async function status(req, res) {
  const { listNum = 10} = req.params
  const client = createClient({
    url: `redis://${REDIS_SERVER}:6379`
  });
  try {
      client.on('error', (err) => console.log('Redis Client Error', err));
      await client.connect();
      // Find size of queue database
      const total_keys = await client.sendCommand(['DBSIZE']);
      const upper_value = total_keys;
      const lower_value = total_keys - listNum;
      // Generate array
      const range = (start, stop) => Array.from({ length: (start - stop) + 1}, (_, i) => start - (i));
      var queue_ids = range(upper_value, lower_value)
      queue_ids = queue_ids.filter(function(x){ return x > 0 }); // Filer out anything less than zero
      // Current timestamp in seconds
      const current_timestamp = parseInt(String(new Date().getTime()).slice(0, -3)); // remove microseconds ("now")
      var response = []; // Initialize array
      for(id of queue_ids){ // Loop through queries
        // Query value
        var value = await client.HGETALL('bull:webApi:'+id);
        if(Object.keys(value).length !== 0){ // if returned a value
          // Grab most of the request (exclude the token & socketId to save space, not used)
          var request_data = JSON.parse(value.data)
          request_data.token = '';
          request_data.socketId = '';
          // Grab & calculate desired times
          const processedOn = value.processedOn.slice(0, -3); // remove microseconds ("start")
          const finishedOn = value.finishedOn.slice(0, -3); // remove microseconds ("done")
          const duration = finishedOn - processedOn; // (seconds)
          const elapsedSinceStart = current_timestamp - processedOn;
          const elapsedSinceFinished = current_timestamp - finishedOn;
          // Grab the returnValue
          const return_data = value.returnValue;
          // ignoring queue keys of: opts, priority, delay, name, timestamp
          const object_data = {request_data: request_data, processedOn: processedOn, finishedOn: finishedOn, return_data: return_data, duration: duration, elapsedSinceStart: elapsedSinceStart, elapsedSinceFinished: elapsedSinceFinished }
          response.push(object_data);
        }
      }
      
      res.json(response);

  } catch (error) {
      console.log('ERROR getting status: ', error.message, new Date());
      res.status(500).json({ message: error.message });
  } finally {
    client.quit();
  }
}

It's looping the Redis query, so I wouldn't want to use this for hundreds of keys, but for 10 or even 50 I'm thinking it should work.

For now I've resorted to getting the total number of keys and working backwards:

await client.sendCommand(['DBSIZE']);

In my case it will return a total number slightly higher than the highest key id (~ a handful of status keys), but at least gets close, and then I just filter out any non-responses.

I've looked at ZRANGE a bit, but I can't figure out how to get it to give me the last id. When I have a Redis database (Bull Queue) like this:

If there's a simple Redis command I can run that will return "3", I'd probably use that instead. (since bull:webApi:3 has the highest number)

(In actual use case, this might be 9555 or some high number; I just want to get the highest numbered key that exists.)

For now I'll try using the method I've come up with above.