sidekiq 6.5.10 → 7.1.6

data/lib/sidekiq/api.rb

@@ -6,10 +6,7 @@ require "zlib"
 require "set"
 require "base64"
 
-if ENV["SIDEKIQ_METRICS_BETA"]
-  require "sidekiq/metrics/deploy"
-  require "sidekiq/metrics/query"
-end
+require "sidekiq/metrics/query"
 
 #
 # Sidekiq's Data API provides a Ruby object model on top
@@ -70,7 +67,18 @@ module Sidekiq
     end
 
     def queues
-      Sidekiq::Stats::Queues.new.lengths
+      Sidekiq.redis do |conn|
+        queues = conn.sscan("queues").to_a
+
+        lengths = conn.pipelined { |pipeline|
+          queues.each do |queue|
+            pipeline.llen("queue:#{queue}")
+          end
+        }
+
+        array_of_arrays = queues.zip(lengths).sort_by { |_, size| -size }
+        array_of_arrays.to_h
+      end
     end
 
     # O(1) redis calls
@@ -84,11 +92,11 @@ module Sidekiq
           pipeline.zcard("retry")
           pipeline.zcard("dead")
           pipeline.scard("processes")
-          pipeline.lrange("queue:default", -1, -1)
+          pipeline.lindex("queue:default", -1)
         end
       }
 
-      default_queue_latency = if (entry = pipe1_res[6].first)
+      default_queue_latency = if (entry = pipe1_res[6])
         job = begin
           Sidekiq.load_json(entry)
         rescue
@@ -117,11 +125,11 @@ module Sidekiq
     # @api private
     def fetch_stats_slow!
       processes = Sidekiq.redis { |conn|
-        conn.sscan_each("processes").to_a
+        conn.sscan("processes").to_a
       }
 
       queues = Sidekiq.redis { |conn|
-        conn.sscan_each("queues").to_a
+        conn.sscan("queues").to_a
       }
 
       pipe2_res = Sidekiq.redis { |conn|
@@ -133,7 +141,7 @@ module Sidekiq
 
       s = processes.size
       workers_size = pipe2_res[0...s].sum(&:to_i)
-      enqueued = pipe2_res[s..-1].sum(&:to_i)
+      enqueued = pipe2_res[s..].sum(&:to_i)
 
       @stats[:workers_size] = workers_size
       @stats[:enqueued] = enqueued
@@ -168,25 +176,8 @@ module Sidekiq
       @stats[s] || raise(ArgumentError, "Unknown stat #{s}")
     end
 
-    class Queues
-      def lengths
-        Sidekiq.redis do |conn|
-          queues = conn.sscan_each("queues").to_a
-
-          lengths = conn.pipelined { |pipeline|
-            queues.each do |queue|
-              pipeline.llen("queue:#{queue}")
-            end
-          }
-
-          array_of_arrays = queues.zip(lengths).sort_by { |_, size| -size }
-          array_of_arrays.to_h
-        end
-      end
-    end
-
     class History
-      def initialize(days_previous, start_date = nil)
+      def initialize(days_previous, start_date = nil, pool: nil)
         # we only store five years of data in Redis
         raise ArgumentError if days_previous < 1 || days_previous > (5 * 365)
         @days_previous = days_previous
@@ -211,15 +202,10 @@ module Sidekiq
 
         keys = dates.map { |datestr| "stat:#{stat}:#{datestr}" }
 
-        begin
-          Sidekiq.redis do |conn|
-            conn.mget(keys).each_with_index do |value, idx|
-              stat_hash[dates[idx]] = value ? value.to_i : 0
-            end
+        Sidekiq.redis do |conn|
+          conn.mget(keys).each_with_index do |value, idx|
+            stat_hash[dates[idx]] = value ? value.to_i : 0
           end
-        rescue RedisConnection.adapter::CommandError
-          # mget will trigger a CROSSSLOT error when run against a Cluster
-          # TODO Someone want to add Cluster support?
         end
 
         stat_hash
@@ -247,7 +233,7 @@ module Sidekiq
     #
     # @return [Array<Sidekiq::Queue>]
     def self.all
-      Sidekiq.redis { |c| c.sscan_each("queues").to_a }.sort.map { |q| Sidekiq::Queue.new(q) }
+      Sidekiq.redis { |c| c.sscan("queues").to_a }.sort.map { |q| Sidekiq::Queue.new(q) }
     end
 
     attr_reader :name
@@ -278,8 +264,8 @@ module Sidekiq
     # @return [Float] in seconds
     def latency
       entry = Sidekiq.redis { |conn|
-        conn.lrange(@rname, -1, -1)
-      }.first
+        conn.lindex(@rname, -1)
+      }
       return 0 unless entry
       job = Sidekiq.load_json(entry)
       now = Time.now.to_f
