wurk 0.0.4 → 1.0.0

data/lib/wurk/metrics/queue_rollup.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require_relative '../component'
+require_relative '../keys'
+require_relative '../job_record'
+require_relative 'rollup'
+
+module Wurk
+  module Metrics
+    # Leader-only background thread that snapshots each queue's current depth
+    # (LLEN) and head-of-line latency into compact per-queue gauge buckets the
+    # dashboard's "queue size / latency over time" charts read directly:
+    #
+    #   qm|1m|<epoch>   HASH {<queue>|sz, <queue>|lt}   TTL 24h
+    #   qm|5m|<epoch>   HASH {<queue>|sz, <queue>|lt}   TTL 7d
+    #   qm|1h|<epoch>   HASH {<queue>|sz, <queue>|lt}   TTL 30d
+    #
+    # Unlike Metrics::Rollup (which SUMS counters rolled up from a source),
+    # size and latency are GAUGES — point-in-time values — so each tick samples
+    # "now" and writes it to the current bucket at every resolution. Within a
+    # coarse (5m/1h) bucket the per-minute ticks overwrite, so the bucket holds
+    # the latest sample in its window (a "last value" downsample, which is the
+    # right summary for a gauge). Leader-gated so N workers don't each sample
+    # the same queues every minute. `<epoch>` is the UTC start-of-bucket.
+    #
+    # Spec: docs/target/sidekiq-ent.md §5.2 (sidekiq.queue.size /
+    # sidekiq.queue.latency gauges), §7 Historical tab.
+    class QueueRollup
+      include Component
+
+      PREFIX = 'qm'
+      SIZE_KIND = 'sz'
+      LAT_KIND = 'lt'
+
+      # Mirror Metrics::Rollup retention so the dashboard's range selector
+      # (24h·1m / 7d·5m / 30d·1h) maps 1:1 to both the throughput and the
+      # queue-gauge series.
+      BUCKETS = Wurk::Metrics::Rollup::BUCKETS
+
+      DEFAULT_TICK_SECONDS = 60
+
+      def self.bucket_key(bucket, epoch)
+        "#{PREFIX}|#{bucket}|#{epoch}"
+      end
+
+      def initialize(config)
+        @config = config
+        @done = false
+        @mutex = ::Mutex.new
+        @sleeper = ::ConditionVariable.new
+        @tick_interval = config[:metrics_rollup_interval] || DEFAULT_TICK_SECONDS
+        @thread = nil
+      end
+
+      def start
+        @thread ||= safe_thread('queue-metrics') do # rubocop:disable Naming/MemoizedInstanceVariableName
+          wait
+          until @done
+            tick
+            wait
+          end
+        end
+      end
+
+      def terminate
+        @mutex.synchronize do
+          @done = true
+          @sleeper.signal
+        end
+      end
+
+      # Leader-gated: only the elected leader samples, so N workers don't each
+      # HSET the same buckets every minute.
+      def tick(now: ::Time.now)
+        return unless leader?
+
+        sample(now)
+      rescue StandardError => e
+        handle_exception(e, { context: 'queue-metrics' })
+      end
+
+      # One sampling pass, bypassing the leader gate and the sleep loop. Public
+      # so deterministic specs and a manual "sample now" can drive it directly.
+      def sample(now = ::Time.now)
+        gauges = queue_gauges
+        return if gauges.empty?
+
+        fields = gauges.flat_map do |name, (size, lat)|
+          ["#{name}|#{SIZE_KIND}", size, "#{name}|#{LAT_KIND}", lat]
+        end
+        BUCKETS.each do |bucket, (step, ttl)|
+          key = self.class.bucket_key(bucket, (now.to_i / step) * step)
+          redis do |c|
+            c.call('HSET', key, *fields)
+            c.call('EXPIRE', key, ttl)
+          end
+        end
+        nil
+      end
+
+      private
+
+      # [[queue_name, [size, latency_seconds]], ...] for every live queue. The
+      # latency is the head-of-line wait — the tail of the LIST is the oldest
+      # job — in seconds, rounded for compact storage.
+      def queue_gauges
+        now_ms = real_ms
+        redis do |c|
+          names = c.call('SMEMBERS', Keys::QUEUES_SET)
+          next [] if names.empty?
+
+          raw = pipelined_queue_reads(c, names)
+          names.each_with_index.map do |name, i|
+            [name, [raw[i * 2].to_i, head_latency(raw[(i * 2) + 1], now_ms)]]
+          end
+        end
+      end
+
+      # Per queue: LLEN (depth) then LRANGE tail (head-of-line job), in one
+      # round trip. Results interleave [len, [tail], len, [tail], …].
+      def pipelined_queue_reads(conn, names)
+        conn.pipelined do |p|
+          names.each do |q|
+            p.call('LLEN', Keys.queue(q))
+            p.call('LRANGE', Keys.queue(q), -1, -1)
+          end
+        end
+      end
+
+      # A single malformed tail payload (bad JSON, or valid JSON of the wrong
+      # shape) yields 0.0 for that queue rather than bubbling up and skipping
+      # the whole sampling pass for every queue.
+      def head_latency(lrange_result, now_ms)
+        payload = lrange_result.is_a?(::Array) ? lrange_result.first : lrange_result
+        return 0.0 if payload.nil?
+
+        parsed = Wurk.load_json(payload)
+        enqueued_at = parsed.is_a?(::Hash) ? parsed['enqueued_at'] : nil
+        Wurk::JobRecord.latency_from(enqueued_at, now_ms).round(2)
+      rescue ::JSON::ParserError, ::TypeError, ::ArgumentError
+        0.0
+      end
+
+      def wait
+        @mutex.synchronize do
+          @sleeper.wait(@mutex, @tick_interval) unless @done
+        end
+      end
+    end
+  end
+end

