sidekiq 4.2.2 → 6.3.1

data/lib/sidekiq/api.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
-# encoding: utf-8
-require 'sidekiq'
+
+require "sidekiq"
+
+require "zlib"
+require "base64"
 
 module Sidekiq
   class Stats
     def initialize
-      fetch_stats!
+      fetch_stats_fast!
     end
 
     def processed
@@ -48,53 +51,78 @@ module Sidekiq
       Sidekiq::Stats::Queues.new.lengths
     end
 
-    def fetch_stats!
-      pipe1_res = Sidekiq.redis do |conn|
+    # O(1) redis calls
+    def fetch_stats_fast!
+      pipe1_res = Sidekiq.redis { |conn|
         conn.pipelined do
-          conn.get('stat:processed'.freeze)
-          conn.get('stat:failed'.freeze)
-          conn.zcard('schedule'.freeze)
-          conn.zcard('retry'.freeze)
-          conn.zcard('dead'.freeze)
-          conn.scard('processes'.freeze)
-          conn.lrange('queue:default'.freeze, -1, -1)
-          conn.smembers('processes'.freeze)
-          conn.smembers('queues'.freeze)
+          conn.get("stat:processed")
+          conn.get("stat:failed")
+          conn.zcard("schedule")
+          conn.zcard("retry")
+          conn.zcard("dead")
+          conn.scard("processes")
+          conn.lrange("queue:default", -1, -1)
         end
-      end
+      }
 
-      pipe2_res = Sidekiq.redis do |conn|
-        conn.pipelined do
-          pipe1_res[7].each {|key| conn.hget(key, 'busy'.freeze) }
-          pipe1_res[8].each {|queue| conn.llen("queue:#{queue}") }
+      default_queue_latency = if (entry = pipe1_res[6].first)
+        job = begin
+          Sidekiq.load_json(entry)
+        rescue
+          {}
         end
+        now = Time.now.to_f
+        thence = job["enqueued_at"] || now
+        now - thence
+      else
+        0
       end
 
-      s = pipe1_res[7].size
-      workers_size = pipe2_res[0...s].map(&:to_i).inject(0, &:+)
-      enqueued     = pipe2_res[s..-1].map(&:to_i).inject(0, &:+)
-
-      default_queue_latency = if (entry = pipe1_res[6].first)
-                                Time.now.to_f - Sidekiq.load_json(entry)['enqueued_at'.freeze]
-                              else
-                                0
-                              end
       @stats = {
-        processed:             pipe1_res[0].to_i,
-        failed:                pipe1_res[1].to_i,
-        scheduled_size:        pipe1_res[2],
-        retry_size:            pipe1_res[3],
-        dead_size:             pipe1_res[4],
-        processes_size:        pipe1_res[5],
-
-        default_queue_latency: default_queue_latency,
-        workers_size:          workers_size,
-        enqueued:              enqueued
+        processed: pipe1_res[0].to_i,
+        failed: pipe1_res[1].to_i,
+        scheduled_size: pipe1_res[2],
+        retry_size: pipe1_res[3],
+        dead_size: pipe1_res[4],
+        processes_size: pipe1_res[5],
+
+        default_queue_latency: default_queue_latency
       }
     end
 
+    # O(number of processes + number of queues) redis calls
+    def fetch_stats_slow!
+      processes = Sidekiq.redis { |conn|
+        conn.sscan_each("processes").to_a
+      }
+
+      queues = Sidekiq.redis { |conn|
+        conn.sscan_each("queues").to_a
+      }
+
+      pipe2_res = Sidekiq.redis { |conn|
+        conn.pipelined do
+          processes.each { |key| conn.hget(key, "busy") }
+          queues.each { |queue| conn.llen("queue:#{queue}") }
+        end
+      }
+
+      s = processes.size
+      workers_size = pipe2_res[0...s].sum(&:to_i)
+      enqueued = pipe2_res[s..-1].sum(&:to_i)
+
+      @stats[:workers_size] = workers_size
+      @stats[:enqueued] = enqueued
+      @stats
+    end
+
+    def fetch_stats!
+      fetch_stats_fast!
+      fetch_stats_slow!
+    end
+
     def reset(*stats)
-      all   = %w(failed processed)
+      all = %w[failed processed]
       stats = stats.empty? ? all : all & stats.flatten.compact.map(&:to_s)
 
       mset_args = []
