wurk 1.4.0 → 1.5.0

data/lib/wurk/metrics/history.rb

@@ -2,6 +2,7 @@
 
 require_relative '../middleware'
 require_relative '../pool_checkout'
+require_relative 'accumulator'
 
 module Wurk
   module Metrics
@@ -31,9 +32,10 @@ module Wurk
     # running we keep its bucket around for the retention window measured from
     # *last write*, not from first write. So we EXPIRE unconditionally.
     #
-    # The middleware is hot-path — every successful job pays for it. Writes are
-    # pipelined in a single round-trip per job (1 HINCRBY × 2 + 1 EXPIRE per
-    # bucket × 2 buckets = 6 commands, batched).
+    # The middleware is hot-path — every job pays for it — so it does not touch
+    # Redis at all. Each execution folds into a process-wide Accumulator and
+    # Wurk::Metrics::Flusher writes the whole tree out every FLUSH_INTERVAL, in
+    # the same 6-commands-per-(class, minute) shape the per-job pipeline sent.
     class History
       include Wurk::Middleware::ServerMiddleware
 
@@ -44,6 +46,22 @@ module Wurk
       MINUTE_KEY_PREFIX = 'j|'
       DATE_FORMAT = '%Y%m%d'           # YYYYMMDD — matches Sidekiq's j| key
 
+      # Ceiling on how stale an unflushed counter can be, in seconds. A
+      # constant, never a config knob: it exists to bound the dashboard's lag,
+      # not to be tuned. Sidekiq — the engine these numbers get compared
+      # against — flushes its own process stats on a 10s heartbeat and writes
+      # nothing per job, so this is the tighter of the two. Signed off in
+      # docs/plans/2026/08/06/101-faster-than-sidekiq/00-semantics-signoff.md §2.
+      FLUSH_INTERVAL = 5
+
+      # Process-wide, like Processor::PROCESSED — the counters belong to the
+      # process, not to a middleware instance (the chain builds one per capsule)
+      # and not to a job.
+      ACCUMULATOR = Accumulator.new
+
+      # Hourly buckets are already class-scoped, so their fields are bare.
+      HOUR_FIELDS = %w[p f ms].freeze
+
       def call(_worker, job, _queue)
         klass = job['class']
         started = monotonic_ms
@@ -54,8 +72,11 @@ module Wurk
           result
         ensure
           duration = (monotonic_ms - started).round
-          # Best-effort: a metrics write failure must never propagate into
-          # the job result. The processor already finalized the ack path.
+          # Best-effort: a metrics failure must never propagate into the job
+          # result. The processor already finalized the ack path. Recording is
+          # in-memory now, so what this catches is a bad payload (a `class` that
+          # is not a String) rather than a Redis blip — the Redis half moved to
+          # Flusher, which reports on its own thread.
           begin
             self.class.record(klass, duration, success: success, redis_pool: redis_pool)
           rescue StandardError => e
@@ -65,39 +86,46 @@ module Wurk
       end
 
       class << self
-        # Single Redis round-trip per job. `success: true` → `<klass>|p`;
-        # `success: false` → `<klass>|f`. `<klass>|ms` accumulates total
-        # runtime in milliseconds for *both* outcomes (so an operator can
-        # ask "how much wall-clock time has FooJob consumed?" without
-        # branching on outcome).
-        def record(klass, duration_ms, success:, redis_pool: nil, at: ::Time.now)
+        # No Redis. `success: true` → `<klass>|p`; `success: false` →
+        # `<klass>|f`. `<klass>|ms` accumulates total runtime in milliseconds
+        # for *both* outcomes (so an operator can ask "how much wall-clock time
+        # has FooJob consumed?" without branching on outcome).
+        #
+        # `at:` defaults to nil rather than `::Time.now`: this runs once per job
+        # and the bucket only needs whole UTC minutes, which #minute_bucket
+        # reads straight off the clock as an Integer.
+        def record(klass, duration_ms, success:, redis_pool: nil, at: nil)
           return if klass.nil? || klass.empty?
 
           ms = duration_ms.to_i
           ms = 0 if ms.negative?
