sidekiq-buffered 0.1.0

data/lib/sidekiq/buffered/script.rb

@@ -0,0 +1,48 @@
+require "digest/sha1"
+
+module Sidekiq
+  module Buffered
+    # One Lua script from scripts/, with the shared helper functions it uses
+    # prepended. Calls go through EVALSHA and fall back to EVAL when Redis has
+    # not seen the script yet.
+    class Script
+      DIRECTORY = File.expand_path("scripts", __dir__)
+
+      def self.load(name, helpers: [])
+        sources = helpers.map { |helper| read("helpers/#{helper}") } << read(name)
+        new(sources.join("\n"))
+      end
+
+      def self.read(name)
+        File.read(File.join(DIRECTORY, "#{name}.lua"))
+      end
+      private_class_method :read
+
+      attr_reader :source, :sha
+
+      def initialize(source)
+        @source = source.freeze
+        @sha = Digest::SHA1.hexdigest(source).freeze
+      end
+
+      def call(conn, keys: [], args: [])
+        conn.call("EVALSHA", sha, keys.size, *keys, *args)
+      rescue RedisClient::CommandError => e
+        raise unless e.message.start_with?("NOSCRIPT")
+
+        conn.call("EVAL", source, keys.size, *keys, *args)
+      end
+
+      # Runs the script once per [keys, args] pair in a single pipeline. SCRIPT
+      # LOAD is idempotent, so loading first avoids NOSCRIPT handling mid-pipeline.
+      def call_each(conn, calls)
+        return [] if calls.empty?
+
+        conn.call("SCRIPT", "LOAD", source)
+        conn.pipelined do |pipeline|
+          calls.each { |keys, args| pipeline.call("EVALSHA", sha, keys.size, *keys, *args) }
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/buffered/scripts/ack.lua

@@ -0,0 +1,5 @@
+local batch_key, lease_key, outstanding_key, failed_key = unpack(KEYS)
+local token, batch_id = unpack(ARGV)
+if redis.call('GET', lease_key) ~= token then return 0 end
+delete_batch(batch_key, lease_key, batch_id, outstanding_key, failed_key)
+return 1

data/lib/sidekiq/buffered/scripts/append.lua