@@ -110,28 +138,23 @@ module Sidekiq
     private
 
     def stat(s)
-      @stats[s]
+      fetch_stats_slow! if @stats[s].nil?
+      @stats[s] || raise(ArgumentError, "Unknown stat #{s}")
     end
 
     class Queues
       def lengths
         Sidekiq.redis do |conn|
-          queues = conn.smembers('queues'.freeze)
+          queues = conn.sscan_each("queues").to_a
 
-          lengths = conn.pipelined do
+          lengths = conn.pipelined {
             queues.each do |queue|
               conn.llen("queue:#{queue}")
             end
-          end
-
-          i = 0
-          array_of_arrays = queues.inject({}) do |memo, queue|
-            memo[queue] = lengths[i]
-            i += 1
-            memo
-          end.sort_by { |_, size| size }
+          }
 
-          Hash[array_of_arrays.reverse]
+          array_of_arrays = queues.zip(lengths).sort_by { |_, size| -size }
+          array_of_arrays.to_h
         end
       end
     end
@@ -143,33 +166,32 @@ module Sidekiq
       end
 
       def processed
-        date_stat_hash("processed")
+        @processed ||= date_stat_hash("processed")
       end
 
       def failed
-        date_stat_hash("failed")
+        @failed ||= date_stat_hash("failed")
       end
 
       private
 
       def date_stat_hash(stat)
-        i = 0
         stat_hash = {}
-        keys = []
-        dates = []
-
-        while i < @days_previous
-          date = @start_date - i
-          datestr = date.strftime("%Y-%m-%d".freeze)
-          keys << "stat:#{stat}:#{datestr}"
-          dates << datestr
-          i += 1
-        end
+        dates = @start_date.downto(@start_date - @days_previous + 1).map { |date|
+          date.strftime("%Y-%m-%d")
+        }
 
-        Sidekiq.redis do |conn|
-          conn.mget(keys).each_with_index do |value, idx|
-            stat_hash[dates[idx]] = value ? value.to_i : 0
+        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
           end
+        rescue Redis::CommandError
+          # mget will trigger a CROSSSLOT error when run against a Cluster
+          # TODO Someone want to add Cluster support?
         end
 
         stat_hash
@@ -196,13 +218,13 @@ module Sidekiq
     # Return all known queues within Redis.
     #
     def self.all
-      Sidekiq.redis { |c| c.smembers('queues'.freeze) }.sort.map { |q| Sidekiq::Queue.new(q) }
+      Sidekiq.redis { |c| c.sscan_each("queues").to_a }.sort.map { |q| Sidekiq::Queue.new(q) }
     end
 
     attr_reader :name
 
-    def initialize(name="default")
-      @name = name
+    def initialize(name = "default")
+      @name = name.to_s
       @rname = "queue:#{name}"
     end
 
@@ -221,11 +243,14 @@ module Sidekiq
     #
     # @return Float
     def latency
-      entry = Sidekiq.redis do |conn|
+      entry = Sidekiq.redis { |conn|
         conn.lrange(@rname, -1, -1)
-      end.first
+      }.first
       return 0 unless entry
-      Time.now.to_f - Sidekiq.load_json(entry)['enqueued_at']
+      job = Sidekiq.load_json(entry)
+      now = Time.now.to_f
+      thence = job["enqueued_at"] || now
+      now - thence
     end
 
     def each
@@ -234,16 +259,16 @@ module Sidekiq
       page = 0
       page_size = 50
 
-      while true do
+      loop do
         range_start = page * page_size - deleted_size
-        range_end   = range_start + page_size - 1
-        entries = Sidekiq.redis do |conn|
+        range_end = range_start + page_size - 1
+        entries = Sidekiq.redis { |conn|
           conn.lrange @rname, range_start, range_end
-        end
+        }
         break if entries.empty?
         page += 1
         entries.each do |entry|
-          yield Job.new(entry, @name)
+          yield JobRecord.new(entry, @name)
         end
         deleted_size = initial_size - size
       end
@@ -253,7 +278,7 @@ module Sidekiq
     # Find the job with the given JID within this queue.
     #
     # This is a slow, inefficient operation.  Do not use under
-    # normal conditions.  Sidekiq Pro contains a faster version.
+    # normal conditions.
     def find_job(jid)
       detect { |j| j.jid == jid }
     end
@@ -261,8 +286,8 @@ module Sidekiq
     def clear
       Sidekiq.redis do |conn|
         conn.multi do