-          buckets = { minute: minute_key(at), hour: hour_key(klass, at) }
-          with_pool(redis_pool) { |conn| pipeline_write(conn, klass, ms, success, buckets) }
+          ACCUMULATOR.add(redis_pool, klass, minute_bucket(at), ms, success)
           nil
         end
 
-        # The minute bucket carries per-class `<klass>|p|f|ms` fields; the
-        # hourly bucket is already class-scoped so its fields are bare
-        # `p|f|ms`. Pipeline all 6 commands in one round-trip.
-        def pipeline_write(conn, klass, ms, success, buckets)
-          outcome = success ? 'p' : 'f'
-          class_outcome = "#{klass}|#{outcome}"
-          class_ms = "#{klass}|ms"
-          conn.pipelined do |pipe|
-            incr_bucket(pipe, buckets[:minute], [class_outcome, class_ms, ms, MID_TERM])
-            incr_bucket(pipe, buckets[:hour], [outcome, 'ms', ms, MID_TERM])
+        # Drains an accumulator into Redis, one pipeline per pool. Raises the
+        # first pool's failure after every other pool has had its turn —
+        # Wurk::Metrics::Flusher owns turning that into an error-handler call.
+        #
+        # Only the *failed* pool's counts are merged back. Putting the whole
+        # drained tree back would re-send the writes that already landed, and
+        # HINCRBY would count them twice.
+        #
+        # The argument is a collaborator, not an option: a process has exactly
+        # one accumulator and nothing in wurk passes a second. Tests pass their
+        # own so a deliberately broken pool cannot leak into a parallel test's
+        # flush through the process-wide one.
+        def flush(accumulator = ACCUMULATOR)
+          error = nil
+          accumulator.drain.each do |pool, minutes|
+            write(pool, minutes)
+          rescue StandardError => e
+            accumulator.merge_back(pool, minutes)
+            error = e
           end
-        end
+          raise error if error
 
-        def incr_bucket(pipe, key, parts)
-          outcome_field, ms_field, ms, ttl = parts
-          pipe.call('HINCRBY', key, outcome_field, 1)
-          pipe.call('HINCRBY', key, ms_field, ms)
-          pipe.call('EXPIRE', key, ttl)
+          nil
         end
 
         # Public formatters — Wurk::Metrics::Query reuses these so the two
@@ -112,6 +140,47 @@ module Wurk
           t = time.utc
           "#{klass}-#{t.strftime(DATE_FORMAT)}-#{t.hour}"
         end
+
+        private
+
+        # Whole UTC minutes since the epoch. Integer arithmetic on a raw clock
+        # read, so nothing is allocated per job.
+        def minute_bucket(at)
+          return ::Process.clock_gettime(::Process::CLOCK_REALTIME, :second) / 60 unless at
+
+          at.to_i / 60
+        end
+
+        def write(pool, minutes)
+          with_pool(pool) do |conn|
+            conn.pipelined do |pipe|
+              minutes.each do |minute, classes|
+                at = ::Time.at(minute * 60).utc
+                key = minute_key(at)
+                classes.each { |klass, counts| write_class(pipe, key, at, klass, counts) }
+              end
+            end
+          end
+        end
+
+        def write_class(pipe, bucket_key, at, klass, counts)
+          incr_bucket(pipe, bucket_key, ["#{klass}|p", "#{klass}|f", "#{klass}|ms"], counts)
+          incr_bucket(pipe, hour_key(klass, at), HOUR_FIELDS, counts)
+        end
+
+        # `p`/`f` are emitted only when non-zero, so a bucket ends up with the
+        # exact field set the per-job path produced: `HINCRBY <field> 0` would
+        # materialize a counter no unbatched write ever created, and the read
+        # side would start reporting a `f: 0` series for classes that have never
+        # failed. `ms` is unconditional — the per-job path always incremented
+        # it, including by zero.
+        def incr_bucket(pipe, key, fields, counts)
+          processed, failed, ms = counts
+          pipe.call('HINCRBY', key, fields[0], processed) if processed.positive?
+          pipe.call('HINCRBY', key, fields[1], failed) if failed.positive?
+          pipe.call('HINCRBY', key, fields[2], ms)
+          pipe.call('EXPIRE', key, MID_TERM)
+        end
       end
 
       private