@@ -0,0 +1,64 @@
+-- ARGV[1] is a JSON array of { keys, args } groups; ARGV[2] pins the clock or is ''.
+local now_text = redis_time(ARGV[2])
+local now = tonumber(now_text)
+
+-- Appends one group's items to its buffer and materializes every full batch.
+local function append_group(keys, args)
+  local buffer_key, deadlines_key, batch_seq_key, meta_key, outstanding_key = unpack(keys)
+  local job_class = args[1]
+  local group = args[2]
+  local max_size = tonumber(args[3])
+  local deadline_at = string.format('%.6f', now + tonumber(args[4]))
+  local member = args[5]
+  local batch_prefix = args[6]
+  local meta = args[7]
+  local recover_at = string.format('%.6f', now + tonumber(args[8]))
+  local added = #args - 8
+  -- Items arrive as JSON objects; stamp the Redis admission time into each.
+  local stamp = ',"buffered_at":' .. now_text .. '}'
+  local incoming = {}
+  local add_bytes = 0
+  for i = 9, #args do
+    local item = string.sub(args[i], 1, -2) .. stamp
+    incoming[#incoming + 1] = item
+    add_bytes = add_bytes + #item
+  end
+  local decoded_meta = cjson.decode(meta)
+  local capacity_key = decoded_meta.capacity_key or member
+  -- Per-group counters back Sidekiq::Buffered.stats; they are not caps.
+  local count_key = capacity_key .. ':count'
+  local bytes_key = capacity_key .. ':bytes'
+  if added > 0 then
+    local was_empty = redis.call('LLEN', buffer_key) == 0
+    for first = 1, #incoming, 1000 do
+      redis.call('RPUSH', buffer_key, unpack(incoming, first, math.min(first + 999, #incoming)))
+    end
+    redis.call('HSET', meta_key, member, meta)
+    redis.call('INCRBY', count_key, added)
+    redis.call('INCRBY', bytes_key, add_bytes)
+    if was_empty then
+      redis.call('ZADD', deadlines_key, deadline_at, member)
+    end
+  end
+  local batch = {
+    class = job_class, group = group, max_size = max_size, id_prefix = decoded_meta.id_prefix,
+    prefix = batch_prefix, seq_key = batch_seq_key, outstanding_key = outstanding_key,
+    recover_at = recover_at, lease_timeout = decoded_meta.lease_timeout or 0,
+    count_key = count_key, bytes_key = bytes_key, context = decoded_meta.context,
+  }
+  local flushed = {}
+  while tonumber(redis.call('LLEN', buffer_key)) >= max_size do
+    flushed[#flushed + 1] = materialize_batch(buffer_key, batch)
+  end
+  if redis.call('LLEN', buffer_key) == 0 then
+    redis.call('ZREM', deadlines_key, member)
+    redis.call('HDEL', meta_key, member)
+  end
+  return flushed
+end
+
+local ids = {}
+for _, group in ipairs(cjson.decode(ARGV[1])) do
+  for _, id in ipairs(append_group(group.keys, group.args)) do ids[#ids + 1] = id end
+end
+return ids

data/lib/sidekiq/buffered/scripts/claim.lua

@@ -0,0 +1,29 @@
+local batch_key, lease_key, outstanding_key, failed_key = unpack(KEYS)
+local execution_jid, default_timeout, now, batch_id, lease_token = unpack(ARGV)
+if redis.call('EXISTS', batch_key) == 0 then return false end
+local same_job = redis.call('HGET', batch_key, 'execution_jid') == execution_jid
+if redis.call('HGET', batch_key, 'exhausted') == '1' then
+  -- Only the exhausted processor itself comes back under the same JID,
+  -- through Sidekiq's Dead set retry. Replay the batch for it.
+  if not same_job then return false end
+  redis.call('HDEL', batch_key, 'exhausted', 'owner_token', 'started_at', 'last_error', 'attempts')
+  redis.call('DEL', lease_key)
+  redis.call('ZREM', failed_key, batch_id)
+end
+local timeout = tonumber(redis.call('HGET', batch_key, 'lease_timeout') or '0')
+if timeout <= 0 then timeout = tonumber(default_timeout) end
+local current = redis.call('GET', lease_key)
+local retrying = redis.call('HGET', batch_key, 'state') == 'retrying'
+if current and retrying and same_job then
+  redis.call('SET', lease_key, lease_token, 'EX', timeout)
+elseif redis.call('SET', lease_key, lease_token, 'NX', 'EX', timeout) == false then
+  return false
+end
+redis.call('HSET', batch_key, 'state', 'running', 'started_at', now, 'execution_jid', execution_jid,
+  'owner_token', lease_token)
+redis.call('HDEL', batch_key, 'recovery_checks')
+redis.call('HINCRBY', batch_key, 'attempts', 1)
+redis.call('ZADD', outstanding_key, tonumber(now) + timeout, batch_id)
+local values = redis.call('HMGET', batch_key, 'class', 'group', 'items', 'attempts')
+values[5] = tostring(timeout)
+return values

data/lib/sidekiq/buffered/scripts/cleanup_failed.lua

@@ -0,0 +1,7 @@
+local failed_key, outstanding_key = unpack(KEYS)
+local batch_prefix, lease_prefix, cutoff, limit = unpack(ARGV)
+local ids = redis.call('ZRANGE', failed_key, '-inf', cutoff, 'BYSCORE', 'LIMIT', 0, tonumber(limit))
+for _, id in ipairs(ids) do
+  delete_batch(batch_prefix .. id, lease_prefix .. id, id, outstanding_key, failed_key)
+end
+return ids

data/lib/sidekiq/buffered/scripts/discard.lua

@@ -0,0 +1,7 @@
+local batch_key, lease_key, outstanding_key, failed_key = unpack(KEYS)
+local batch_id = ARGV[1]
+if redis.call('EXISTS', batch_key) == 0 then return -1 end
+if redis.call('HGET', batch_key, 'exhausted') ~= '1' then return 0 end
+local previous_jid = redis.call('HGET', batch_key, 'execution_jid') or ''
+delete_batch(batch_key, lease_key, batch_id, outstanding_key, failed_key)
+return {1, previous_jid}

data/lib/sidekiq/buffered/scripts/exhaust.lua

@@ -0,0 +1,10 @@
+local batch_key, lease_key, outstanding_key, failed_key = unpack(KEYS)
+local batch_id, now, token, error = unpack(ARGV)
+if redis.call('EXISTS', batch_key) == 0 then return 0 end
+if token ~= '' and redis.call('HGET', batch_key, 'owner_token') ~= token then return 0 end
+redis.call('HSET', batch_key, 'exhausted', '1', 'state', 'failed')
+if error ~= '' then redis.call('HSET', batch_key, 'last_error', error) end
+redis.call('DEL', lease_key)
+redis.call('ZREM', outstanding_key, batch_id)
+redis.call('ZADD', failed_key, now, batch_id)
+return 1

data/lib/sidekiq/buffered/scripts/extend.lua

@@ -0,0 +1,7 @@
+-- Heartbeat: extend a lease the caller still owns and push recovery out.
+local lease_key, outstanding_key = unpack(KEYS)
+local token, timeout, recover_at, batch_id = unpack(ARGV)
+if redis.call('GET', lease_key) ~= token then return 0 end
+redis.call('EXPIRE', lease_key, timeout)
+redis.call('ZADD', outstanding_key, 'XX', recover_at, batch_id)
+return 1

data/lib/sidekiq/buffered/scripts/flush_due.lua

@@ -0,0 +1,25 @@
+local buffer_key, deadlines_key, batch_seq_key, meta_key, outstanding_key = unpack(KEYS)
+local member, now, batch_prefix, recover_at, fallback_id_prefix, force = unpack(ARGV)
+now = tonumber(now)
+local due = redis.call('ZSCORE', deadlines_key, member)
+if not due or (force ~= '1' and tonumber(due) > now) then return {} end
+local raw = redis.call('HGET', meta_key, member)
+if not raw then
+  redis.call('ZREM', deadlines_key, member)
+  return {}
+end
+local meta = cjson.decode(raw)
+local capacity_key = meta.capacity_key or member
+local batch = {
+  class = meta.class, group = meta.group, max_size = tonumber(meta.max_size),
+  id_prefix = meta.id_prefix or fallback_id_prefix, prefix = batch_prefix, seq_key = batch_seq_key,
+  outstanding_key = outstanding_key, recover_at = recover_at, lease_timeout = meta.lease_timeout or 0,
+  count_key = capacity_key .. ':count', bytes_key = capacity_key .. ':bytes', context = meta.context,
+}
+local flushed = {}
+while tonumber(redis.call('LLEN', buffer_key)) > 0 do
+  flushed[#flushed + 1] = materialize_batch(buffer_key, batch)
+end
+redis.call('ZREM', deadlines_key, member)
+redis.call('HDEL', meta_key, member)
+return flushed

data/lib/sidekiq/buffered/scripts/helpers/delete_batch.lua

@@ -0,0 +1,21 @@
+-- Deletes a batch and its lease, drops it from both indexes, and returns the
+-- inputs it held to the per-group counters behind Sidekiq::Buffered.stats.
+local function delete_batch(batch_key, lease_key, batch_id, outstanding_key, failed_key)
+  local count_key = redis.call('HGET', batch_key, 'count_key')
+  local bytes_key = redis.call('HGET', batch_key, 'bytes_key')
+  local bytes = tonumber(redis.call('HGET', batch_key, 'bytes') or '0')
+  local raw_items = redis.call('HGET', batch_key, 'items')
+  local count = 0
+  if raw_items then count = #cjson.decode(raw_items) end
+  redis.call('DEL', batch_key, lease_key)
+  redis.call('ZREM', outstanding_key, batch_id)
+  redis.call('ZREM', failed_key, batch_id)
+  if count_key then
+    local left = redis.call('DECRBY', count_key, count)
+    if left <= 0 then redis.call('DEL', count_key) end
+  end
+  if bytes_key then
+    local left = redis.call('DECRBY', bytes_key, bytes)
+    if left <= 0 then redis.call('DEL', bytes_key) end
+  end
+end

data/lib/sidekiq/buffered/scripts/helpers/materialize_batch.lua

@@ -0,0 +1,21 @@
+-- Moves the first max_size buffered items into a new batch hash, registers the
+-- batch for recovery, and returns its id.
+local function materialize_batch(buffer_key, batch)
+  local items = redis.call('LRANGE', buffer_key, 0, batch.max_size - 1)
+  redis.call('LTRIM', buffer_key, batch.max_size, -1)
+  local id = batch.id_prefix .. ':' .. tostring(redis.call('INCR', batch.seq_key))
+  local nbytes = 0
+  for i = 1, #items do
+    nbytes = nbytes + #items[i]
+  end
+  local key = batch.prefix .. id
+  redis.call('HSET', key, 'class', batch.class, 'group', batch.group, 'items', cjson.encode(items),
+    'state', 'queued', 'oldest_at', cjson.decode(items[1]).buffered_at or '',
+    'count_key', batch.count_key, 'bytes_key', batch.bytes_key, 'bytes', nbytes,
+    'lease_timeout', batch.lease_timeout)
+  if batch.context then
+    redis.call('HSET', key, 'dispatch_context', batch.context)
+  end
+  redis.call('ZADD', batch.outstanding_key, batch.recover_at, id)
+  return id
+end

data/lib/sidekiq/buffered/scripts/helpers/redis_time.lua

@@ -0,0 +1,6 @@
+-- Redis time as a '%.6f' string, unless the caller pinned the clock.
+local function redis_time(pinned)
+  if pinned ~= '' then return pinned end
+  local t = redis.call('TIME')
+  return string.format('%.6f', tonumber(t[1]) + (tonumber(t[2]) / 1000000))
+end

data/lib/sidekiq/buffered/scripts/record_dispatch.lua

@@ -0,0 +1,5 @@
+local batch_key = KEYS[1]
+local queue_key, payload = unpack(ARGV)
+if redis.call('EXISTS', batch_key) == 0 then return 0 end
+redis.call('HSET', batch_key, 'queued_key', queue_key, 'queued_payload', payload)
+return 1

data/lib/sidekiq/buffered/scripts/recover.lua

@@ -0,0 +1,21 @@
+local outstanding_key, lease_key, batch_key = unpack(KEYS)
+local batch_id, now, recover_at, max_interval = unpack(ARGV)
+now = tonumber(now)
+if redis.call('EXISTS', batch_key) == 0 or redis.call('HGET', batch_key, 'exhausted') == '1' then
+  redis.call('ZREM', outstanding_key, batch_id)
+  return 0
+end
+local due = redis.call('ZSCORE', outstanding_key, batch_id)
+if not due or tonumber(due) > now then return 0 end
+if redis.call('EXISTS', lease_key) == 1 then return 0 end
+-- Repeated checks back off from recovery_interval towards recovery_max_interval.
+local checks = redis.call('HINCRBY', batch_key, 'recovery_checks', 1)
+local base = tonumber(recover_at) - now
+local delay = math.min(base * 2 ^ math.min(checks - 1, 20), math.max(base, tonumber(max_interval)))
+redis.call('ZADD', outstanding_key, now + delay, batch_id)
+-- A processor still waiting in its queue needs no re-dispatch.
+local queue = redis.call('HGET', batch_key, 'queued_key')
+local payload = redis.call('HGET', batch_key, 'queued_payload')
+if queue and payload and redis.call('LPOS', queue, payload) then return 0 end
+redis.call('HSET', batch_key, 'state', 'queued')
+return 1

data/lib/sidekiq/buffered/scripts/release.lua

@@ -0,0 +1,8 @@
+-- Sidekiq::Shutdown interrupted perform; Sidekiq requeues the same job.
+local batch_key, lease_key, outstanding_key = unpack(KEYS)
+local token, recover_at, batch_id = unpack(ARGV)
+if redis.call('GET', lease_key) ~= token then return 0 end
+redis.call('DEL', lease_key)
+redis.call('HSET', batch_key, 'state', 'queued')
+redis.call('ZADD', outstanding_key, 'XX', recover_at, batch_id)
+return 1

data/lib/sidekiq/buffered/scripts/replay.lua

@@ -0,0 +1,11 @@
+local batch_key, lease_key, outstanding_key, failed_key = unpack(KEYS)
+local batch_id, recover_at = unpack(ARGV)
+if redis.call('EXISTS', batch_key) == 0 then return -1 end
+if redis.call('HGET', batch_key, 'exhausted') ~= '1' then return 0 end
+local previous_jid = redis.call('HGET', batch_key, 'execution_jid') or ''
+redis.call('HDEL', batch_key, 'exhausted', 'execution_jid', 'owner_token', 'started_at', 'last_error', 'attempts')
+redis.call('HSET', batch_key, 'state', 'queued')
+redis.call('DEL', lease_key)
+redis.call('ZREM', failed_key, batch_id)
+redis.call('ZADD', outstanding_key, recover_at, batch_id)
+return {1, previous_jid}

data/lib/sidekiq/buffered/scripts/retrying.lua

@@ -0,0 +1,13 @@
+local batch_key, lease_key, outstanding_key = unpack(KEYS)
+local batch_id, token, delay, now, default_timeout, error = unpack(ARGV)
+if redis.call('EXISTS', batch_key) == 0 then return 0 end
+if redis.call('HGET', batch_key, 'exhausted') == '1' then return 0 end
+if redis.call('HGET', batch_key, 'owner_token') ~= token then return 0 end
+local timeout = tonumber(redis.call('HGET', batch_key, 'lease_timeout') or '0')
+if timeout <= 0 then timeout = tonumber(default_timeout) end
+-- Protect recovery through the latest possible retry time plus the lease timeout.
+local ttl = math.ceil(tonumber(delay)) + timeout
+redis.call('HSET', batch_key, 'state', 'retrying', 'last_error', error)
+redis.call('SET', lease_key, token, 'EX', ttl)
+redis.call('ZADD', outstanding_key, tonumber(now) + ttl, batch_id)
+return 1

data/lib/sidekiq/buffered/scripts/tick.lua

@@ -0,0 +1,10 @@
+-- One round trip for the poller: Redis time, due buffers, due recoveries,
+-- and the next moment anything becomes due.
+local deadlines_key, outstanding_key = unpack(KEYS)
+local now = redis_time(ARGV[1])
+local limit = tonumber(ARGV[2])
+local due_buffers = redis.call('ZRANGE', deadlines_key, '-inf', now, 'BYSCORE', 'LIMIT', 0, limit)
+local due_batches = redis.call('ZRANGE', outstanding_key, '-inf', now, 'BYSCORE', 'LIMIT', 0, limit)
+local next_deadline = redis.call('ZRANGE', deadlines_key, 0, 0, 'WITHSCORES')
+local next_recovery = redis.call('ZRANGE', outstanding_key, 0, 0, 'WITHSCORES')
+return { now, due_buffers, due_batches, next_deadline[2] or '', next_recovery[2] or '' }

data/lib/sidekiq/buffered/scripts.rb

@@ -0,0 +1,23 @@
+require_relative "script"
+
+module Sidekiq
+  module Buffered
+    # Every Store operation is one of these scripts, so each runs atomically.
+    module Scripts
+      APPEND = Script.load("append", helpers: %w[redis_time materialize_batch])
+      FLUSH_DUE = Script.load("flush_due", helpers: %w[materialize_batch])
+      TICK = Script.load("tick", helpers: %w[redis_time])
+      CLAIM = Script.load("claim")
+      EXTEND = Script.load("extend")
+      RELEASE = Script.load("release")
+      ACK = Script.load("ack", helpers: %w[delete_batch])
+      DISCARD = Script.load("discard", helpers: %w[delete_batch])
+      CLEANUP_FAILED = Script.load("cleanup_failed", helpers: %w[delete_batch])
+      RETRYING = Script.load("retrying")
+      EXHAUST = Script.load("exhaust")
+      REPLAY = Script.load("replay")
+      RECORD_DISPATCH = Script.load("record_dispatch")
+      RECOVER = Script.load("recover")
+    end
+  end
+end

data/lib/sidekiq/buffered/server_middleware.rb

@@ -0,0 +1,51 @@
+module Sidekiq
+  module Buffered
+    # Claims the batch before the rest of the server chain runs and acknowledges
+    # it only after the chain succeeds. Keep this middleware first in the chain.
+    class ServerMiddleware
+      def call(worker, job, _queue, &)
+        return yield unless worker.is_a?(Processor)
+
+        execution = Execution.new(job.fetch("args").first, jid: job.fetch("jid"))
+        return unless execution.claim
+
+        worker.execution = execution
+        guard(execution, job, &)
+      end
+
+      private
+
+      def guard(execution, job)
+        record = execution.record
+        Heartbeat.track(record.id, token: execution.token, timeout: record.lease_timeout,
+                                   redis_pool: Sidekiq.redis_pool,)
+        BatchContext.with(record) do
+          yield
+          acknowledge(execution) if execution.performed?
+        end
+        execution.finish
+      rescue Sidekiq::Shutdown
+        # Sidekiq requeues this job under the same JID; let it reclaim immediately.
+        Heartbeat.untrack(record.id)
+        execution.release
+        execution.finish
+        raise
+      rescue StandardError => e
+        # Sidekiq's retry handler takes the execution over through the job
+        # class's retry callbacks, unless retries are off and nothing will run them.
+        if job["retry"] == false
+          execution.exhaust(e)
+          execution.finish
+        end
+        raise
+      ensure
+        Heartbeat.untrack(record.id)
+      end
+
+      def acknowledge(execution)
+        Heartbeat.untrack(execution.batch_id)
+        execution.ack
+      end
+    end
+  end
+end

data/lib/sidekiq/buffered/setter.rb

@@ -0,0 +1,41 @@
+module Sidekiq
+  module Buffered
+    # Setter for buffered job classes. Synchronous execution accepts one input
+    # hash or an explicit batch and bypasses buffering.
+    class Setter < Sidekiq::Job::Setter
+      def initialize(klass, opts)
+        super
+        @buffered_class = klass
+      end
+
+      def perform_inline(*args)
+        args = [Input.normalize_args(@buffered_class.name, args)] if args.size == 1 && args.first.is_a?(Hash)
+        Inline.with { super(*args) }
+      end
+      alias perform_sync perform_inline
+
+      # One client call per perform_bulk so batch_size chunks and accepted JIDs
+      # are handled in Sidekiq::Buffered::Client regardless of Sidekiq version.
+      def perform_bulk(args, **options)
+        client = Client.new(pool: @buffered_class.get_sidekiq_options["pool"])
+        client.push_bulk(@opts.merge({ "class" => @buffered_class, "args" => args }, options))
+      end
+    end
+
+    # Class-level overrides for native Sidekiq::Job classes declaring +buffered+.
+    module NativeJobMethods
+      def set(options)
+        Setter.new(self, options)
+      end
+
+      def perform_inline(*)
+        Setter.new(self, {}).perform_inline(*)
+      end
+      alias perform_sync perform_inline
+
+      def perform_bulk(*, **)
+        Setter.new(self, {}).perform_bulk(*, **)
+      end
+    end
+  end
+end

data/lib/sidekiq/buffered/statistics.rb

@@ -0,0 +1,130 @@
+module Sidekiq
+  module Buffered
+    # On-demand, paginated inspection. Counts can change while the snapshot is read.
+    class Statistics
+      PAGE_SIZE = 100
+      STATES = %w[queued running retrying failed].freeze
+
+      def initialize(store: Buffered.store, now: nil, job_class: nil, group: Buffered::ANY_GROUP)
+        @scope = Scope.new(job_class:, group:)
+        @capacity_keys = {}
+        @store = store
+        @redis_pool = store.redis_pool
+        @now = now || store.now
+        @pending_inputs = 0
+        @oldest_pending_at = nil
+        @oldest_input_at = nil
+        @batches = STATES.to_h { |state| [state.to_sym, 0] }
+      end
+
+      def call
+        read_buffers
+        read_batches(Store::OUTSTANDING, fallback: "queued")
+        read_batches(Store::FAILED, fallback: "failed")
+        outstanding, bytes = capacity_totals
+        {
+          outstanding_inputs: outstanding,
+          stored_bytes: bytes,
+          pending_inputs: @pending_inputs,
+          oldest_pending_age: age(@oldest_pending_at),
+          oldest_input_age: age(@oldest_input_at),
+          batches: @batches,
+        }
+      end
+
+      private
+
+      def read_buffers
+        each_page(Store::DEADLINES) do |keys|
+          entries = @redis_pool.with do |conn|
+            conn.pipelined do |pipeline|
+              keys.each do |key|
+                pipeline.call("LLEN", key)
+                pipeline.call("LINDEX", key, 0)
+                pipeline.call("HGET", Store::META, key)
+              end
+            end
+          end
+          entries.each_slice(3).with_index do |(count, first, raw_meta), index|
+            read_buffer(keys[index], count, first, raw_meta)
+          end
+        end
+      end
+
+      def read_buffer(key, count, first, raw_meta)
+        return unless raw_meta
+
+        meta = Sidekiq.load_json(raw_meta)
+        return unless matches?(meta["class"], meta["group"])
+
+        @pending_inputs += count
+        capacity = meta["capacity_key"] || key
+        @capacity_keys["#{capacity}:count"] = "#{capacity}:bytes"
+        time = first && Sidekiq.load_json(first)["buffered_at"]
+        @oldest_pending_at = earlier(@oldest_pending_at, time)
+        @oldest_input_at = earlier(@oldest_input_at, time)
+      end
+
+      def read_batches(index, fallback:)
+        each_page(index) do |ids|
+          entries = @redis_pool.with do |conn|
+            conn.pipelined do |pipeline|
+              ids.each do |id|
+                pipeline.call("HMGET", @store.batch_key(id), "class", "group", "state", "oldest_at",
+                              "count_key", "bytes_key",)
+              end
+            end
+          end
+          entries.each { |entry| read_batch(entry, fallback:) }
+        end
+      end
+
+      def read_batch(entry, fallback:)
+        klass, group, state, oldest, count_key, bytes_key = entry
+        return unless klass && matches?(klass, group)
+
+        @capacity_keys[count_key] = bytes_key if count_key && bytes_key
+        state ||= fallback
+        @batches[state.to_sym] += 1 if STATES.include?(state)
+        @oldest_input_at = earlier(@oldest_input_at, oldest)
+      end
+
+      def matches?(klass, group)
+        @scope.matches?(klass, Input.decode_group(group))
+      end
+
+      def capacity_totals
+        @capacity_keys.to_a.each_slice(PAGE_SIZE).with_object([0, 0]) do |keys, totals|
+          values = @redis_pool.with { |conn| conn.call("MGET", *keys.flatten) }
+          values.each_slice(2) do |count, bytes|
+            totals[0] += count.to_i
+            totals[1] += bytes.to_i
+          end
+        end
+      end
+
+      def each_page(key)
+        offset = 0
+        loop do
+          members = @redis_pool.with { |conn| conn.call("ZRANGE", key, offset, offset + PAGE_SIZE - 1) }
+          break if members.empty?
+
+          yield members
+          offset += PAGE_SIZE
+          break if members.size < PAGE_SIZE
+        end
+      end
+
+      def earlier(current, value)
+        return current if value.nil? || value == ""
+
+        time = Float(value)
+        current ? [current, time].min : time
+      end
+
+      def age(timestamp)
+        timestamp && [@now - timestamp, 0.0].max
+      end
+    end
+  end
+end