-          conn.del(@rname)
-          conn.srem("queues".freeze, name)
+          conn.unlink(@rname)
+          conn.srem("queues", name)
         end
       end
     end
@@ -274,114 +299,166 @@ module Sidekiq
   # sorted set.
   #
   # The job should be considered immutable but may be
-  # removed from the queue via Job#delete.
+  # removed from the queue via JobRecord#delete.
   #
-  class Job
+  class JobRecord
     attr_reader :item
     attr_reader :value
 
-    def initialize(item, queue_name=nil)
+    def initialize(item, queue_name = nil)
+      @args = nil
       @value = item
-      @item = item.is_a?(Hash) ? item : Sidekiq.load_json(item)
-      @queue = queue_name || @item['queue']
+      @item = item.is_a?(Hash) ? item : parse(item)
+      @queue = queue_name || @item["queue"]
+    end
+
+    def parse(item)
+      Sidekiq.load_json(item)
+    rescue JSON::ParserError
+      # If the job payload in Redis is invalid JSON, we'll load
+      # the item as an empty hash and store the invalid JSON as
+      # the job 'args' for display in the Web UI.
+      @invalid = true
+      @args = [item]
+      {}
     end
 
     def klass
-      @item['class']
+      self["class"]
     end
 
     def display_class
       # Unwrap known wrappers so they show up in a human-friendly manner in the Web UI
-      @klass ||= case klass
-                 when /\ASidekiq::Extensions::Delayed/
-                   safe_load(args[0], klass) do |target, method, _|
-                     "#{target}.#{method}"
-                   end
-                 when "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
-                   job_class = @item['wrapped'] || args[0]
-                   if 'ActionMailer::DeliveryJob' == job_class
-                     # MailerClass#mailer_method
-                     args[0]['arguments'][0..1].join('#')
-                   else
-                    job_class
-                   end
-                 else
-                   klass
-                 end
+      @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"
+          job_class = @item["wrapped"] || args[0]
+          if job_class == "ActionMailer::DeliveryJob" || job_class == "ActionMailer::MailDeliveryJob"
+            # MailerClass#mailer_method
+            args[0]["arguments"][0..1].join("#")
+          else
+            job_class
+          end
+        else
+          klass
+        end
+      end
     end
 
     def display_args
       # Unwrap known wrappers so they show up in a human-friendly manner in the Web UI
-      @args ||= case klass
+      @display_args ||= case klass
                 when /\ASidekiq::Extensions::Delayed/
                   safe_load(args[0], args) do |_, _, arg|
                     arg
                   end
                 when "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
-                  job_args = @item['wrapped'] ? args[0]["arguments"] : []
-                  if 'ActionMailer::DeliveryJob' == (@item['wrapped'] || args[0])
-                   # remove MailerClass, mailer_method and 'deliver_now'
-                   job_args.drop(3)
+                  job_args = self["wrapped"] ? 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"]
                   else
-                   job_args
+                    job_args
                   end
                 else
+                  if self["encrypt"]
+                    # no point in showing 150+ bytes of random garbage
+                    args[-1] = "[encrypted data]"
+                  end
                   args
-                end
+      end
     end
 
     def args
-      @item['args']
+      @args || @item["args"]
     end
 
     def jid
-      @item['jid']
+      self["jid"]
     end
 
     def enqueued_at
-      @item['enqueued_at'] ? Time.at(@item['enqueued_at']).utc : nil
+      self["enqueued_at"] ? Time.at(self["enqueued_at"]).utc : nil
     end
 
     def created_at
-      Time.at(@item['created_at'] || @item['enqueued_at'] || 0).utc
+      Time.at(self["created_at"] || self["enqueued_at"] || 0).utc
+    end
+
+    def tags
+      self["tags"] || []
     end
 
-    def queue
-      @queue
+    def error_backtrace
+      # Cache nil values
+      if defined?(@error_backtrace)
+        @error_backtrace
+      else
+        value = self["error_backtrace"]
+        @error_backtrace = value && uncompress_backtrace(value)
+      end
     end
 
+    attr_reader :queue
+
     def latency
-      Time.now.to_f - (@item['enqueued_at'] || @item['created_at'])
+      now = Time.now.to_f
+      now - (@item["enqueued_at"] || @item["created_at"] || now)
     end
 
     ##
     # Remove this job from the queue.
     def delete