data/lib/wurk/metrics/statsd.rb

@@ -35,6 +35,15 @@ module Wurk
       METRIC_PREFIX = 'sidekiq.'
       DEFAULT_SAMPLE_RATE = 1.0
 
+      # Unresolved state of the {.client} memo, distinct from a resolved nil.
+      UNSET = :unset
+      private_constant :UNSET
+
+      # Seeded in the class body (not `class << self`, where `self` is the
+      # singleton class) so {.client} is a bare ivar read with no `defined?`
+      # guard on the hot path.
+      @client = UNSET
+
       class << self
         attr_accessor :options
 
@@ -91,19 +100,35 @@ module Wurk
         # Resolves the live client: invokes the configured `dogstatsd` proc
         # exactly once per process and memoizes. Returns nil when no proc
         # is configured, so callers get a clean no-op without raising.
+        #
+        # The *unconfigured* answer is memoized too, which is what makes the
+        # no-client path free: Client#emit_enqueued asks once per payload, so
+        # re-reading `Wurk.configuration` here would cost a config lookup per
+        # job on every bulk push. Both invalidation points call {.reset!}.
         def client
-          return @client if defined?(@client) && !@client.nil?
+          memo = @client
+          return memo unless UNSET.equal?(memo)
 
           builder = Wurk.configuration.respond_to?(:dogstatsd) ? Wurk.configuration.dogstatsd : nil
-          return nil if builder.nil?
-
           @client = builder.respond_to?(:call) ? builder.call : builder
         end
 
-        # Test/lifecycle hook. Reset between specs and after fork so the
-        # parent's socket doesn't bleed into children.
+        # {.client} without the raise: a builder proc that blows up is reported
+        # through the error handler and treated as "no client", so misconfigured
+        # metrics can never fail the work they were measuring. Callers on a
+        # hot path use this to skip building anything the emit would drop.
+        def safe_client
+          client
+        rescue StandardError => e
+          handle_error(e)
+          nil
+        end
+
+        # Test/lifecycle hook. Reset between specs, after fork so the parent's
+        # socket doesn't bleed into children, and on every `config.dogstatsd=`
+        # — a memoized nil would otherwise hide a client configured later.
         def reset!
-          @client = nil
+          @client = UNSET
         end
 
         private
@@ -118,8 +143,7 @@ module Wurk
       end
 
       def call(_worker, job, queue) # rubocop:disable Metrics/AbcSize
-        client = safe_client
-        return yield if client.nil?
+        return yield if self.class.safe_client.nil?
 
         klass = job['class']
         opts  = per_job_options(klass, job, queue)
@@ -146,16 +170,6 @@ module Wurk
 
       private
 
-      # Wraps `self.class.client` so a misconfigured builder proc never turns
-      # a metrics-init failure into a job failure. Returns nil on error (the
-      # caller falls through to a plain `yield`).
-      def safe_client
-        self.class.client
-      rescue StandardError => e
-        self.class.send(:handle_error, e)
-        nil
-      end
-
       # Per-spec §9.2: caller-supplied proc may override tags / sample_rate
       # on a per-job basis. The job's own `dd_rate` field, when present,
       # always wins — it's the per-push override hinted in §8.

data/lib/wurk/middleware/chain.rb

@@ -7,9 +7,10 @@ module Wurk
     # pushes to index 0, `insert_before`/`insert_after` anchor relative to an
     # existing entry, `invoke` walks the chain handing the inner block to each.
     #
