sidekiq 6.0.0 → 6.0.5

data/Pro-Changes.md

@@ -4,12 +4,20 @@
 
 Please see [http://sidekiq.org/](http://sidekiq.org/) for more details and how to buy.
 
+5.0.1
+---------
+
+- Rejigger batch failures UI to add direct links to retries and scheduled jobs [#4209]
+- Delete batch data with `UNLINK` [#4155]
+- Fix bug where a scheduled job can lose its scheduled time when using reliable push [#4267]
+- Sidekiq::JobSet#scan and #find_job APIs have been promoted to Sidekiq OSS. [#4259]
+
 5.0.0
 ---------
 
 - There is no significant migration from Sidekiq Pro 4.0 to 5.0
   but make sure you read the [update notes for Sidekiq
-6.0](/mperham/sidekiq/blob/master/6.0-Upgrade.md).
+6.0](https://github.com/mperham/sidekiq/blob/master/6.0-Upgrade.md).
 - Removed various deprecated APIs and associated warnings.
 - **BREAKING CHANGE** Remove the `Sidekiq::Batch::Status#dead_jobs` API in favor of
   `Sidekiq::Batch::Status#dead_jids`. [#4217]

data/README.md

@@ -3,6 +3,7 @@ Sidekiq
 
 [![Gem Version](https://badge.fury.io/rb/sidekiq.svg)](https://rubygems.org/gems/sidekiq)
 [![Code Climate](https://codeclimate.com/github/mperham/sidekiq.svg)](https://codeclimate.com/github/mperham/sidekiq)
+[![Test Coverage](https://codeclimate.com/github/mperham/sidekiq/badges/coverage.svg)](https://codeclimate.com/github/mperham/sidekiq/coverage)
 [![Build Status](https://circleci.com/gh/mperham/sidekiq/tree/master.svg?style=svg)](https://circleci.com/gh/mperham/sidekiq/tree/master)
 [![Gitter Chat](https://badges.gitter.im/mperham/sidekiq.svg)](https://gitter.im/mperham/sidekiq)
 
@@ -18,7 +19,8 @@ Performance
 
 Version |	Latency | Garbage created for 10k jobs	| Time to process 100k jobs |	Throughput | Ruby
 -----------------|------|---------|---------|------------------------|-----
-Sidekiq 6.0.0    | 3 ms	| 156 MB  | 19 sec  | **5200 jobs/sec** | MRI 2.6.3
+Sidekiq 6.0.2    | 3 ms	| 156 MB  | 14.0 sec| **7100 jobs/sec** | MRI 2.6.3
+Sidekiq 6.0.0    | 3 ms	| 156 MB  | 19 sec  | 5200 jobs/sec | MRI 2.6.3
 Sidekiq 4.0.0    | 10 ms	| 151 MB  | 22 sec  | 4500 jobs/sec |
 Sidekiq 3.5.1    | 22 ms	| 1257 MB | 125 sec | 800 jobs/sec |
 Resque 1.25.2    |  -	  | -       | 420 sec | 240 jobs/sec |

data/bin/sidekiqload

@@ -5,7 +5,8 @@
 $TESTING = false
 
 #require 'ruby-prof'
-Bundler.require(:default)
+require 'bundler/setup'
+Bundler.require(:default, :load_test)
 
 require_relative '../lib/sidekiq/cli'
 require_relative '../lib/sidekiq/launcher'
@@ -102,17 +103,20 @@ iter.times do
 end
 Sidekiq.logger.error "Created #{count*iter} jobs"
 
+start = Time.now
+
 Monitoring = Thread.new do
   watchdog("monitor thread") do
     while true
-      sleep 0.5
+      sleep 0.2
       qsize = Sidekiq.redis do |conn|
         conn.llen "queue:default"
       end
       total = qsize
-      Sidekiq.logger.error("RSS: #{Process.rss} Pending: #{total}")
+      #Sidekiq.logger.error("RSS: #{Process.rss} Pending: #{total}")
       if total == 0
-        Sidekiq.logger.error("Done, now here's the latency for three jobs")
+        Sidekiq.logger.error("Done, #{iter * count} jobs in #{Time.now - start} sec")
+        Sidekiq.logger.error("Now here's the latency for three jobs")
 
         LoadWorker.perform_async(1, Time.now.to_f)
         LoadWorker.perform_async(2, Time.now.to_f)

data/bin/sidekiqmon

@@ -2,8 +2,7 @@
 
 require 'sidekiq/monitor'
 
-if ARGV[0] == 'status'
-  Sidekiq::Monitor::Status.new.display(ARGV[1])
-else
-  Sidekiq::Monitor.print_usage
-end
+section = "all"
+section = ARGV[0] if ARGV.size == 1
+
+Sidekiq::Monitor::Status.new.display(section)

data/lib/generators/sidekiq/worker_generator.rb

@@ -16,7 +16,9 @@ module Sidekiq
       end
 
       def create_test_file
-        if defined?(RSpec)
+        return unless test_framework
+
+        if test_framework == :rspec
           create_worker_spec
         else
           create_worker_test
@@ -42,6 +44,14 @@ module Sidekiq
         )
         template "worker_test.rb.erb", template_file
       end
+
+      def file_name
+        @_file_name ||= super.sub(/_?worker\z/i, "")
+      end
+
+      def test_framework
+        ::Rails.application.config.generators.options[:rails][:test_framework]
+      end
     end
   end
 end

data/lib/sidekiq.rb

@@ -192,6 +192,7 @@ module Sidekiq
 
   def self.log_formatter=(log_formatter)
     @log_formatter = log_formatter
+    logger.formatter = log_formatter
   end
 
   def self.logger
@@ -199,9 +200,20 @@ module Sidekiq
   end
 
   def self.logger=(logger)
+    if logger.nil?
+      self.logger.level = Logger::FATAL
+      return self.logger
+    end
+
+    logger.extend(Sidekiq::LoggingUtils)
+
     @logger = logger
   end
 
+  def self.pro?
+    defined?(Sidekiq::Pro)
+  end
+
   # How frequently Redis should be checked by a random Sidekiq process for
   # scheduled and retriable jobs. Each individual process will take turns by
   # waiting some multiple of this value.

data/lib/sidekiq/api.rb

@@ -2,23 +2,11 @@
 
 require "sidekiq"
 
-module Sidekiq
-  module RedisScanner
-    def sscan(conn, key)
-      cursor = "0"
-      result = []
-      loop do
-        cursor, values = conn.sscan(key, cursor)
-        result.push(*values)
-        break if cursor == "0"
-      end
-      result
-    end
-  end
+require "zlib"
+require "base64"
 
+module Sidekiq
   class Stats
-    include RedisScanner
-
     def initialize
       fetch_stats!
     end
@@ -77,11 +65,11 @@ module Sidekiq
       }
 
       processes = Sidekiq.redis { |conn|
-        sscan(conn, "processes")
+        conn.sscan_each("processes").to_a
       }
 
       queues = Sidekiq.redis { |conn|
-        sscan(conn, "queues")
+        conn.sscan_each("queues").to_a
       }
 
       pipe2_res = Sidekiq.redis { |conn|
@@ -92,8 +80,8 @@ module Sidekiq
       }
 
       s = processes.size
-      workers_size = pipe2_res[0...s].map(&:to_i).inject(0, &:+)
-      enqueued = pipe2_res[s..-1].map(&:to_i).inject(0, &:+)
+      workers_size = pipe2_res[0...s].sum(&:to_i)
+      enqueued = pipe2_res[s..-1].sum(&:to_i)
 
       default_queue_latency = if (entry = pipe1_res[6].first)
         job = begin
@@ -142,11 +130,9 @@ module Sidekiq
     end
 
     class Queues
-      include RedisScanner
-
       def lengths
         Sidekiq.redis do |conn|
-          queues = sscan(conn, "queues")
+          queues = conn.sscan_each("queues").to_a
 
           lengths = conn.pipelined {
             queues.each do |queue|
@@ -154,13 +140,8 @@ module Sidekiq
             end
           }
 
-          i = 0
-          array_of_arrays = queues.each_with_object({}) { |queue, memo|
-            memo[queue] = lengths[i]
-            i += 1
-          }.sort_by { |_, size| size }
-
-          Hash[array_of_arrays.reverse]
+          array_of_arrays = queues.zip(lengths).sort_by { |_, size| -size }
+          Hash[array_of_arrays]
         end
       end
     end
@@ -182,18 +163,12 @@ module Sidekiq
       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")
-          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")
+        }
+
+        keys = dates.map { |datestr| "stat:#{stat}:#{datestr}" }
 
         begin
           Sidekiq.redis do |conn|
@@ -225,13 +200,12 @@ module Sidekiq
   #
   class Queue
     include Enumerable
-    extend RedisScanner
 
     ##
     # Return all known queues within Redis.
     #
     def self.all
-      Sidekiq.redis { |c| sscan(c, "queues") }.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
@@ -299,7 +273,7 @@ module Sidekiq
     def clear
       Sidekiq.redis do |conn|
         conn.multi do
-          conn.del(@rname)
+          conn.unlink(@rname)
           conn.srem("queues", name)
         end
       end
@@ -349,7 +323,7 @@ module Sidekiq
                    end
                  when "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
                    job_class = @item["wrapped"] || args[0]
-                   if job_class == "ActionMailer::DeliveryJob"
+                   if job_class == "ActionMailer::DeliveryJob" || job_class == "ActionMailer::MailDeliveryJob"
                      # MailerClass#mailer_method
                      args[0]["arguments"][0..1].join("#")
                    else
@@ -372,6 +346,9 @@ module Sidekiq
                   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
                   end
@@ -400,6 +377,20 @@ module Sidekiq
       Time.at(self["created_at"] || self["enqueued_at"] || 0).utc
     end
 
+    def tags
+      self["tags"] || []
+    end
+
+    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
@@ -433,6 +424,23 @@ module Sidekiq
       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
@@ -458,8 +466,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
@@ -503,7 +512,7 @@ module Sidekiq
         else
           # multiple jobs with the same score
           # find the one with the right JID and push it
-          hash = results.group_by { |message|
+          matched, nonmatched = results.partition { |message|
             if message.index(jid)
               msg = Sidekiq.load_json(message)
               msg["jid"] == jid
@@ -512,12 +521,12 @@ module Sidekiq
             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
@@ -540,9 +549,20 @@ 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
@@ -576,28 +596,40 @@ module Sidekiq
       end
     end
 
+    ##
+    # Fetch jobs that match a given time or Range. Job ID is an
+    # optional second argument.
     def fetch(score, jid = nil)
+      begin_score, end_score =
+        if score.is_a?(Range)
+          [score.first, score.last]
+        else
+          [score, score]
+        end
+
       elements = Sidekiq.redis { |conn|
-        conn.zrangebyscore(name, score, score)
+        conn.zrangebyscore(name, begin_score, end_score, with_scores: true)
       }
 
       elements.each_with_object([]) do |element, result|
-        entry = SortedEntry.new(self, score, element)
-        if jid
-          result << entry if entry.jid == jid
-        else
-          result << entry
-        end
+        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)
-      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)
@@ -612,11 +644,13 @@ 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
         end
       end
@@ -720,7 +754,6 @@ module Sidekiq
   #
   class ProcessSet
     include Enumerable
-    include RedisScanner
 
     def initialize(clean_plz = true)
       cleanup if clean_plz
@@ -731,7 +764,7 @@ module Sidekiq
     def cleanup
       count = 0
       Sidekiq.redis do |conn|
-        procs = sscan(conn, "processes").sort
+        procs = conn.sscan_each("processes").to_a.sort
         heartbeats = conn.pipelined {
           procs.each do |key|
             conn.hget(key, "info")
@@ -741,40 +774,37 @@ module Sidekiq
         # 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
+        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| sscan(conn, "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 {
+        conn.pipelined do
           procs.each do |key|
             conn.hmget(key, "info", "busy", "beat", "quiet")
           end
-        }
+        end
+      }
 
-        result.each do |info, busy, at_s, quiet|
-          # 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?
+      result.each do |info, busy, at_s, quiet|
+        # 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?
 
-          hash = Sidekiq.load_json(info)
-          yield Process.new(hash.merge("busy" => busy.to_i, "beat" => at_s.to_f, "quiet" => quiet))
-        end
+        hash = Sidekiq.load_json(info)
+        yield Process.new(hash.merge("busy" => busy.to_i, "beat" => at_s.to_f, "quiet" => quiet))
       end
-
-      nil
     end
 
     # This method is not guaranteed accurate since it does not prune the set
@@ -885,11 +915,10 @@ module Sidekiq
   #
   class Workers
     include Enumerable
-    include RedisScanner
 
     def each
       Sidekiq.redis do |conn|
-        procs = sscan(conn, "processes")
+        procs = conn.sscan_each("processes").to_a
         procs.sort.each do |key|
           valid, workers = conn.pipelined {
             conn.exists(key)
@@ -897,7 +926,11 @@ module Sidekiq
           }
           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)
+            yield key, tid, hsh
           end
         end
       end
@@ -911,7 +944,7 @@ module Sidekiq
     # which can easily get out of sync with crashy processes.
     def size
       Sidekiq.redis do |conn|
-        procs = sscan(conn, "processes")
+        procs = conn.sscan_each("processes").to_a
         if procs.empty?
           0
         else
@@ -919,7 +952,7 @@ module Sidekiq
             procs.each do |key|
               conn.hget(key, "busy")
             end
-          }.map(&:to_i).inject(:+)
+          }.sum(&:to_i)
         end
       end
     end