-      count = Sidekiq.redis do |conn|
+      count = Sidekiq.redis { |conn|
         conn.lrem("queue:#{@queue}", 1, @value)
-      end
+      }
       count != 0
     end
 
     def [](name)
-      @item[name]
+      # nil will happen if the JSON fails to parse.
+      # We don't guarantee Sidekiq will work with bad job JSON but we should
+      # make a best effort to minimize the damage.
+      @item ? @item[name] : nil
     end
 
     private
 
     def safe_load(content, default)
-      begin
-        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.
-        Sidekiq.logger.warn "Unable to load YAML: #{ex.message}" unless Sidekiq.options[:environment] == 'development'
-        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.
+      Sidekiq.logger.warn "Unable to load YAML: #{ex.message}" unless Sidekiq.options[:environment] == "development"
+      default
+    end
+
+    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)
+        end
       end
     end
   end
 
-  class SortedEntry < Job
+  class SortedEntry < JobRecord
     attr_reader :score
     attr_reader :parent
 
@@ -404,8 +481,9 @@ module Sidekiq
     end
 
     def reschedule(at)
-      delete
-      @parent.schedule(at, item)
+      Sidekiq.redis do |conn|
+        conn.zincrby(@parent.name, at.to_f - @score, Sidekiq.dump_json(@item))
+      end
     end
 
     def add_to_queue
@@ -416,10 +494,9 @@ module Sidekiq
     end
 
     def retry
-      raise "Retry not available on jobs which have not failed" unless item["failed_at"]
       remove_job do |message|
         msg = Sidekiq.load_json(message)
-        msg['retry_count'] -= 1
+        msg["retry_count"] -= 1 if msg["retry_count"]
         Sidekiq::Client.push(msg)
       end
     end
@@ -427,56 +504,50 @@ module Sidekiq
     ##
     # Place job in the dead set
     def kill
-      raise 'Kill not available on jobs which have not failed' unless item['failed_at']
       remove_job do |message|
-        Sidekiq.logger.info { "Killing job #{message['jid']}" }
-        now = Time.now.to_f
-        Sidekiq.redis do |conn|
-          conn.multi do
-            conn.zadd('dead', now, message)
-            conn.zremrangebyscore('dead', '-inf', now - DeadSet.timeout)
-            conn.zremrangebyrank('dead', 0, - DeadSet.max_jobs)
-          end
-        end
+        DeadSet.new.kill(message)
       end
     end
 
+    def error?
+      !!item["error_class"]
+    end
+
     private
 
     def remove_job
       Sidekiq.redis do |conn|
-        results = conn.multi do
+        results = conn.multi {
           conn.zrangebyscore(parent.name, score, score)
           conn.zremrangebyscore(parent.name, score, score)
-        end.first
+        }.first
 
         if results.size == 1
           yield results.first
         else
           # multiple jobs with the same score
           # find the one with the right JID and push it
-          hash = results.group_by do |message|
+          matched, nonmatched = results.partition { |message|
             if message.index(jid)
               msg = Sidekiq.load_json(message)
-              msg['jid'] == jid
+              msg["jid"] == jid
             else
               false
             end
-          end
+          }
 
-          msg = hash.fetch(true, []).first
+          msg = matched.first
           yield msg if msg
 
           # push the rest back onto the sorted set
           conn.multi do
-            hash.fetch(false, []).each do |message|
+            nonmatched.each do |message|
               conn.zadd(parent.name, score.to_f.to_s, message)
             end
           end
         end
       end
     end
-
   end
 
   class SortedSet
@@ -493,16 +564,26 @@ module Sidekiq
       Sidekiq.redis { |c| c.zcard(name) }
     end
 
+    def scan(match, count = 100)
+      return to_enum(:scan, match, count) unless block_given?
+
+      match = "*#{match}*" unless match.include?("*")
+      Sidekiq.redis do |conn|
+        conn.zscan_each(name, match: match, count: count) do |entry, score|
+          yield SortedEntry.new(self, score, entry)
+        end
+      end
+    end
+
     def clear
       Sidekiq.redis do |conn|
-        conn.del(name)
+        conn.unlink(name)
       end
     end
     alias_method :💣, :clear
   end
 
   class JobSet < SortedSet
-
     def schedule(timestamp, message)
       Sidekiq.redis do |conn|
         conn.zadd(name, timestamp.to_f.to_s, Sidekiq.dump_json(message))