data/lib/wurk/metrics/statsd.rb

@@ -194,4 +194,15 @@ module Wurk
       end
     end
   end
+
+  module Middleware
+    # Sidekiq Pro documents the statsd server middleware as
+    # `Sidekiq::Middleware::Server::Statsd` (spec §9.1) — the drop-in snippet is
+    # `require "sidekiq/middleware/server/statsd"; chain.add Sidekiq::Middleware::Server::Statsd`.
+    # Expose that namespace pointing at our implementation. `Sidekiq::Middleware`
+    # aliases `Wurk::Middleware`, so this makes the Sidekiq constant resolve too.
+    module Server
+      Statsd = Wurk::Metrics::Statsd
+    end
+  end
 end

data/lib/wurk/middleware/current_attributes.rb

@@ -25,6 +25,7 @@ module Wurk
           raise ArgumentError, 'persist requires at least one CurrentAttributes class' if classes.empty?
 
           config.client_middleware.add(Save, classes)
+          config.client_middleware.add(Load, classes)
           config.server_middleware.add(Load, classes)
         end
 
@@ -35,9 +36,12 @@ module Wurk
         end
 
         # AS::CurrentAttributes#attributes returns a HashWithIndifferentAccess;
-        # we coerce to a plain Hash so JSON encoding is predictable.
+        # we coerce to a plain Hash so JSON encoding is predictable. `.dup` so
+        # the snapshot is a detached copy — Load holds onto the pre-job state
+        # and must not see it mutated when it restores the job's attributes,
+        # and Save must not alias live attributes into the persisted job hash.
         def snapshot(klass)
-          klass.attributes.to_h
+          klass.attributes.to_h.dup
         end
 
         def restore(klass, attrs)
@@ -64,8 +68,17 @@ module Wurk
       end
 
       # Restores each registered CurrentAttributes class for the duration
-      # of the inner block, then resets so the next job in the thread
-      # starts clean. Reset runs in `ensure` to survive raises and Skip.
+      # of the inner block, then puts back whatever was there before — not a
+      # blanket reset. On a server thread the prior state is empty, so this is
+      # equivalent to resetting; but Load also runs on the CLIENT chain (persist
+      # registers it on both), where an enqueue happens mid-request with
+      # request-scoped attributes already set. Resetting there would wipe the
+      # caller's state right after `perform_async`. Save/restore is what Sidekiq
+      # does and is correct on both chains. Restore runs in `ensure` to survive
+      # raises and Skip.
+      #
+      # Registered on BOTH chains, so `call` takes an optional 4th arg: the
+      # client chain passes a `redis_pool`, the server chain stops at `queue`.
       class Load
         include Wurk::Middleware::ServerMiddleware
 
@@ -73,15 +86,25 @@ module Wurk
           @classes = classes
         end
 
-        def call(_job_or_class, job, _queue)
+        def call(_job_or_class, job, _queue, _redis_pool = nil)
+          previous = @classes.map { |klass| CurrentAttributes.snapshot(klass) }
           @classes.each_with_index do |klass, idx|
             CurrentAttributes.restore(klass, job[CurrentAttributes.key_for(idx)])
           end
           yield
         ensure
