bullpane 0.5.1

package/dist/lua/getTreeNode.lua

@@ -0,0 +1,105 @@
+--[[
+  One node of a flow tree: the job's own fields, its state, and the KEYS of its
+  children — in one round trip, without shipping logs or return values.
+
+  Why a script separate from getJob.lua: the tree walk reads many jobs and only
+  needs a handful of fields plus the child keys. getJob HGETALLs the whole hash
+  and LRANGEs the logs, which on a 300-node tree is a lot of bytes for data the
+  graph never renders.
+
+  KEYS[1]      job hash
+  KEYS[2]      `${id}:dependencies` set  (unprocessed children, members are full job keys)
+  KEYS[3]      `${id}:processed` hash    (processed children, fields are full job keys)
+  KEYS[4..11]  state keys in STATE_ORDER:
+               wait, active, completed, failed, delayed, prioritized, paused, waiting-children
+
+  ARGV[1]      job id
+  ARGV[2]      max child keys to return (the rest are counted, not listed)
+
+  Returns nil when the hash does not exist, otherwise
+    { fieldsFlat, state, unprocessedCount, processedCount, childKeys, childrenTruncated }
+
+  `childKeys` mixes unprocessed and processed children; the caller does not need
+  to tell them apart from this list because each child reports its own state.
+  Only this job's own keys are touched, so the call is safe to pipeline per queue
+  on a cluster. Children living in another queue are walked by the caller in a
+  separate, per-queue pipeline.
+]]
+local rcall = redis.call
+local jobKey = KEYS[1]
+
+if rcall("EXISTS", jobKey) == 0 then
+  return nil
+end
+
+-- Only the fields the tree renders. HMGET keeps a fat `data` payload in Redis.
+local fields = rcall("HMGET", jobKey,
+  "name", "timestamp", "finishedOn", "processedOn",
+  "attemptsMade", "failedReason", "progress", "parentKey", "parent", "opts")
+
+local id = ARGV[1]
+local limit = tonumber(ARGV[2]) or 100
+
+local state = "unknown"
+if rcall("ZSCORE", KEYS[6], id) then state = "completed"
+elseif rcall("ZSCORE", KEYS[7], id) then state = "failed"
+elseif rcall("ZSCORE", KEYS[8], id) then state = "delayed"
+elseif rcall("ZSCORE", KEYS[9], id) then state = "prioritized"
+elseif rcall("ZSCORE", KEYS[11], id) then state = "waiting-children"
+else
+  local function inList(key)
+    local ok, pos = pcall(rcall, "LPOS", key, id)
+    if ok and pos then return true end
+    return false
+  end
+  if inList(KEYS[5]) then state = "active"
+  elseif inList(KEYS[4]) then state = "waiting"
+  elseif inList(KEYS[10]) then state = "paused"
+  end
+end
+
+local unprocessed = rcall("SCARD", KEYS[2])
+local processed = rcall("HLEN", KEYS[3])
+
+-- SSCAN/HSCAN with COUNT rather than SMEMBERS/HKEYS: a fan-out parent can have
+-- tens of thousands of children and we only ever draw `limit` of them.
+local children = {}
+local truncated = 0
+
+if limit > 0 and unprocessed > 0 then
+  local cursor = "0"
+  repeat
+    local res = rcall("SSCAN", KEYS[2], cursor, "COUNT", 200)
+    cursor = res[1]
+    for _, member in ipairs(res[2]) do
+      if #children >= limit then
+        truncated = 1
+        break
+      end
+      children[#children + 1] = member
+    end
+  until cursor == "0" or truncated == 1
+end
+
+if limit > 0 and processed > 0 and truncated == 0 then
+  local cursor = "0"
+  repeat
+    local res = rcall("HSCAN", KEYS[3], cursor, "COUNT", 200)
+    cursor = res[1]
+    -- HSCAN returns field, value, field, value...; the value is the child's
+    -- return value, which we deliberately do not ship.
+    for i = 1, #res[2], 2 do
+      if #children >= limit then
+        truncated = 1
+        break
+      end
+      children[#children + 1] = res[2][i]
+    end
+  until cursor == "0" or truncated == 1
+end
+
+if (unprocessed + processed) > #children then
+  truncated = 1
+end
+
+return { fields, state, unprocessed, processed, children, truncated }

package/dist/lua/queueSetup.lua

@@ -0,0 +1,47 @@
+--[[
+  What Redis knows about how ONE queue is configured, in a single round trip.
+
+  KEYS[1]  meta hash
+  KEYS[2]  `limiter` (worker rate limiter; PTTL > 0 => throttling right now)
+  KEYS[3]  Pro `groups`               zset, status "waiting"
+  KEYS[4]  Pro `groups:limit`         zset, status "limited"
+  KEYS[5]  Pro `groups:max`           zset, status "maxed"
+  KEYS[6]  Pro `groups:paused`        zset, status "paused"
+  KEYS[7]  Pro `groups:active:count`  hash  gid -> active jobs (only when the worker sets group.concurrency)
+  KEYS[8]  Pro `groups:metas`         zset  gids with per-group overrides (concurrency / rate limit)
+  KEYS[9]  metrics:completed hash (exists => the worker collects metrics)
+
+  Returns:
+    [1] HGETALL meta (flat field/value array)
+    [2] PTTL limiter (-2 when the key does not exist)
+    [3..6] ZCARD of the four status zsets (waiting, limited, maxed, paused)
+    [7] HLEN groups:active:count
+    [8] ZCARD groups:metas
+    [9] EXISTS metrics:completed
+
+  Everything here is O(1) except HGETALL on the tiny meta hash. Cluster safe: one queue.
+  Worker-side options (worker concurrency, batch size) are NOT in Redis; the caller
+  reports them as unknown instead of guessing.
+]]
+local rcall = redis.call
+
+-- A layout change in Pro must degrade to 0, never to a WRONGTYPE error.
+local function card(key)
+  local ok, n = pcall(rcall, "ZCARD", key)
+  if ok then return n end
+  local ok2, m = pcall(rcall, "SCARD", key)
+  if ok2 then return m end
+  return 0
+end
+
+local out = {}
+out[1] = rcall("HGETALL", KEYS[1])
+out[2] = rcall("PTTL", KEYS[2])
+out[3] = card(KEYS[3])
+out[4] = card(KEYS[4])
+out[5] = card(KEYS[5])
+out[6] = card(KEYS[6])
+out[7] = rcall("HLEN", KEYS[7])
+out[8] = card(KEYS[8])
+out[9] = rcall("EXISTS", KEYS[9])
+return out

package/dist/lua/queueStats.lua

@@ -0,0 +1,140 @@
+--[[
+  Counts + flags for ONE queue in a single round trip.
+
+  KEYS[1..8]  state keys in STATE_ORDER:
+              wait, active, completed, failed, delayed, prioritized, paused, waiting-children
+  KEYS[9]     meta hash
+  KEYS[10]    Pro `groups` zset
+  KEYS[11]    metrics:completed:data list
+  KEYS[12]    metrics:failed:data list
+  KEYS[13]    metrics:completed hash  (field `count`, cumulative since forever)
+  KEYS[14]    metrics:failed hash
+  KEYS[15]    `repeat` zset (job schedulers)
+  KEYS[16]    `stalled` SET (ids marked as stalled by the StalledCheck)
+
+  ARGV[1]     withMetrics "1" | "0"
+  ARGV[2]     number of metric points (newest N minutes)
+  ARGV[3]     window start (unix ms) for the success/failure rate ZCOUNTs
+  ARGV[4]     `${prefix}:${queue}:` (to read a job's opts and detect retention)
+
+  Returns a flat array:
+    [1..8]  counts (LLEN for lists, ZCARD for zsets)
+    [9]     1 when the queue is paused (meta.paused exists)
+    [10]    1 when the queue shows a BullMQ Pro signal (any group status zset,
+            groups:metas, or meta.version "bullmq-pro:x")
+    [11]    groups with jobs = sum of the four status zsets (see keys.ts)
+    [12]    completed metric points, newest first (empty when withMetrics = 0)
+    [13]    failed metric points, newest first
+    [14]    ZCOUNT completed since ARGV[3]  (scores are finishedOn timestamps; O(log N))
+    [15]    ZCOUNT failed since ARGV[3]
+    [16]    meta.version ("bullmq:5.x" / "bullmq-pro:7.x") or false
+    [17]    `opts` of the newest job in completed, or false. Only used to find out
+            whether the queue uses removeOnComplete: with aggressive retention the
+            zset counts lie, and the caller has to warn the user.
+    [20]    ZCARD `repeat` — how many job schedulers the queue has. A ZCARD is O(1),
+            so it fits here and the Schedulers tab badge costs no extra round trip.
+    [21]    SCARD `stalled` — jobs that lost their lock. Cost: ONE more O(1) command
+            in the same EVALSHA (no extra round trip to Redis). Worth the budget
+            because it is the only way for the `active` tab to say "3 of these hung";
+            without it the operator sees "active 8" and cannot tell half are dead.
+
+  Cluster safe: every key belongs to the same queue (same hash tag).
+  Read only: the legacy "0:" wait-list marker is skipped, never popped.
+]]
+local rcall = redis.call
+
+-- Lists may carry a deprecated "0:<ts>" marker at the tail (BullMQ v4 -> v5 migration).
+-- It is not a job, so it is excluded from the count.
+local function listCount(key)
+  local n = rcall("LLEN", key)
+  if n > 0 then
+    local last = rcall("LINDEX", key, -1)
+    if last and string.sub(last, 1, 2) == "0:" then
+      n = n - 1
+    end
+  end
+  return n
+end
+
+local out = {}
+out[1] = listCount(KEYS[1])              -- wait
+out[2] = rcall("LLEN", KEYS[2])          -- active
+out[3] = rcall("ZCARD", KEYS[3])         -- completed
+out[4] = rcall("ZCARD", KEYS[4])         -- failed
+out[5] = rcall("ZCARD", KEYS[5])         -- delayed
+out[6] = rcall("ZCARD", KEYS[6])         -- prioritized
+out[7] = listCount(KEYS[7])              -- paused
+out[8] = rcall("ZCARD", KEYS[8])         -- waiting-children
+
+out[9] = rcall("HEXISTS", KEYS[9], "paused")
+
+-- Pro detection + group count. A group sits in exactly ONE of four status zsets
+-- (`groups` = waiting, groups:limit, groups:max, groups:paused — see keys.ts), so
+-- "how many groups" is the sum of their ZCARDs and a queue whose groups are all
+-- maxed has no `groups` key at all. groups:metas (per-group overrides) and
+-- meta.version = "bullmq-pro:x" also mark a Pro queue, so an idle one still shows
+-- as Pro. The three extra zsets hang off ARGV[4] (same queue, same hash tag):
+-- three more O(1) commands in the same EVALSHA, no extra round trip.
+local function card(key)
+  local ok, n = pcall(rcall, "ZCARD", key)
+  if ok then return n end
+  return 0
+end
+local version = rcall("HGET", KEYS[9], "version")
+local groupsCount = card(KEYS[10])
+  + card(ARGV[4] .. "groups:limit")
+  + card(ARGV[4] .. "groups:max")
+  + card(ARGV[4] .. "groups:paused")
+local isPro = groupsCount > 0
+  or rcall("EXISTS", ARGV[4] .. "groups:metas") == 1
+  or (version and string.sub(version, 1, 10) == "bullmq-pro") or false
+out[10] = isPro and 1 or 0
+out[11] = groupsCount
+
+if ARGV[1] == "1" then
+  local points = tonumber(ARGV[2]) or 60
+  -- metrics data is LPUSHed by BullMQ, so index 0 is the newest minute.
+  out[12] = rcall("LRANGE", KEYS[11], 0, points - 1)
+  out[13] = rcall("LRANGE", KEYS[12], 0, points - 1)
+else
+  out[12] = {}
+  out[13] = {}
+end
+
+-- Success / failure over a trailing window. completed/failed zset scores are the
+-- finishedOn timestamp, so ZCOUNT is O(log N) regardless of queue size.
+local since = tonumber(ARGV[3]) or 0
+out[14] = rcall("ZCOUNT", KEYS[3], since, "+inf")
+out[15] = rcall("ZCOUNT", KEYS[4], since, "+inf")
+out[16] = version or false
+
+-- Retention: `removeOnComplete` lives in EACH job's opts, not in meta. We read the
+-- opts of ONE job (an HGET on a small hash, O(1)) just to know whether the queue
+-- prunes completed jobs. Without it there is no way to tell "99% success" apart
+-- from "aggressive pruning making the ratio lie".
+-- ARGV[4] = "${prefix}:${queue}:" to build the job hash key.
+out[17] = false
+local newest = rcall("ZREVRANGE", KEYS[3], 0, 0)
+if newest and newest[1] then
+  out[17] = rcall("HGET", ARGV[4] .. newest[1], "opts") or false
+end
+
+-- BullMQ's cumulative counters. They only exist when the Worker was created with
+-- `metrics: { maxDataPoints }`, but when they do they are the ONLY correct source:
+-- they are incremented as each job finishes and never decremented, so
+-- removeOnComplete cannot touch them. The :data list only gains a point when the
+-- minute rolls over, which is why we read the hash and not just the list.
+out[18] = rcall("HGET", KEYS[13], "count") or false
+out[19] = rcall("HGET", KEYS[14], "count") or false
+
+-- Job schedulers (repeatable jobs). They live outside the 8 states, in the `repeat`
+-- zset. ZCARD is O(1), so the count rides along with everything else and the
+-- Schedulers tab starts with the right number without a second round trip to Redis.
+out[20] = rcall("ZCARD", KEYS[15])
+
+-- `stalled` is an auxiliary SET, NOT a state: BullMQ does not expose it in
+-- getState() (a stalled job answers `active`) and it only exists while something is
+-- hung. SCARD is O(1), so the count rides along for free in this script.
+out[21] = rcall("SCARD", KEYS[16])
+
+return out

package/dist/lua/sampleParents.lua

@@ -0,0 +1,65 @@
+--[[
+  Flow detection: sample the newest N jobs of several states and aggregate the
+  queue key of their parent (BullMQ flow children carry `parentKey` and a
+  `parent` JSON {id, queueKey} in their hash).
+
+  KEYS[1..n]   state keys to sample
+  ARGV[1]      per-state sample size N
+  ARGV[2]      queue key prefix `${prefix}:${queue}:`
+  ARGV[3..]    "list" | "zset" for each KEYS[i]  (ARGV[2 + i])
+
+  Returns { sampled, pairs } where pairs = { parentQueueKey1, count1, parentQueueKey2, count2, ... }
+
+  Cost: at most n * N HMGETs, all inside Redis, one round trip. The caller caches.
+]]
+local rcall = redis.call
+local n = tonumber(ARGV[1])
+local qprefix = ARGV[2]
+
+local counts = {}
+local order = {}
+local sampled = 0
+
+for i = 1, #KEYS do
+  local kind = ARGV[2 + i]
+  local ids
+  if kind == "list" then
+    ids = rcall("LRANGE", KEYS[i], 0, n - 1)
+  else
+    ids = rcall("ZREVRANGE", KEYS[i], 0, n - 1)
+  end
+  for _, id in ipairs(ids) do
+    if string.sub(id, 1, 2) ~= "0:" then
+      local vals = rcall("HMGET", qprefix .. id, "parentKey", "parent")
+      sampled = sampled + 1
+      local qk = nil
+      if vals[2] then
+        -- preferred: parent JSON carries the queue key verbatim
+        local ok, parsed = pcall(cjson.decode, vals[2])
+        if ok and type(parsed) == "table" and type(parsed.queueKey) == "string" then
+          qk = parsed.queueKey
+        end
+      end
+      if not qk and vals[1] then
+        -- fallback: parentKey is `${prefix}:${queue}:${id}`; drop the trailing `:id`
+        local cut = string.match(vals[1], "^(.*):[^:]+$")
+        if cut then qk = cut end
+      end
+      if qk then
+        if not counts[qk] then
+          counts[qk] = 0
+          order[#order + 1] = qk
+        end
+        counts[qk] = counts[qk] + 1
+      end
+    end
+  end
+end
+
+local out = {}
+for _, qk in ipairs(order) do
+  out[#out + 1] = qk
+  out[#out + 1] = counts[qk]
+end
+
+return { sampled, out }

package/dist/lua/searchJobs.lua

@@ -0,0 +1,146 @@
+--[[
+  Bounded, resumable substring search over the jobs of one state.
+
+  KEYS[1]     the state key (list or zset)
+
+  ARGV[1]     "list" | "zset"
+  ARGV[2]     cursor: index (newest = 0) of the first job to inspect
+  ARGV[3]     batch: max number of job hashes inspected in THIS call (maxScanPerCall)
+  ARGV[4]     needle, already lower-cased by the caller
+  ARGV[5]     limit: stop early once this many matches are found
+  ARGV[6]     queue key prefix `${prefix}:${queue}:`
+  ARGV[7]     previewBytes (same truncation as getJobs)
+  ARGV[8]     maxFieldBytes: a `data` field longer than this is NOT read or searched
+              (HSTRLEN first). The job still matches on id / name / failedReason
+              and is counted in `skipped` so the UI can say so.
+  ARGV[9]     byteBudget: stop the call once this many payload bytes were copied
+              into Lua, even if `batch` hashes were not reached. The cursor comes
+              back as usual and the UI keeps streaming.
+  ARGV[10..]  hash fields to HMGET (must include name, data, failedReason)
+
+  Returns { matches, nextCursor, scanned, total, skipped }
+    matches     rows shaped exactly like getJobs.lua rows (…, dataTruncated, dataBytes)
+    nextCursor  index to pass back next time, or -1 when the state is exhausted
+    scanned     hashes inspected in this call
+    skipped     hashes whose data was over maxFieldBytes and not searched
+
+  The match is a plain (non-pattern) case-insensitive string.find over id, name,
+  data and failedReason, each field on its own (no concatenated haystack: every
+  `..` on a 1 MB string is another 1 MB copy). Two bounds make the cost of ONE
+  call independent of both queue size and payload size: at most `batch` hashes
+  and at most `byteBudget` payload bytes. Before them a search over 1000 × 1 MB
+  jobs kept Redis busy for 13 s; with them a call is a few milliseconds.
+]]
+local rcall = redis.call
+local key = KEYS[1]
+local kind = ARGV[1]
+local cursor = tonumber(ARGV[2])
+local batch = tonumber(ARGV[3])
+local needle = ARGV[4]
+local limit = tonumber(ARGV[5])
+local qprefix = ARGV[6]
+local previewBytes = tonumber(ARGV[7])
+local maxFieldBytes = tonumber(ARGV[8])
+local byteBudget = tonumber(ARGV[9])
+
+local fields = {}
+for i = 10, #ARGV do fields[#fields + 1] = ARGV[i] end
+local SKIP = "\0skip"
+
+local dataIdx, retIdx, nameIdx, reasonIdx = nil, nil, nil, nil
+for i, f in ipairs(fields) do
+  if f == "data" then dataIdx = i end
+  if f == "returnvalue" then retIdx = i end
+  if f == "name" then nameIdx = i end
+  if f == "failedReason" then reasonIdx = i end
+end
+
+local total
+local ids
+-- id -> raw score string, zsets only (delayed: when the job becomes runnable)
+local scores = {}
+if kind == "list" then
+  total = rcall("LLEN", key)
+  ids = rcall("LRANGE", key, cursor, cursor + batch - 1)   -- head = newest
+else
+  total = rcall("ZCARD", key)
+  local flat = rcall("ZREVRANGE", key, cursor, cursor + batch - 1, "WITHSCORES") -- highest score = newest
+  ids = {}
+  for i = 1, #flat, 2 do
+    ids[#ids + 1] = flat[i]
+    scores[flat[i]] = flat[i + 1]
+  end
+end
+
+local matches = {}
+local scanned = 0
+local found = 0
+local skipped = 0
+local bytes = 0
+local stoppedEarly = false
+
+local function has(hay, needle)
+  return hay and string.find(string.lower(hay), needle, 1, true) ~= nil
+end
+
+for _, id in ipairs(ids) do
+  scanned = scanned + 1
+  if string.sub(id, 1, 2) ~= "0:" then
+    local hkey = qprefix .. id
+    local dataBytes = dataIdx and rcall("HSTRLEN", hkey, "data") or 0
+    local retBytes = retIdx and rcall("HSTRLEN", hkey, "returnvalue") or 0
+    local skipData = dataIdx and dataBytes > maxFieldBytes
+    local want = fields
+    if skipData or (retIdx and retBytes > maxFieldBytes) then
+      want = {}
+      for i = 1, #fields do want[i] = fields[i] end
+      if skipData then want[dataIdx] = SKIP end
+      if retIdx and retBytes > maxFieldBytes then want[retIdx] = SKIP end
+    end
+    local vals = rcall("HMGET", hkey, unpack(want))
+    local alive = false
+    for i = 1, #vals do
+      if vals[i] then alive = true break end
+    end
+    if alive then
+      if skipData then skipped = skipped + 1 else bytes = bytes + dataBytes end
+      local hit = has(id, needle)
+        or (nameIdx and has(vals[nameIdx], needle))
+        or (dataIdx and not skipData and has(vals[dataIdx], needle))
+        or (reasonIdx and has(vals[reasonIdx], needle))
+      if hit then
+        local truncated = 0
+        if dataIdx and dataBytes > previewBytes then
+          if vals[dataIdx] then vals[dataIdx] = string.sub(vals[dataIdx], 1, previewBytes) end
+          truncated = 1
+        end
+        if retIdx and vals[retIdx] and #vals[retIdx] > previewBytes then
+          vals[retIdx] = string.sub(vals[retIdx], 1, previewBytes)
+        end
+        local row = { id }
+        for i = 1, #vals do row[#row + 1] = vals[i] end
+        row[#row + 1] = truncated
+        row[#row + 1] = dataBytes
+        row[#row + 1] = scores[id] or false
+        matches[#matches + 1] = row
+        found = found + 1
+        if found >= limit then
+          stoppedEarly = true
+          break
+        end
+      end
+      if bytes >= byteBudget then
+        stoppedEarly = true
+        break
+      end
+    end
+  end
+end
+
+local nextCursor = cursor + scanned
+-- Exhausted when we walked past the end of the state and did not stop early.
+if not stoppedEarly and (#ids < batch or nextCursor >= total) then
+  nextCursor = -1
+end
+
+return { matches, nextCursor, scanned, total, skipped }

package/dist/lua/windowMetrics.lua

@@ -0,0 +1,167 @@
+--[[
+  "What finished in the last W minutes" for ONE queue, from BullMQ's own
+  metrics, plus a bounded processing-time sample. One round trip, read only.
+
+  WHY THE :data LISTS AND NOT ZCOUNT. The completed/failed zsets only hold what
+  retention left behind: with `removeOnComplete` a healthy queue reads as a
+  failing one (300 ok / 15 failed = 4.8% real reads as 23.1% by ZCOUNT).
+  BullMQ's metrics are written as each job finishes and pruning never touches
+  them.
+
+  HOW BULLMQ WRITES THEM (commands/includes/collectMetrics.lua). Per side
+  (completed / failed) there is a hash { count, prevTS, prevCount } and a list:
+    - every finished job does HINCRBY count
+    - when a job finishes in a LATER minute than prevTS, the jobs counted since
+      prevTS (count - prevCount) are LPUSHed, followed by one 0 per idle minute,
+      and prevTS/prevCount move to now
+  So, with m0 = floor(prevTS / 60000):
+    - `count - prevCount` jobs finished in minute m0 and are not in the list yet
+    - list index i holds minute m0 - 1 - i
+    - minutes after m0, up to now, had no finished job (a finish would have
+      flushed), so they are known zeros
+  Nothing is extrapolated and no history is kept on our side: the window is
+  exact to the minute from the first read, including right after a restart.
+
+  KEYS[1]  metrics:completed hash
+  KEYS[2]  metrics:failed hash
+  KEYS[3]  metrics:completed:data list
+  KEYS[4]  metrics:failed:data list
+  KEYS[5]  completed zset (score = finishedOn)
+
+  ARGV[1]  now, unix ms (the server's clock; minute granularity absorbs skew)
+  ARGV[2]  rate windows in minutes, comma separated ("" = none)
+  ARGV[3]  duration windows in minutes, comma separated ("" = none)
+  ARGV[4]  max completed jobs to read for durations (bounded by the caller)
+  ARGV[5]  `${prefix}:${queue}:` to build job hash keys
+
+  Returns:
+    [1] 1 when either metrics hash exists, else 0 (the Worker has no `metrics`)
+    [2] flat { completed, failed, coveredMinutes } per rate window, in ARGV[2] order
+    [3] flat { sampled, p50Ms, p95Ms } per duration window, in ARGV[3] order
+        (p50/p95 are -1 when nothing was sampled)
+
+  Cost: 2 HMGET + at most 2 LRANGE of max(window) small integers, and for
+  durations 1 ZREVRANGEBYSCORE + at most ARGV[4] HMGETs of two fields. Every
+  key belongs to this queue (same hash tag), so it is cluster safe.
+]]
+local rcall = redis.call
+
+local function csv(s)
+  local out = {}
+  for part in string.gmatch(s or "", "[^,]+") do
+    local n = tonumber(part)
+    if n and n > 0 then out[#out + 1] = math.floor(n) end
+  end
+  return out
+end
+
+local now = tonumber(ARGV[1])
+local nowMin = math.floor(now / 60000)
+local rateWindows = csv(ARGV[2])
+local durationWindows = csv(ARGV[3])
+
+local maxWindow = 0
+for _, w in ipairs(rateWindows) do
+  if w > maxWindow then maxWindow = w end
+end
+
+-- One side (completed or failed). Returns a reader: window -> total, covered.
+local function side(hashKey, listKey)
+  local h = rcall("HMGET", hashKey, "count", "prevTS", "prevCount")
+  local count = tonumber(h[1])
+  if not count then
+    -- Hash absent. For `failed` this is normal on a queue that never failed
+    -- (BullMQ creates it on the first failure), so it reads as zero, fully
+    -- covered; the caller decides "no metrics" from BOTH sides being absent.
+    return false, function(w) return 0, w end
+  end
+  local prevTS = tonumber(h[2])
+  local prevCount = tonumber(h[3]) or 0
+  if not prevTS then
+    -- Written by a BullMQ that sets count before prevTS: all of it is "now".
+    return true, function(w) return count, w end
+  end
+  local m0 = math.floor(prevTS / 60000)
+  local ref = nowMin
+  if m0 > ref then ref = m0 end -- a worker clock ahead of ours
+  local pending = count - prevCount
+
+  -- Read the list once, for the widest window.
+  local points = {}
+  local need = m0 - (ref - maxWindow + 1)
+  if need > 0 then points = rcall("LRANGE", listKey, 0, need - 1) end
+
+  return true, function(w)
+    local startMin = ref - w + 1
+    if m0 < startMin then return 0, w end -- nothing finished inside the window
+    local total = pending
+    local covered = ref - m0 + 1
+    local n = m0 - startMin
+    if n > #points then n = #points end
+    for i = 1, n do
+      total = total + (tonumber(points[i]) or 0)
+    end
+    covered = covered + n
+    if covered > w then covered = w end
+    return total, covered
+  end
+end
+
+local hasCompleted, completedIn = side(KEYS[1], KEYS[3])
+local hasFailed, failedIn = side(KEYS[2], KEYS[4])
+
+local rates = {}
+for _, w in ipairs(rateWindows) do
+  local c, cc = completedIn(w)
+  local f, fc = failedIn(w)
+  local covered = cc
+  if fc < covered then covered = fc end
+  rates[#rates + 1] = c
+  rates[#rates + 1] = f
+  rates[#rates + 1] = covered
+end
+
+-- Processing time: newest completed jobs inside the widest duration window.
+local durations = {}
+if #durationWindows > 0 then
+  local widest = 0
+  for _, w in ipairs(durationWindows) do
+    if w > widest then widest = w end
+  end
+  local limit = tonumber(ARGV[4]) or 100
+  local ids = rcall("ZREVRANGEBYSCORE", KEYS[5], "+inf", now - widest * 60000, "LIMIT", 0, limit)
+  -- { finishedOn, duration } newest first
+  local sampled = {}
+  for _, id in ipairs(ids) do
+    local v = rcall("HMGET", ARGV[5] .. id, "processedOn", "finishedOn")
+    local p, f = tonumber(v[1]), tonumber(v[2])
+    if p and f and f >= p then sampled[#sampled + 1] = { f, f - p } end
+  end
+
+  local function pct(sorted, q)
+    local idx = math.ceil(q / 100 * #sorted)
+    if idx < 1 then idx = 1 end
+    return sorted[idx]
+  end
+
+  for _, w in ipairs(durationWindows) do
+    local since = now - w * 60000
+    local ds = {}
+    for _, s in ipairs(sampled) do
+      if s[1] >= since then ds[#ds + 1] = s[2] end
+    end
+    table.sort(ds)
+    durations[#durations + 1] = #ds
+    if #ds > 0 then
+      durations[#durations + 1] = pct(ds, 50)
+      durations[#durations + 1] = pct(ds, 95)
+    else
+      durations[#durations + 1] = -1
+      durations[#durations + 1] = -1
+    end
+  end
+end
+
+local has = 0
+if hasCompleted or hasFailed then has = 1 end
+return { has, rates, durations }