@@ -515,44 +596,55 @@ module Sidekiq
       page = -1
       page_size = 50
 
-      while true do
+      loop do
         range_start = page * page_size + offset_size
-        range_end   = range_start + page_size - 1
-        elements = Sidekiq.redis do |conn|
+        range_end = range_start + page_size - 1
+        elements = Sidekiq.redis { |conn|
           conn.zrange name, range_start, range_end, with_scores: true
-        end
+        }
         break if elements.empty?
         page -= 1
-        elements.each do |element, score|
+        elements.reverse_each do |element, score|
           yield SortedEntry.new(self, score, element)
         end
         offset_size = initial_size - @_size
       end
     end
 
+    ##
+    # Fetch jobs that match a given time or Range. Job ID is an
+    # optional second argument.
     def fetch(score, jid = nil)
-      elements = Sidekiq.redis do |conn|
-        conn.zrangebyscore(name, score, score)
-      end
-
-      elements.inject([]) do |result, element|
-        entry = SortedEntry.new(self, score, element)
-        if jid
-          result << entry if entry.jid == jid
+      begin_score, end_score =
+        if score.is_a?(Range)
+          [score.first, score.last]
         else
-          result << entry
+          [score, score]
         end
-        result
+
+      elements = Sidekiq.redis { |conn|
+        conn.zrangebyscore(name, begin_score, end_score, with_scores: true)
+      }
+
+      elements.each_with_object([]) do |element, result|
+        data, job_score = element
+        entry = SortedEntry.new(self, job_score, data)
+        result << entry if jid.nil? || entry.jid == jid
       end
     end
 
     ##
     # Find the job with the given JID within this sorted set.
-    #
-    # This is a slow, inefficient operation.  Do not use under
-    # normal conditions.  Sidekiq Pro contains a faster version.
+    # This is a slower O(n) operation.  Do not use for app logic.
     def find_job(jid)
-      self.detect { |j| j.jid == jid }
+      Sidekiq.redis do |conn|
+        conn.zscan_each(name, match: "*#{jid}*", count: 100) do |entry, score|
+          job = JSON.parse(entry)
+          matched = job["jid"] == jid
+          return SortedEntry.new(self, score, entry) if matched
+        end
+      end
+      nil
     end
 
     def delete_by_value(name, value)
@@ -567,13 +659,14 @@ module Sidekiq
       Sidekiq.redis do |conn|
         elements = conn.zrangebyscore(name, score, score)
         elements.each do |element|
-          message = Sidekiq.load_json(element)
-          if message["jid"] == jid
-            ret = conn.zrem(name, element)
-            @_size -= 1 if ret
-            break ret
+          if element.index(jid)
+            message = Sidekiq.load_json(element)
+            if message["jid"] == jid
+              ret = conn.zrem(name, element)
+              @_size -= 1 if ret
+              break ret
+            end
           end
-          false
         end
       end
     end
@@ -585,17 +678,17 @@ module Sidekiq
   # Allows enumeration of scheduled jobs within Sidekiq.
   # Based on this, you can search/filter for jobs.  Here's an
   # example where I'm selecting all jobs of a certain type
-  # and deleting them from the retry queue.
+  # and deleting them from the schedule queue.
   #
   #   r = Sidekiq::ScheduledSet.new
-  #   r.select do |retri|
-  #     retri.klass == 'Sidekiq::Extensions::DelayedClass' &&
-  #     retri.args[0] == 'User' &&
-  #     retri.args[1] == 'setup_new_subscriber'
+  #   r.select do |scheduled|
+  #     scheduled.klass == 'Sidekiq::Extensions::DelayedClass' &&
+  #     scheduled.args[0] == 'User' &&
+  #     scheduled.args[1] == 'setup_new_subscriber'
   #   end.map(&:delete)
   class ScheduledSet < JobSet
     def initialize
-      super 'schedule'
+      super "schedule"
     end
   end
 
@@ -613,13 +706,15 @@ module Sidekiq
   #   end.map(&:delete)
   class RetrySet < JobSet
     def initialize
-      super 'retry'
+      super "retry"
     end
 
     def retry_all
-      while size > 0
-        each(&:retry)
-      end
+      each(&:retry) while size > 0
+    end
+
+    def kill_all
+      each(&:kill) while size > 0
     end
   end
 