@@ -388,12 +374,7 @@ module Sidekiq
     def display_class
       # Unwrap known wrappers so they show up in a human-friendly manner in the Web UI
       @klass ||= self["display_class"] || begin
-        case klass
-        when /\ASidekiq::Extensions::Delayed/
-          safe_load(args[0], klass) do |target, method, _|
-            "#{target}.#{method}"
-          end
-        when "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
+        if klass == "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
           job_class = @item["wrapped"] || args[0]
           if job_class == "ActionMailer::DeliveryJob" || job_class == "ActionMailer::MailDeliveryJob"
             # MailerClass#mailer_method
@@ -409,23 +390,14 @@ module Sidekiq
 
     def display_args
       # Unwrap known wrappers so they show up in a human-friendly manner in the Web UI
-      @display_args ||= case klass
-      when /\ASidekiq::Extensions::Delayed/
-        safe_load(args[0], args) do |_, _, arg, kwarg|
-          if !kwarg || kwarg.empty?
-            arg
-          else
-            [arg, kwarg]
-          end
-        end
-      when "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
-        job_args = self["wrapped"] ? args[0]["arguments"] : []
+      @display_args ||= if klass == "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
+        job_args = self["wrapped"] ? deserialize_argument(args[0]["arguments"]) : []
         if (self["wrapped"] || args[0]) == "ActionMailer::DeliveryJob"
           # remove MailerClass, mailer_method and 'deliver_now'
           job_args.drop(3)
         elsif (self["wrapped"] || args[0]) == "ActionMailer::MailDeliveryJob"
           # remove MailerClass, mailer_method and 'deliver_now'
-          job_args.drop(3).first["args"]
+          job_args.drop(3).first.values_at("params", "args")
         else
           job_args
         end
@@ -446,6 +418,10 @@ module Sidekiq
       self["jid"]
     end
 
+    def bid
+      self["bid"]
+    end
+
     def enqueued_at
       self["enqueued_at"] ? Time.at(self["enqueued_at"]).utc : nil
     end
@@ -491,32 +467,34 @@ module Sidekiq
 
     private
 
-    def safe_load(content, default)
-      yield(*YAML.load(content))
-    rescue => ex
-      # #1761 in dev mode, it's possible to have jobs enqueued which haven't been loaded into
-      # memory yet so the YAML can't be loaded.
-      # TODO is this still necessary? Zeitwerk reloader should handle?
-      Sidekiq.logger.warn "Unable to load YAML: #{ex.message}" unless Sidekiq.options[:environment] == "development"
-      default
-    end
+    ACTIVE_JOB_PREFIX = "_aj_"
+    GLOBALID_KEY = "_aj_globalid"
 
-    def uncompress_backtrace(backtrace)
-      if backtrace.is_a?(Array)
-        # Handle old jobs with raw Array backtrace format
-        backtrace
-      else
-        decoded = Base64.decode64(backtrace)
-        uncompressed = Zlib::Inflate.inflate(decoded)
-        begin
-          Sidekiq.load_json(uncompressed)
-        rescue
-          # Handle old jobs with marshalled backtrace format
-          # TODO Remove in 7.x
-          Marshal.load(uncompressed)
+    def deserialize_argument(argument)
+      case argument
+      when Array
+        argument.map { |arg| deserialize_argument(arg) }
+      when Hash
+        if serialized_global_id?(argument)
+          argument[GLOBALID_KEY]
+        else
+          argument.transform_values { |v| deserialize_argument(v) }
+            .reject { |k, _| k.start_with?(ACTIVE_JOB_PREFIX) }
         end
+      else
+        argument
       end
     end
+
+    def serialized_global_id?(hash)
+      hash.size == 1 && hash.include?(GLOBALID_KEY)
+    end
+
+    def uncompress_backtrace(backtrace)
+      decoded = Base64.decode64(backtrace)
+      uncompressed = Zlib::Inflate.inflate(decoded)
+      Sidekiq.load_json(uncompressed)
+    end
   end
 
   # Represents a job within a Redis sorted set where the score