-    # `retrieve` instantiates a fresh instance per entry on every job — entries
-    # store klass + ctor args, not the live object. This keeps middleware
-    # thread-safe by construction and matches Sidekiq's lifecycle.
+    # Entries store klass + ctor args, not the live object: every job gets a
+    # fresh instance per entry (`invoke` builds each as it reaches it, `retrieve`
+    # builds them all up front). This keeps middleware thread-safe by
+    # construction and matches Sidekiq's lifecycle.
     #
     # Spec: docs/target/sidekiq-free.md §10.1.
     class Chain
@@ -83,23 +84,28 @@ module Wurk
       # Walks the chain inside-out. Each middleware receives a block that
       # advances to the next; the innermost block is the caller's `&block`,
       # whose return value is propagated back out. Empty chain: `yield`.
+      #
+      # Hot path — one job pays this per invocation, so instantiation is folded
+      # into an index walk over `@entries`: no instance array from `retrieve`,
+      # no traversal lambda, and no `shift` (which memmoves the array per entry).
+      # Cost is one allocation per entry (the middleware itself), zero to walk.
       def invoke(*args, &block)
         raise ArgumentError, 'middleware chain requires a block' unless block
         return yield if @entries.empty?
 
-        chain = retrieve
-        traverse = lambda do
-          if chain.empty?
-            block.call
-          else
-            chain.shift.call(*args, &traverse)
-          end
-        end
-        traverse.call
+        traverse(@entries, 0, args, &block)
       end
 
       private
 
+      def traverse(entries, index, args, &block)
+        return yield if index == entries.size
+
+        entries[index].make_new(@config).call(*args) do
+          traverse(entries, index + 1, args, &block)
+        end
+      end
+
       # Custom dup semantics: deep-copy the entries array so a child chain's
       # mutations don't bleed into the parent (or sibling capsules).
       def initialize_copy(orig)
@@ -108,18 +114,29 @@ module Wurk
       end
 
       # Holds the klass + ctor args for a registered middleware. Defers
-      # instantiation until `retrieve` runs so each job gets a fresh object.
+      # instantiation until `retrieve`/`invoke` runs so each job gets a fresh
+      # object.
+      #
+      # Whether the class declares `config=` is resolved once, at registration,
+      # so the common case (the setter comes from `include
+      # Wurk::Middleware::ServerMiddleware`) skips a `respond_to?` on every job
+      # × every entry. It is a fast path, not the rule: the contract is "set
+      # `config` if the instance is respondable" (spec §10.1), which also covers
+      # a setter defined on the singleton in `initialize`, one reached through
+      # `method_missing`, or one added to the class after it was registered — so
+      # a class that does not declare it still gets asked.
       class Entry
         attr_reader :klass
 
         def initialize(klass, *args)
           @klass = klass
           @args = args
+          @takes_config = klass.public_method_defined?(:config=)
         end
 
         def make_new(config = nil)
           instance = @klass.new(*@args)
-          instance.config = config if config && instance.respond_to?(:config=)
+          instance.config = config if config && (@takes_config || instance.respond_to?(:config=))
           instance
         end
       end

data/lib/wurk/middleware/poison_pill.rb

@@ -129,11 +129,32 @@ module Wurk
       # Register a callback fired when a poison pill is detected. Callbacks
       # receive a single Hash `{jid:, klass:, count:, queue:}` — matches
       # Sidekiq Pro's documented shape so consumers can drop in unchanged.
+      #
+      # Dedups by callable identity — an initializer that re-runs (Rails
+      # code reloading, a re-required file) and hands back the *same* stored
+      # Proc each time won't accumulate duplicate closures (and the bindings
+      # they retain). A fresh block literal per call still registers
+      # separately, same as before. Returns a {Registration} the caller can
+      # `#remove!` to deregister explicitly.
       def on_poison(&block)
         raise ArgumentError, 'block required' unless block
 