@@ -628,13 +723,32 @@ module Sidekiq
   #
   class DeadSet < JobSet
     def initialize
-      super 'dead'
+      super "dead"
     end
 
-    def retry_all
-      while size > 0
-        each(&:retry)
+    def kill(message, opts = {})
+      now = Time.now.to_f
+      Sidekiq.redis do |conn|
+        conn.multi do
+          conn.zadd(name, now.to_s, message)
+          conn.zremrangebyscore(name, "-inf", now - self.class.timeout)
+          conn.zremrangebyrank(name, 0, - self.class.max_jobs)
+        end
+      end
+
+      if opts[:notify_failure] != false
+        job = Sidekiq.load_json(message)
+        r = RuntimeError.new("Job killed by API")
+        r.set_backtrace(caller)
+        Sidekiq.death_handlers.each do |handle|
+          handle.call(job, r)
+        end
       end
+      true
+    end
+
+    def retry_all
+      each(&:retry) while size > 0
     end
 
     def self.max_jobs
@@ -648,7 +762,7 @@ module Sidekiq
 
   ##
   # Enumerates the set of Sidekiq processes which are actively working
-  # right now.  Each process send a heartbeat to Redis every 5 seconds
+  # right now.  Each process sends a heartbeat to Redis every 5 seconds
   # so this set should be relatively accurate, barring network partitions.
   #
   # Yields a Sidekiq::Process.
@@ -656,54 +770,60 @@ module Sidekiq
   class ProcessSet
     include Enumerable
 
-    def initialize(clean_plz=true)
-      self.class.cleanup if clean_plz
+    def initialize(clean_plz = true)
+      cleanup if clean_plz
     end
 
     # Cleans up dead processes recorded in Redis.
     # Returns the number of processes cleaned.
-    def self.cleanup
+    def cleanup
       count = 0
       Sidekiq.redis do |conn|
-        procs = conn.smembers('processes').sort
-        heartbeats = conn.pipelined do
+        procs = conn.sscan_each("processes").to_a.sort
+        heartbeats = conn.pipelined {
           procs.each do |key|
-            conn.hget(key, 'info')
+            conn.hget(key, "info")
           end
-        end
+        }
 
         # the hash named key has an expiry of 60 seconds.
         # if it's not found, that means the process has not reported
         # in to Redis and probably died.
-        to_prune = []
-        heartbeats.each_with_index do |beat, i|
-          to_prune << procs[i] if beat.nil?
-        end
-        count = conn.srem('processes', to_prune) unless to_prune.empty?
+        to_prune = procs.select.with_index { |proc, i|
+          heartbeats[i].nil?
+        }
+        count = conn.srem("processes", to_prune) unless to_prune.empty?
       end
       count
     end
 
     def each
-      procs = Sidekiq.redis { |conn| conn.smembers('processes') }.sort
+      result = Sidekiq.redis { |conn|
+        procs = conn.sscan_each("processes").to_a.sort
 
-      Sidekiq.redis do |conn|
         # 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,
         # you'll be happier this way
-        result = conn.pipelined do
+        conn.pipelined do
           procs.each do |key|
-            conn.hmget(key, 'info', 'busy', 'beat', 'quiet')
+            conn.hmget(key, "info", "busy", "beat", "quiet", "rss", "rtt_us")
           end
         end
+      }
 
-        result.each do |info, busy, at_s, quiet|
-          hash = Sidekiq.load_json(info)
-          yield Process.new(hash.merge('busy' => busy.to_i, 'beat' => at_s.to_f, 'quiet' => quiet))
-        end
-      end
+      result.each do |info, busy, at_s, quiet, rss, rtt|
+        # 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.
+        next if info.nil?
 
-      nil
+        hash = Sidekiq.load_json(info)
+        yield Process.new(hash.merge("busy" => busy.to_i,
+                                     "beat" => at_s.to_f,
+                                     "quiet" => quiet,
+                                     "rss" => rss.to_i,
+                                     "rtt_us" => rtt.to_i))
+      end
     end
 
     # This method is not guaranteed accurate since it does not prune the set
@@ -711,7 +831,31 @@ module Sidekiq
     # contains Sidekiq processes which have sent a heartbeat within the last
     # 60 seconds.
     def size