@@ -593,7 +571,7 @@ module Sidekiq
     def remove_job
       Sidekiq.redis do |conn|
         results = conn.multi { |transaction|
-          transaction.zrangebyscore(parent.name, score, score)
+          transaction.zrange(parent.name, score, score, "BYSCORE")
           transaction.zremrangebyscore(parent.name, score, score)
         }.first
 
@@ -656,7 +634,7 @@ module Sidekiq
 
       match = "*#{match}*" unless match.include?("*")
       Sidekiq.redis do |conn|
-        conn.zscan_each(name, match: match, count: count) do |entry, score|
+        conn.zscan(name, match: match, count: count) do |entry, score|
           yield SortedEntry.new(self, score, entry)
         end
       end
@@ -728,7 +706,7 @@ module Sidekiq
         end
 
       elements = Sidekiq.redis { |conn|
-        conn.zrangebyscore(name, begin_score, end_score, withscores: true)
+        conn.zrange(name, begin_score, end_score, "BYSCORE", withscores: true)
       }
 
       elements.each_with_object([]) do |element, result|
@@ -746,8 +724,8 @@ module Sidekiq
     # @return [SortedEntry] the record or nil
     def find_job(jid)
       Sidekiq.redis do |conn|
-        conn.zscan_each(name, match: "*#{jid}*", count: 100) do |entry, score|
-          job = JSON.parse(entry)
+        conn.zscan(name, match: "*#{jid}*", count: 100) do |entry, score|
+          job = Sidekiq.load_json(entry)
           matched = job["jid"] == jid
           return SortedEntry.new(self, score, entry) if matched
         end
@@ -769,7 +747,7 @@ module Sidekiq
     # @api private
     def delete_by_jid(score, jid)
       Sidekiq.redis do |conn|
-        elements = conn.zrangebyscore(name, score, score)
+        elements = conn.zrange(name, score, score, "BYSCORE")
         elements.each do |element|
           if element.index(jid)
             message = Sidekiq.load_json(element)
@@ -792,12 +770,8 @@ module Sidekiq
   # example where I'm selecting jobs based on some complex logic
   # and deleting them from the scheduled set.
   #
-  #   r = Sidekiq::ScheduledSet.new
-  #   r.select do |scheduled|
-  #     scheduled.klass == 'Sidekiq::Extensions::DelayedClass' &&
-  #     scheduled.args[0] == 'User' &&
-  #     scheduled.args[1] == 'setup_new_subscriber'
-  #   end.map(&:delete)
+  # See the API wiki page for usage notes and examples.
+  #
   class ScheduledSet < JobSet
     def initialize
       super "schedule"
@@ -810,12 +784,8 @@ module Sidekiq
   # example where I'm selecting all jobs of a certain type
   # and deleting them from the retry queue.
   #
-  #   r = Sidekiq::RetrySet.new
-  #   r.select do |retri|
-  #     retri.klass == 'Sidekiq::Extensions::DelayedClass' &&
-  #     retri.args[0] == 'User' &&
-  #     retri.args[1] == 'setup_new_subscriber'
-  #   end.map(&:delete)
+  # See the API wiki page for usage notes and examples.
+  #
   class RetrySet < JobSet
     def initialize
       super "retry"
@@ -849,8 +819,8 @@ module Sidekiq
       Sidekiq.redis do |conn|
         conn.multi do |transaction|
           transaction.zadd(name, now.to_s, message)
-          transaction.zremrangebyscore(name, "-inf", now - self.class.timeout)
-          transaction.zremrangebyrank(name, 0, - self.class.max_jobs)
+          transaction.zremrangebyscore(name, "-inf", now - Sidekiq::Config::DEFAULTS[:dead_timeout_in_seconds])
+          transaction.zremrangebyrank(name, 0, - Sidekiq::Config::DEFAULTS[:dead_max_jobs])
         end
       end
 
@@ -858,7 +828,7 @@ module Sidekiq
         job = Sidekiq.load_json(message)
         r = RuntimeError.new("Job killed by API")
         r.set_backtrace(caller)
-        Sidekiq.death_handlers.each do |handle|
+        Sidekiq.default_configuration.death_handlers.each do |handle|
           handle.call(job, r)
         end
       end
@@ -869,18 +839,6 @@ module Sidekiq
     def retry_all
       each(&:retry) while size > 0
     end
-
-    # The maximum size of the Dead set. Older entries will be trimmed
-    # to stay within this limit. Default value is 10,000.
-    def self.max_jobs
-      Sidekiq[:dead_max_jobs]
-    end
-
-    # The time limit for entries within the Dead set. Older entries will be thrown away.
-    # Default value is six months.
-    def self.timeout
-      Sidekiq[:dead_timeout_in_seconds]
-    end
   end
 
   ##