-          @classes.each(&:reset)
+          previous&.each_with_index do |attrs, idx|
+            @classes[idx].reset
+            CurrentAttributes.restore(@classes[idx], attrs)
+          end
         end
       end
     end
   end
 end
+
+# Drop-in alias. Sidekiq documents the top-level constant
+# `Sidekiq::CurrentAttributes` (with `.persist` and `Save`/`Load` nested),
+# not the `Middleware::`-namespaced form. Set when this opt-in file is
+# required, so `Sidekiq::CurrentAttributes.persist(MyAttrs)` resolves.
+Sidekiq::CurrentAttributes = Wurk::Middleware::CurrentAttributes if defined?(Sidekiq)

data/lib/wurk/middleware/interrupt_handler.rb

@@ -43,3 +43,8 @@ module Wurk
 end
 
 Wurk.configuration.server_middleware.prepend(Wurk::Middleware::InterruptHandler)
+
+# Sidekiq exposes this middleware as `Sidekiq::Job::InterruptHandler`. Mirror
+# that name onto `Wurk::Job` (aliased to `Sidekiq::Job` in compat) so the
+# drop-in constant resolves. Spec: docs/target/sidekiq-free.md §10.3.
+Wurk::Job::InterruptHandler = Wurk::Middleware::InterruptHandler

data/lib/wurk/middleware/poison_pill.rb

@@ -29,6 +29,12 @@ module Wurk
       KEY_PREFIX = 'super_fetch:recovered:'
       DEAD_RECORD_LIMIT = 100
 
+      # The `pill` handed to a Pro `super_fetch! { |jobstr, pill| }` recovery
+      # callback on the kill path. Responds to .jid/.klass/.count/.queue so a
+      # `pill.jid`-style Pro initializer drops in. `.count` shadows Struct#count
+      # by design — Pro's API names it that. Spec: sidekiq-pro.md §3.1.
+      Pill = ::Struct.new(:jid, :klass, :count, :queue, keyword_init: true) # rubocop:disable Lint/StructNewOverride
+
       module_function
 
       # Called per recovered orphan job. Returns `:poison` when the threshold
@@ -37,23 +43,34 @@ module Wurk
       # here). Emits `jobs.recovered.fetch` on every call, `jobs.poison`
       # only on the kill path.
       #
+      # Fires the Pro `super_fetch!` recovery callback (config.super_fetch_callback)
+      # exactly once per call: `(jobstr, nil)` on plain recovery, `(jobstr, pill)`
+      # on the kill path. The poison-only `on_poison` Hash callbacks fire
+      # independently inside #mark_poison.
+      #
       # @param payload [String, Hash] the job JSON or pre-parsed hash.
       # @param queue   [String, nil] the public queue name (without `queue:`).
+      # @param config  [Configuration] config that owns the super_fetch! callback;
+      #   defaults to the global so non-reaper callers (tests) need not pass it.
       # @return [Symbol] :recovered | :poison
-      def track!(payload, queue: nil)
+      def track!(payload, queue: nil, config: Wurk.configuration)
         job = parse(payload)
-        return :recovered unless job
+        unless job
+          fire_super_fetch(config, payload, nil)
+          return :recovered
+        end
 
         jid = job['jid']
         klass = job['class']
         emit_recovered_fetch(klass, queue)
-        return :recovered if jid.nil? || jid.empty?
 
-        count = bump_counter(jid)
-        if count >= RECOVERY_THRESHOLD
+        count = bump_counter(jid) if jid && !jid.empty?
+        if count && count >= RECOVERY_THRESHOLD
           mark_poison(payload, job, queue: queue, count: count)
+          fire_super_fetch(config, payload, Pill.new(jid: jid, klass: klass, count: count, queue: queue))
           :poison
         else
+          fire_super_fetch(config, payload, nil)
           :recovered
         end
       end
@@ -144,6 +161,19 @@ module Wurk
           Wurk.configuration.handle_exception(e, context: 'Wurk::Middleware::PoisonPill')
         end
       end
+
+      # Invoke the Pro recovery callback registered via config.super_fetch! { }.
+      # No-op unless one is registered. `jobstr` is the raw job JSON so a Pro
+      # `|jobstr, pill|` block sees exactly what Sidekiq Pro hands it.
+      def fire_super_fetch(config, payload, pill)
+        cb = config.super_fetch_callback
+        return unless cb
+
+        jobstr = payload.is_a?(::String) ? payload : Wurk.dump_json(payload)
+        cb.call(jobstr, pill)
+      rescue StandardError => e
+        config.handle_exception(e, context: 'Wurk::Middleware::PoisonPill')
+      end
     end
   end
 end