-        callbacks << block
-        block
+        callbacks << block unless callbacks.any? { |cb| cb.equal?(block) }
+        Registration.new(callbacks, block)
+      end
+
+      # Handle returned by {on_poison}. Removing it is idempotent and safe
+      # even after a {reset!} discarded the underlying list.
+      class Registration
+        def initialize(list, callback)
+          @list = list
+          @callback = callback
+        end
+
+        def remove!
+          @list.delete(@callback)
+          nil
+        end
       end
 
       def callbacks

data/lib/wurk/pool_checkout.rb

@@ -25,5 +25,15 @@ module Wurk
 
       pool.with(idempotent: true, &)
     end
+
+    # Same apply-safety forwarding as .with, minus the is_a? probe. Only for
+    # call sites whose pool is always this process's own {RedisPool} — never a
+    # host-supplied `pool:` kwarg — so the polymorphic check has nothing to
+    # decide.
+    def self.trusted(pool, idempotent, &)
+      return pool.with(&) unless idempotent
+
+      pool.with(idempotent: true, &)
+    end
   end
 end

data/lib/wurk/processor.rb

@@ -10,8 +10,11 @@ require_relative 'profiler'
 module Wurk
   # Inside each Manager, N Processors run in parallel. Each owns one thread,
   # pulls a UnitOfWork from the capsule's fetcher, parses the payload, walks
-  # the server middleware chain, invokes `perform`, then ACKs (removes the
-  # payload from the per-process private list).
+  # the server middleware chain, invokes `perform`, then ACKs (retires the
+  # payload from the per-process private list). The ACK is handed to the
+  # fetcher, which pipelines it with the next fetch rather than spending a
+  # round trip on it — #flush_acks covers the case where there is no next
+  # fetch.
   #
   # Shutdown is two-stage:
   #   * `terminate` flips a flag; the run loop exits between jobs.
@@ -23,6 +26,26 @@ module Wurk
   class Processor
     include Component
 
+    # Interrupt masks for the two `Thread.handle_interrupt` scopes every job
+    # runs inside. Frozen constants rather than the inline literals they
+    # replace: the mask never varies, and a literal allocated two Hashes per
+    # job. Sidekiq hoists the same pair (processor.rb:161-164).
+    IGNORE_SHUTDOWN_INTERRUPTS = { Wurk::Shutdown => :never }.freeze
+    private_constant :IGNORE_SHUTDOWN_INTERRUPTS
+    ALLOW_SHUTDOWN_INTERRUPTS = { Wurk::Shutdown => :immediate }.freeze
+    private_constant :ALLOW_SHUTDOWN_INTERRUPTS
+
+    # Stand-in for the default reloader, `proc { |&b| b.call }`. That default
+    # is an identity wrapper, but a block param (`|&b|`) forces MRI to reify
+    # the dispatch block into a Proc on every job just to call it straight
+    # back; `yield` does not. Same contract, one less allocation per job.
+    module IdentityReloader
+      def self.call
+        yield
+      end
+    end
+    private_constant :IdentityReloader
+
     attr_reader :thread, :job, :capsule
 
     def initialize(capsule, &callback)
@@ -32,7 +55,7 @@ module Wurk
       @done = false
       @job = nil
       @thread = nil
-      @reloader = capsule.config[:reloader] || proc { |&b| b.call }
+      @reloader = resolve_reloader(capsule.config[:reloader])
       @job_logger = (capsule.config[:job_logger] || JobLogger).new(capsule.config)
       @retrier = JobRetry.new(capsule)
     end
@@ -116,6 +139,19 @@ module Wurk
         @lock.synchronize { @work.delete(tid) }
       end
 