@@ -893,6 +851,24 @@ module Sidekiq
   class ProcessSet
     include Enumerable
 
+    def self.[](identity)
+      exists, (info, busy, beat, quiet, rss, rtt_us) = Sidekiq.redis { |conn|
+        conn.multi { |transaction|
+          transaction.sismember("processes", identity)
+          transaction.hmget(identity, "info", "busy", "beat", "quiet", "rss", "rtt_us")
+        }
+      }
+
+      return nil if exists == 0 || info.nil?
+
+      hash = Sidekiq.load_json(info)
+      Process.new(hash.merge("busy" => busy.to_i,
+        "beat" => beat.to_f,
+        "quiet" => quiet,
+        "rss" => rss.to_i,
+        "rtt_us" => rtt_us.to_i))
+    end
+
     # :nodoc:
     # @api private
     def initialize(clean_plz = true)
@@ -909,7 +885,7 @@ module Sidekiq
 
       count = 0
       Sidekiq.redis do |conn|
-        procs = conn.sscan_each("processes").to_a
+        procs = conn.sscan("processes").to_a
         heartbeats = conn.pipelined { |pipeline|
           procs.each do |key|
             pipeline.hget(key, "info")
@@ -929,7 +905,7 @@ module Sidekiq
 
     def each
       result = Sidekiq.redis { |conn|
-        procs = conn.sscan_each("processes").to_a.sort
+        procs = conn.sscan("processes").to_a.sort
 
         # We're making a tradeoff here between consuming more memory instead of
         # making more roundtrips to Redis, but if you have hundreds or thousands of workers,
@@ -941,7 +917,7 @@ module Sidekiq
         end
       }
 
-      result.each do |info, busy, at_s, quiet, rss, rtt|
+      result.each do |info, busy, beat, quiet, rss, rtt_us|
         # If a process is stopped between when we query Redis for `procs` and
         # when we query for `result`, we will have an item in `result` that is
         # composed of `nil` values.
@@ -949,10 +925,10 @@ module Sidekiq
 
         hash = Sidekiq.load_json(info)
         yield Process.new(hash.merge("busy" => busy.to_i,
-          "beat" => at_s.to_f,
+          "beat" => beat.to_f,
           "quiet" => quiet,
           "rss" => rss.to_i,
-          "rtt_us" => rtt.to_i))
+          "rtt_us" => rtt_us.to_i))
       end
     end
 
@@ -1008,6 +984,7 @@ module Sidekiq
   #   'busy' => 10,
   #   'beat' => <last heartbeat>,
   #   'identity' => <unique string identifying the process>,
+  #   'embedded' => true,
   # }
   class Process
     # :nodoc:
@@ -1021,7 +998,7 @@ module Sidekiq
     end
 
     def labels
-      Array(self["labels"])
+      self["labels"].to_a
     end
 
     def [](key)
@@ -1036,11 +1013,25 @@ module Sidekiq
       self["queues"]
     end
 
+    def weights
+      self["weights"]
+    end
+
+    def version
+      self["version"]
+    end
+
+    def embedded?
+      self["embedded"]
+    end
+
     # Signal this process to stop processing new jobs.
     # It will continue to execute jobs it has already fetched.
     # This method is *asynchronous* and it can take 5-10
     # seconds for the process to quiet.
     def quiet!
+      raise "Can't quiet an embedded process" if embedded?
+
       signal("TSTP")
     end
 
@@ -1049,6 +1040,8 @@ module Sidekiq
     # This method is *asynchronous* and it can take 5-10
     # seconds for the process to start shutting down.
     def stop!
+      raise "Can't stop an embedded process" if embedded?
+
       signal("TERM")
     end
 
@@ -1107,8 +1100,7 @@ module Sidekiq
       all_works = nil
 
       Sidekiq.redis do |conn|
-        procs = conn.sscan_each("processes").to_a.sort
-
+        procs = conn.sscan("processes").to_a.sort
         all_works = conn.pipelined do |pipeline|
           procs.each do |key|
             pipeline.hgetall("#{key}:work")
@@ -1118,13 +1110,7 @@ module Sidekiq
 
       procs.zip(all_works).each do |key, workers|
         workers.each_pair do |tid, json|