data/lib/wurk/processor.rb

@@ -5,6 +5,7 @@ require_relative 'context'
 require_relative 'job_logger'
 require_relative 'job_retry'
 require_relative 'keys'
+require_relative 'profiler'
 
 module Wurk
   # Inside each Manager, N Processors run in parallel. Each owns one thread,
@@ -206,14 +207,12 @@ module Wurk
         @retrier.global(jobstr, queue) do
           @job_logger.call(job_hash, queue) do
             stats(jobstr, queue) do
-              @reloader.call do
-                klass = Object.const_get(job_hash['class'])
-                instance = klass.new
-                instance.jid = job_hash['jid']
-                instance.bid = job_hash['bid'] if instance.respond_to?(:bid=)
-                instance._context = self
-                @retrier.local(instance, jobstr, queue) do
-                  yield instance
+              Wurk::Profiler.call(job_hash) do
+                @reloader.call do
+                  instance = build_instance(job_hash)
+                  @retrier.local(instance, jobstr, queue) do
+                    yield instance
+                  end
                 end
               end
             end
@@ -222,6 +221,16 @@ module Wurk
       end
     end
 
+    # Instantiate the worker and wire its per-job context. Extracted from
+    # dispatch so the dispatch onion stays readable.
+    def build_instance(job_hash)
+      instance = Object.const_get(job_hash['class']).new
+      instance.jid = job_hash['jid']
+      instance.bid = job_hash['bid'] if instance.respond_to?(:bid=)
+      instance._context = self
+      instance
+    end
+
     def execute_job(instance, job_hash, queue)
       @capsule.server_middleware.invoke(instance, job_hash, queue) do
         instance.perform(*job_hash['args'])

data/lib/wurk/profile_set.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative 'keys'
+require_relative 'profiler'
+
+module Wurk
+  # Read-only view over stored job profiles (Sidekiq 8.0+ data API, spec §19.8).
+  # `ProfileSet` enumerates the `profiles` ZSET, purging expired members first;
+  # `ProfileRecord` wraps one `<token>-<jid>` HASH.
+  class ProfileSet
+    include Enumerable
+
+    # Snapshot the (non-expired) member keys at construction. ZREMRANGEBYSCORE
+    # drops members whose expiry score has passed before we read the rest.
+    def initialize
+      @keys = Wurk.redis do |conn|
+        conn.call('ZREMRANGEBYSCORE', Keys::PROFILES, '-inf', "(#{::Time.now.to_i}")
+        conn.call('ZRANGE', Keys::PROFILES, 0, -1)
+      end
+    end
+
+    def size = @keys.size
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      Wurk.redis do |conn|
+        @keys.each do |key|
+          raw = conn.call('HGETALL', key)
+          hash = raw.is_a?(Hash) ? raw : raw.each_slice(2).to_h
+          yield ProfileRecord.new(hash) unless hash.empty?
+        end
+      end
+    end
+  end
+
+  # One profile record: the metadata fields of a `<token>-<jid>` HASH plus
+  # lazy access to the gzipped gecko blob. Spec §19.8.
+  class ProfileRecord
+    attr_reader :jid, :type, :token, :size, :elapsed
+
+    def initialize(hash)
+      @hash = hash
+      @jid = hash['jid']
+      @type = hash['type']
+      @token = hash['token']
+      @size = hash['size'].to_i
+      @elapsed = hash['elapsed'].to_i
+    end
+
+    def started_at
+      ts = @hash['started_at']
+      ::Time.at(ts.to_i) unless ts.nil? || ts.empty?
+    end
+
+    def key = Wurk::Profiler.profile_key(@token, @jid)
+
+    # The stored blob is gzipped gecko JSON. `data` returns the raw (gzipped)
+    # bytes — the web layer streams them straight to the browser with a gzip
+    # Content-Encoding. Returns nil if the HASH expired between list and read.
+    def data
+      Wurk.redis { |conn| conn.call('HGET', key, 'data') }
+    end
+  end
+end