+      # RAII: publish for the duration of the block, always retract. The write
+      # lives *inside* this method's ensure frame on purpose — with the `set`
+      # one line above a `begin`, an async raise landing in that gap (a host
+      # timeout's `Thread#raise`, say) escapes the ensure and strands the
+      # entry for the life of the process: the payload String stays reachable
+      # and every heartbeat reports the thread as busy.
+      def track(tid, hash)
+        set(tid, hash)
+        yield
+      ensure
+        delete(tid)
+      end
+
       def dup
         @lock.synchronize { @work.dup }
       end
@@ -136,8 +172,23 @@ module Wurk
 
     private
 
+    # Only the untouched framework default is swapped out — a host-supplied
+    # reloader (Rails wraps every job in `Rails.application.reloader`) is used
+    # exactly as given. `equal?` against DEFAULTS is sound because
+    # Configuration's deep-dup copies Hashes/Arrays only, so an unset
+    # `:reloader` is still the very Proc object DEFAULTS holds.
+    def resolve_reloader(configured)
+      return IdentityReloader if configured.nil? || configured.equal?(Configuration::DEFAULTS[:reloader])
+
+      configured
+    end
+
     def run
-      process_one until @done
+      begin
+        process_one until @done
+      ensure
+        flush_acks
+      end
       @callback&.call(self)
     rescue Wurk::Shutdown
       @callback&.call(self)
@@ -147,6 +198,24 @@ module Wurk
       raise
     end
 
+    # The fetcher holds each finished job's LREM until a fetch can pipeline it
+    # (Fetcher::Reliable#defer_ack). This thread has stopped fetching, so
+    # nothing else will send the one it may still be holding — and a finished
+    # job left in the private list is invisible to Manager#hard_shutdown's
+    # in-flight list, so the next boot's reaper would run it a second time.
+    #
+    # Inside the loop's own ensure rather than the method's: the callback below
+    # drops this Processor from the Manager's pool, which is what lets
+    # Manager#stop return and close the capsule's Redis pool out from under us.
+    # `respond_to?` because a config[:fetch_class] fetcher need not defer, and
+    # the capsule has no fetcher at all if the launcher died before prepare!.
+    def flush_acks
+      fetcher = @capsule.fetcher
+      fetcher.flush_pending_acks if fetcher.respond_to?(:flush_pending_acks)
+    rescue StandardError => e
+      handle_exception(e, { context: 'Error flushing pending acks' })
+    end
+
     def fetch
       @capsule.fetcher.retrieve_work
     rescue Wurk::Shutdown
@@ -166,15 +235,15 @@ module Wurk
 
       # The fetcher never parses, so hand it the jid we just read: the ACK
       # retires this job's poison-pill recovery counter inside the round trip
-      # it already makes. A fetcher plugged in via `config[:fetch_class]` has
-      # no jid slot and simply ACKs — the counter then ages out on its 72h TTL.
+      # it rides. A fetcher plugged in via `config[:fetch_class]` has no jid
+      # slot and simply ACKs — the counter then ages out on its 72h TTL.
       uow.jid = job_hash['jid'] if uow.respond_to?(:jid=)
 
       ack = false
       begin
-        Thread.handle_interrupt(Wurk::Shutdown => :never) do
+        Thread.handle_interrupt(IGNORE_SHUTDOWN_INTERRUPTS) do
           dispatch(job_hash, queue, jobstr) do |instance|
-            Thread.handle_interrupt(Wurk::Shutdown => :immediate) do
+            Thread.handle_interrupt(ALLOW_SHUTDOWN_INTERRUPTS) do
               execute_job(instance, job_hash, queue)
             end
           end
@@ -247,15 +316,14 @@ module Wurk
     # Heartbeat can mirror it into Redis (`<identity>:work`), and increments
     # PROCESSED/FAILURE counters around the inner block.
     def stats(jobstr, queue)