-      Sidekiq.redis { |conn| conn.scard('processes') }
+      Sidekiq.redis { |conn| conn.scard("processes") }
+    end
+
+    # Total number of threads available to execute jobs.
+    # For Sidekiq Enterprise customers this number (in production) must be
+    # less than or equal to your licensed concurrency.
+    def total_concurrency
+      sum { |x| x["concurrency"].to_i }
+    end
+
+    def total_rss_in_kb
+      sum { |x| x["rss"].to_i }
+    end
+    alias_method :total_rss, :total_rss_in_kb
+
+    # Returns the identity of the current cluster leader or "" if no leader.
+    # This is a Sidekiq Enterprise feature, will always return "" in Sidekiq
+    # or Sidekiq Pro.
+    def leader
+      @leader ||= begin
+        x = Sidekiq.redis { |c| c.get("dear-leader") }
+        # need a non-falsy value so we can memoize
+        x ||= ""
+        x
+      end
     end
   end
 
@@ -736,31 +880,39 @@ module Sidekiq
     end
 
     def tag
-      self['tag']
+      self["tag"]
     end
 
     def labels
-      Array(self['labels'])
+      Array(self["labels"])
     end
 
     def [](key)
       @attribs[key]
     end
 
+    def identity
+      self["identity"]
+    end
+
+    def queues
+      self["queues"]
+    end
+
     def quiet!
-      signal('USR1')
+      signal("TSTP")
     end
 
     def stop!
-      signal('TERM')
+      signal("TERM")
     end
 
     def dump_threads
-      signal('TTIN')
+      signal("TTIN")
     end
 
     def stopping?
-      self['quiet'] == 'true'
+      self["quiet"] == "true"
     end
 
     private
@@ -774,15 +926,11 @@ module Sidekiq
         end
       end
     end
-
-    def identity
-      self['identity']
-    end
   end
 
   ##
-  # A worker is a thread that is currently processing a job.
-  # Programmatic access to the current active worker set.
+  # The WorkSet stores the work being done by this Sidekiq cluster.
+  # It tracks the process and thread working on each job.
   #
   # WARNING WARNING WARNING
   #
@@ -790,33 +938,40 @@ module Sidekiq
   # If you call #size => 5 and then expect #each to be
   # called 5 times, you're going to have a bad time.
   #
-  #    workers = Sidekiq::Workers.new
-  #    workers.size => 2
-  #    workers.each do |process_id, thread_id, work|
+  #    works = Sidekiq::WorkSet.new
+  #    works.size => 2
+  #    works.each do |process_id, thread_id, work|
   #      # process_id is a unique identifier per Sidekiq process
   #      # thread_id is a unique identifier per thread
   #      # work is a Hash which looks like:
-  #      # { 'queue' => name, 'run_at' => timestamp, 'payload' => msg }
+  #      # { 'queue' => name, 'run_at' => timestamp, 'payload' => job_hash }
   #      # run_at is an epoch Integer.
   #    end
   #
-  class Workers
+  class WorkSet
     include Enumerable
 
-    def each
+    def each(&block)
+      results = []
       Sidekiq.redis do |conn|
-        procs = conn.smembers('processes')
+        procs = conn.sscan_each("processes").to_a
         procs.sort.each do |key|
-          valid, workers = conn.pipelined do
-            conn.exists(key)
+          valid, workers = conn.pipelined {
+            conn.exists?(key)
             conn.hgetall("#{key}:workers")
-          end
+          }
           next unless valid
           workers.each_pair do |tid, json|
-            yield key, tid, Sidekiq.load_json(json)
+            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]
           end
         end
       end
+
+      results.sort_by { |(_, _, hsh)| hsh["run_at"] }.each(&block)
     end
 
     # Note that #size is only as accurate as Sidekiq's heartbeat,
@@ -827,18 +982,21 @@ module Sidekiq
     # which can easily get out of sync with crashy processes.
     def size
       Sidekiq.redis do |conn|
-        procs = conn.smembers('processes')
+        procs = conn.sscan_each("processes").to_a
         if procs.empty?
           0
         else
-          conn.pipelined do
+          conn.pipelined {
             procs.each do |key|
-              conn.hget(key, 'busy')
+              conn.hget(key, "busy")
             end
-          end.map(&:to_i).inject(:+)
+          }.sum(&:to_i)
         end
       end
     end
   end
-
+  # Since "worker" is a nebulous term, we've deprecated the use of this class name.
+  # Is "worker" a process, a type of job, a thread? Undefined!
+  # WorkSet better describes the data.
+  Workers = WorkSet
 end