data/lib/wurk/profiler.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'zlib'
+require 'stringio'
+require 'tempfile'
+require_relative 'keys'
+
+module Wurk
+  # Job profiling (Sidekiq 8.0+, OSS). When a job is pushed with a `profile`
+  # option, the processor wraps `perform` in a Vernier capture; the resulting
+  # Firefox-profiler (gecko) JSON is gzipped and stored so the dashboard can
+  # hand it to https://profiler.firefox.com for flame-graph inspection.
+  #
+  # Redis schema (spec §1.7), wire-compat with Sidekiq's Profiles pane:
+  #
+  #   profiles            ZSET   member = "<token>-<jid>", score = expiry epoch
+  #   <token>-<jid>       HASH   jid, type, token, started_at, elapsed, size,
+  #                              sid, data (gzipped gecko JSON)
+  #
+  # Capture is a no-op unless the `vernier` gem is loaded — profiling is an
+  # opt-in, dev/staging tool, so vernier stays an optional dependency.
+  module Profiler
+    # Stored profiles live this long (score = now + TTL); ProfileSet purges
+    # expired members on read.
+    TTL = 7 * 24 * 60 * 60 # 7 days
+
+    class << self
+      # Server-side hook called from Processor#dispatch. Returns the perform
+      # result. Only captures when the job opted in AND vernier is present —
+      # otherwise it's a plain `yield`. Crucially there is NO blanket rescue
+      # here: the job's own exceptions (a normal failure, or JobRetry::Skip
+      # 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, &)
+        label = job_hash['profile']
+        return yield unless label && defined?(::Vernier)
+
+        capture(job_hash, label, &)
+      end
+
+      # Persists a profile. Extracted from capture so it is unit-testable
+      # without vernier: tests pass a ready gecko JSON blob. The wide keyword
+      # list mirrors the HASH fields one-to-one — collapsing them into an
+      # options hash would just hide the schema.
+      # rubocop:disable Metrics/ParameterLists
+      def store(jid:, type:, gecko_json:, started_at:, elapsed_ms:, token: SecureRandom.hex(8),
+                sid: Wurk.configuration[:identity], pool: nil)
+        key = profile_key(token, jid)
+        gz = gzip(gecko_json)
+        with_pool(pool) do |conn|
+          conn.call('HSET', key, 'jid', jid, 'type', type, 'token', token,
+                    'started_at', started_at.to_i, 'elapsed', elapsed_ms.to_i,
+                    'size', gz.bytesize, 'sid', sid.to_s, 'data', gz)
+          conn.call('EXPIRE', key, TTL)
+          conn.call('ZADD', Keys::PROFILES, (now + TTL).to_i, key)
+        end
+        key
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def profile_key(token, jid)
+        "#{token}-#{jid}"
+      end
+
+      def gzip(str)
+        io = StringIO.new(+'', 'wb')
+        gz = Zlib::GzipWriter.new(io)
+        gz.write(str)
+        gz.close
+        io.string
+      end
+
+      def gunzip(bytes)
+        Zlib::GzipReader.new(StringIO.new(bytes)).read
+      end
+
+      private
+
+      # Wrap the block in a Vernier capture, write the gecko JSON to a tempfile
+      # (Vernier serializes on block exit), then store it. Only reached when
+      # vernier is loaded.
+      def capture(job_hash, label)
+        retval = nil
+        started = now
+        elapsed_ms = nil
+        json = profile_to_json do
+          t0 = monotonic_ms
+          retval = yield
+          elapsed_ms = monotonic_ms - t0
+        end
+        safe_store(job_hash, label, json, started, elapsed_ms)
+        retval
+      end
+
+      # The job already ran successfully by the time we get here; a Redis hiccup
+      # persisting the profile must not turn a green job red. Job exceptions
+      # never reach this method — they propagate out of `capture`'s yield.
+      def safe_store(job_hash, label, json, started, elapsed_ms)
+        store(jid: job_hash['jid'], type: label.to_s, gecko_json: json,
+              started_at: started, elapsed_ms: elapsed_ms)
+      rescue StandardError => e
+        Wurk.configuration.handle_exception(e, context: 'Wurk::Profiler')
+      end
+
+      def profile_to_json(&)
+        Tempfile.create(['wurk-profile', '.json']) do |file|
+          ::Vernier.profile(out: file.path, &)
+          File.read(file.path)
+        end
+      end
+
+      def with_pool(pool, &)
+        pool ? pool.with(&) : Wurk.redis(&)
+      end
+
+      def now
+        ::Time.now.to_f
+      end
+
+      def monotonic_ms
+        ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :float_millisecond)
+      end
+    end
+  end
+end

data/lib/wurk/railtie.rb

@@ -1,16 +1,23 @@
 # frozen_string_literal: true
 