-          next if json.empty?
-
-          hsh = Sidekiq.load_json(json)
-          p = hsh["payload"]
-          # avoid breaking API, this is a side effect of the JSON optimization in #4316
-          hsh["payload"] = Sidekiq.load_json(p) if p.is_a?(String)
-          results << [key, tid, hsh]
+          results << [key, tid, Sidekiq.load_json(json)] unless json.empty?
         end
       end
 
@@ -1139,7 +1125,7 @@ module Sidekiq
     # which can easily get out of sync with crashy processes.
     def size
       Sidekiq.redis do |conn|
-        procs = conn.sscan_each("processes").to_a
+        procs = conn.sscan("processes").to_a
         if procs.empty?
           0
         else

data/lib/sidekiq/capsule.rb

@@ -0,0 +1,127 @@
+require "sidekiq/component"
+
+module Sidekiq
+  # A Sidekiq::Capsule is the set of resources necessary to
+  # process one or more queues with a given concurrency.
+  # One "default" Capsule is started but the user may declare additional
+  # Capsules in their initializer.
+  #
+  # This capsule will pull jobs from the "single" queue and process
+  # the jobs with one thread, meaning the jobs will be processed serially.
+  #
+  # Sidekiq.configure_server do |config|
+  #   config.capsule("single-threaded") do |cap|
+  #     cap.concurrency = 1
+  #     cap.queues = %w(single)
+  #   end
+  # end
+  class Capsule
+    include Sidekiq::Component
+
+    attr_reader :name
+    attr_reader :queues
+    attr_accessor :concurrency
+    attr_reader :mode
+    attr_reader :weights
+
+    def initialize(name, config)
+      @name = name
+      @config = config
+      @queues = ["default"]
+      @weights = {"default" => 0}
+      @concurrency = config[:concurrency]
+      @mode = :strict
+    end
+
+    def fetcher
+      @fetcher ||= begin
+        inst = (config[:fetch_class] || Sidekiq::BasicFetch).new(self)
+        inst.setup(config[:fetch_setup]) if inst.respond_to?(:setup)
+        inst
+      end
+    end
+
+    def stop
+      fetcher&.bulk_requeue([])
+    end
+
+    # Sidekiq checks queues in three modes:
+    # - :strict - all queues have 0 weight and are checked strictly in order
+    # - :weighted - queues have arbitrary weight between 1 and N
+    # - :random - all queues have weight of 1
+    def queues=(val)
+      @weights = {}
+      @queues = Array(val).each_with_object([]) do |qstr, memo|
+        arr = qstr
+        arr = qstr.split(",") if qstr.is_a?(String)
+        name, weight = arr
+        @weights[name] = weight.to_i
+        [weight.to_i, 1].max.times do
+          memo << name
+        end
+      end
+      @mode = if @weights.values.all?(&:zero?)
+        :strict
+      elsif @weights.values.all? { |x| x == 1 }
+        :random
+      else
+        :weighted
+      end
+    end
+
+    # Allow the middleware to be different per-capsule.
+    # Avoid if possible and add middleware globally so all
+    # capsules share the same chains. Easier to debug that way.
+    def client_middleware
+      @client_chain ||= config.client_middleware.copy_for(self)
+      yield @client_chain if block_given?
+      @client_chain
+    end
+
+    def server_middleware
+      @server_chain ||= config.server_middleware.copy_for(self)
+      yield @server_chain if block_given?
+      @server_chain
+    end
+
+    def redis_pool
+      Thread.current[:sidekiq_redis_pool] || local_redis_pool
+    end
+
+    def local_redis_pool
+      # connection pool is lazy, it will not create connections unless you actually need them
+      # so don't be skimpy!
+      @redis ||= config.new_redis_pool(@concurrency, name)
+    end
+
+    def redis
+      raise ArgumentError, "requires a block" unless block_given?
+      redis_pool.with do |conn|
+        retryable = true
+        begin
+          yield conn
+        rescue RedisClientAdapter::BaseError => ex
+          # 2550 Failover can cause the server to become a replica, need
+          # to disconnect and reopen the socket to get back to the primary.
+          # 4495 Use the same logic if we have a "Not enough replicas" error from the primary
+          # 4985 Use the same logic when a blocking command is force-unblocked
+          # The same retry logic is also used in client.rb
+          if retryable && ex.message =~ /READONLY|NOREPLICAS|UNBLOCKED/
+            conn.close
+            retryable = false
+            retry
+          end
+          raise
+        end
+      end
+    end
+
+    def lookup(name)
+      config.lookup(name)
+    end
+
+    def logger
+      config.logger
+    end
+  end
+end