-      WORK_STATE.set(tid, queue: queue, payload: jobstr, run_at: ::Time.now.to_i)
-      begin
+      run_at = ::Process.clock_gettime(::Process::CLOCK_REALTIME, :second)
+      WORK_STATE.track(tid, queue: queue, payload: jobstr, run_at: run_at) do
         yield
       rescue Exception # rubocop:disable Lint/RescueException
         FAILURE.incr
         raise
       ensure
         PROCESSED.incr
-        WORK_STATE.delete(tid)
       end
     end
   end

data/lib/wurk/profiler.rb

@@ -34,11 +34,15 @@ module Wurk
       # from the interrupt/expiry middleware) must propagate untouched so the
       # retry/skip flow works. Only the storage step is made failure-safe
       # (see #safe_store).
-      def call(job_hash, &)
+      # No `&block` parameter: every job passes through here, and declaring one
+      # would reify the caller's block into a Proc even on the `yield`-straight-
+      # through path that opted-out jobs take. The capture path pays for its own
+      # block instead.
+      def call(job_hash)
         label = job_hash['profile']
         return yield unless label && defined?(::Vernier)
 
-        capture(job_hash, label, &)
+        capture(job_hash, label) { yield } # rubocop:disable Style/ExplicitBlockArgument
       end
 
       # Persists a profile. Extracted from capture so it is unit-testable

data/lib/wurk/queue.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative 'fetcher/reliable'
 require_relative 'job_record'
 
 module Wurk
@@ -12,6 +13,11 @@ module Wurk
   # (see `Wurk::Fetcher::Reliable#queues_cmd`). In-flight jobs continue to
   # completion — pausing only stops new fetches.
   #
+  # Fetchers answer from a `PAUSED_TTL` cache rather than re-reading the SET
+  # every pass, so `pause!`/`unpause!` expire this process's copy inline and
+  # other processes pick the change up within the TTL. `paused?` is a reporting
+  # call and always reads Redis.
+  #
   # Spec: docs/target/sidekiq-free.md §19.2, sidekiq-pro.md §6.
   class Queue
     include Enumerable
@@ -58,12 +64,14 @@ module Wurk
     # 0 when the name was already present. In-flight jobs are untouched.
     def pause! # rubocop:disable Naming/PredicateMethod
       Wurk.redis(idempotent: true) { |conn| conn.call('SADD', Keys::PAUSED_SET, @name) }
+      Fetcher::Reliable.invalidate_paused_cache!
       true
     end
 
     # Resume fetches. Idempotent.
     def unpause! # rubocop:disable Naming/PredicateMethod
       Wurk.redis(idempotent: true) { |conn| conn.call('SREM', Keys::PAUSED_SET, @name) }
+      Fetcher::Reliable.invalidate_paused_cache!
       true
     end
 

data/lib/wurk/redis_client_adapter.rb

@@ -37,7 +37,7 @@ module Wurk
 
       # The Redis commands Sidekiq itself uses — defined eagerly so the
       # common ones skip method_missing. Same list as upstream.
-      USED_COMMANDS = %w[bitfield bitfield_ro del exists expire flushdb
+      USED_COMMANDS = %w[bitfield bitfield_ro blmove del exists expire flushdb
                          get hdel hget hgetall hincrby hlen hmget hset hsetnx incr incrby
                          lindex llen lmove lpop lpush lrange lrem mget mset ping pttl
                          publish rpop rpush sadd scard script set sismember smembers

data/lib/wurk/redis_pool.rb

@@ -190,9 +190,9 @@ module Wurk
     # redials a closed socket lazily), so a busy fetcher can't leak checkouts.
     def run(conn, idempotent)
       attempts = 0
+      odometer = conn.round_trips
       begin
         attempts += 1
-        odometer = conn.round_trips
         yield conn
       rescue RedisClient::Error => e
         plan = retry_plan(e, attempts, idempotent, conn.round_trips != odometer)
@@ -204,6 +204,7 @@ module Wurk
 
         safe_close(conn)
         sleep(backoff_delay(attempts)) if plan == :backoff
+        odometer = conn.round_trips
         retry
       end
     end