-require "rails/railtie"
+require 'rails/railtie'
 
 module Wurk
   # Boot the swarm after the host app has fully initialized.
   # Skip when: WURK_DISABLED=1, Rails console mode, or Rails test env.
   # See docs/idea/03-process-model.md for the exact ordering.
   class Railtie < ::Rails::Railtie
-    config.after_initialize do |app|
-      next if ENV["WURK_DISABLED"] == "1"
-      next if defined?(::Rails::Console)
-      next if ::Rails.env.test?
+    # This Rails process forks the workers, so it IS the server. Enter server
+    # mode BEFORE config/initializers load — otherwise the app's
+    # `Sidekiq.configure_server` blocks gate on `config.server?` (still false)
+    # and are silently dropped. Gated identically to the swarm boot: a process
+    # that won't run workers (disabled / console / test) is not a server.
+    initializer 'wurk.server_mode', before: :load_config_initializers do
+      Wurk.enter_server_mode unless Wurk::Railtie.skip_boot?
+    end
+
+    config.after_initialize do |_app|
+      next if Wurk::Railtie.skip_boot?
 
       swarm = Wurk::Swarm.new(topology: Wurk.configuration.topology)
       swarm.boot
@@ -24,5 +31,12 @@ module Wurk
         Wurk.configuration.logger.error { "wurk supervisor thread died: #{e.class}: #{e.message}" }
       end
     end
+
+    # A process that won't run workers isn't a server: skip both server mode
+    # and the swarm boot. Console mode is detected reliably here — the console
+    # command file defines ::Rails::Console before initializers run.
+    def self.skip_boot?
+      ENV['WURK_DISABLED'] == '1' || defined?(::Rails::Console) || ::Rails.env.test?
+    end
   end
 end

data/lib/wurk/redis_client_adapter.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'redis-client'
+require 'redis_client/decorator'
+
+module Wurk
+  # Command-method compatibility for connections yielded by `Wurk.redis` /
+  # `Sidekiq.redis` (#204). Sidekiq 7+ yields RedisClientAdapter::CompatClient,
+  # so third-party gems write `conn.hgetall(...)` / `conn.smembers(...)` —
+  # method-style commands raw RedisClient doesn't answer (it only has #call).
+  # Every pooled connection is wrapped in this decorator at build time
+  # (RedisPool#build_client); wurk's own hot paths keep using #call, which the
+  # decorator forwards with a single delegation hop.
+  #
+  # Mirrors sidekiq-8.1.6 lib/sidekiq/redis_client_adapter.rb byte-for-byte in
+  # behavior: same fast-path command list, same deprecation warning, same
+  # error constants (gems rescue `Sidekiq::RedisClientAdapter::BaseError`).
+  class RedisClientAdapter
+    BaseError = RedisClient::Error
+    CommandError = RedisClient::CommandError
+
+    DEPRECATED_COMMANDS = %i[rpoplpush zrangebyscore zrevrange zrevrangebyscore getset hmset setex setnx].to_set
+
+    module CompatMethods
+      def info
+        @client.call('INFO') { |i| i.lines(chomp: true).map { |l| l.split(':', 2) }.select { |l| l.size == 2 }.to_h }
+      end
+
+      def evalsha(sha, keys, argv)
+        @client.call('EVALSHA', sha, keys.size, *keys, *argv)
+      end
+
+      # 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
+                         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
+                         srem ttl type unlink zadd zcard zincrby zrange zrem
+                         zremrangebyrank zremrangebyscore].freeze
+
+      USED_COMMANDS.each do |name|
+        define_method(name) do |*args, **kwargs|
+          @client.call(name, *args, **kwargs)
+        end
+      end
+
+      private
+
+      # `conn.hmset(...)` instead of redis-client's native `conn.call("hmset", ...)`.
+      def method_missing(*args, &)
+        if DEPRECATED_COMMANDS.include?(args.first)
+          warn("[sidekiq#5788] Redis has deprecated the `#{args.first}` command, called at #{caller(1..1)}")
+        end
+        @client.call(*args, &)
+      end
+      ruby2_keywords :method_missing if respond_to?(:ruby2_keywords, true)
+
+      def respond_to_missing?(_name, _include_private = false)
+        super # We can't tell what is a valid command.
+      end
+    end
+
+    CompatClient = RedisClient::Decorator.create(CompatMethods)
+
+    class CompatClient
+      def config
+        @client.config
+      end
+    end
+  end
+end