sidekiq 4.2.10 → 6.5.7

data/lib/sidekiq/middleware/current_attributes.rb

@@ -0,0 +1,63 @@
+require "active_support/current_attributes"
+
+module Sidekiq
+  ##
+  # Automatically save and load any current attributes in the execution context
+  # so context attributes "flow" from Rails actions into any associated jobs.
+  # This can be useful for multi-tenancy, i18n locale, timezone, any implicit
+  # per-request attribute. See +ActiveSupport::CurrentAttributes+.
+  #
+  # @example
+  #
+  #   # in your initializer
+  #   require "sidekiq/middleware/current_attributes"
+  #   Sidekiq::CurrentAttributes.persist(Myapp::Current)
+  #
+  module CurrentAttributes
+    class Save
+      include Sidekiq::ClientMiddleware
+
+      def initialize(cattr)
+        @klass = cattr
+      end
+
+      def call(_, job, _, _)
+        attrs = @klass.attributes
+        if attrs.any?
+          if job.has_key?("cattr")
+            job["cattr"].merge!(attrs)
+          else
+            job["cattr"] = attrs
+          end
+        end
+        yield
+      end
+    end
+
+    class Load
+      include Sidekiq::ServerMiddleware
+
+      def initialize(cattr)
+        @klass = cattr
+      end
+
+      def call(_, job, _, &block)
+        if job.has_key?("cattr")
+          @klass.set(job["cattr"], &block)
+        else
+          yield
+        end
+      end
+    end
+
+    def self.persist(klass)
+      Sidekiq.configure_client do |config|
+        config.client_middleware.add Save, klass
+      end
+      Sidekiq.configure_server do |config|
+        config.client_middleware.add Save, klass
+        config.server_middleware.add Load, klass
+      end
+    end
+  end
+end

data/lib/sidekiq/middleware/i18n.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 #
 # Simple middleware to save the current locale and restore it when the job executes.
 # Use it by requiring it in your initializer:
@@ -9,19 +10,18 @@ module Sidekiq::Middleware::I18n
   # Get the current locale and store it in the message
   # to be sent to Sidekiq.
   class Client
-    def call(worker_class, msg, queue, redis_pool)
-      msg['locale'] ||= I18n.locale
+    include Sidekiq::ClientMiddleware
+    def call(_jobclass, job, _queue, _redis)
+      job["locale"] ||= I18n.locale
       yield
     end
   end
 
   # Pull the msg locale out and set the current thread to use it.
   class Server
-    def call(worker, msg, queue)
-      I18n.locale = msg['locale'] || I18n.default_locale
-      yield
-    ensure
-      I18n.locale = I18n.default_locale
+    include Sidekiq::ServerMiddleware
+    def call(_jobclass, job, _queue, &block)
+      I18n.with_locale(job.fetch("locale", I18n.default_locale), &block)
     end
   end
 end

data/lib/sidekiq/middleware/modules.rb

@@ -0,0 +1,21 @@
+module Sidekiq
+  # Server-side middleware must import this Module in order
+  # to get access to server resources during `call`.
+  module ServerMiddleware
+    attr_accessor :config
+    def redis_pool
+      config.redis_pool
+    end
+
+    def logger
+      config.logger
+    end
+
+    def redis(&block)
+      config.redis(&block)
+    end
+  end
+
+  # no difference for now
+  ClientMiddleware = ServerMiddleware
+end

data/lib/sidekiq/monitor.rb

@@ -0,0 +1,133 @@
+#!/usr/bin/env ruby
+
+require "fileutils"
+require "sidekiq/api"
+
+class Sidekiq::Monitor
+  class Status
+    VALID_SECTIONS = %w[all version overview processes queues]
+    COL_PAD = 2
+
+    def display(section = nil)
+      section ||= "all"
+      unless VALID_SECTIONS.include? section
+        puts "I don't know how to check the status of '#{section}'!"
+        puts "Try one of these: #{VALID_SECTIONS.join(", ")}"
+        return
+      end
+      send(section)
+    rescue => e
+      abort "Couldn't get status: #{e}"
+    end
+
+    def all
+      version
+      puts
+      overview
+      puts
+      processes
+      puts
+      queues
+    end
+
+    def version
+      puts "Sidekiq #{Sidekiq::VERSION}"
+      puts Time.now.utc
+    end
+
+    def overview
+      puts "---- Overview ----"
+      puts "  Processed: #{delimit stats.processed}"
+      puts "     Failed: #{delimit stats.failed}"
+      puts "       Busy: #{delimit stats.workers_size}"
+      puts "   Enqueued: #{delimit stats.enqueued}"
+      puts "    Retries: #{delimit stats.retry_size}"
+      puts "  Scheduled: #{delimit stats.scheduled_size}"
+      puts "       Dead: #{delimit stats.dead_size}"
+    end
+
+    def processes
+      puts "---- Processes (#{process_set.size}) ----"
+      process_set.each_with_index do |process, index|
+        puts "#{process["identity"]} #{tags_for(process)}"
+        puts "  Started: #{Time.at(process["started_at"])} (#{time_ago(process["started_at"])})"
+        puts "  Threads: #{process["concurrency"]} (#{process["busy"]} busy)"
+        puts "   Queues: #{split_multiline(process["queues"].sort, pad: 11)}"
+        puts "" unless (index + 1) == process_set.size
+      end
+    end
+
+    def queues
+      puts "---- Queues (#{queue_data.size}) ----"
+      columns = {
+        name: [:ljust, (["name"] + queue_data.map(&:name)).map(&:length).max + COL_PAD],
+        size: [:rjust, (["size"] + queue_data.map(&:size)).map(&:length).max + COL_PAD],
+        latency: [:rjust, (["latency"] + queue_data.map(&:latency)).map(&:length).max + COL_PAD]
+      }
+      columns.each { |col, (dir, width)| print col.to_s.upcase.public_send(dir, width) }
+      puts
+      queue_data.each do |q|
+        columns.each do |col, (dir, width)|
+          print q.send(col).public_send(dir, width)
+        end
+        puts
+      end
+    end
+
+    private
+
+    def delimit(number)
+      number.to_s.reverse.scan(/.{1,3}/).join(",").reverse
+    end
+
+    def split_multiline(values, opts = {})
+      return "none" unless values
+      pad = opts[:pad] || 0
+      max_length = opts[:max_length] || (80 - pad)
+      out = []
+      line = ""
+      values.each do |value|
+        if (line.length + value.length) > max_length
+          out << line
+          line = " " * pad
+        end
+        line << value + ", "
+      end
+      out << line[0..-3]
+      out.join("\n")
+    end
+
+    def tags_for(process)
+      tags = [
+        process["tag"],
+        process["labels"],
+        (process["quiet"] == "true" ? "quiet" : nil)
+      ].flatten.compact
+      tags.any? ? "[#{tags.join("] [")}]" : nil
+    end
+
+    def time_ago(timestamp)
+      seconds = Time.now - Time.at(timestamp)
+      return "just now" if seconds < 60
+      return "a minute ago" if seconds < 120
+      return "#{seconds.floor / 60} minutes ago" if seconds < 3600
+      return "an hour ago" if seconds < 7200
+      "#{seconds.floor / 60 / 60} hours ago"
+    end
+
+    QUEUE_STRUCT = Struct.new(:name, :size, :latency)
+    def queue_data
+      @queue_data ||= Sidekiq::Queue.all.map { |q|
+        QUEUE_STRUCT.new(q.name, q.size.to_s, sprintf("%#.2f", q.latency))
+      }
+    end
+
+    def process_set
+      @process_set ||= Sidekiq::ProcessSet.new
+    end
+
+    def stats
+      @stats ||= Sidekiq::Stats.new
+    end
+  end
+end

data/lib/sidekiq/paginator.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
+
 module Sidekiq
   module Paginator
-
-    def page(key, pageidx=1, page_size=25, opts=nil)
+    def page(key, pageidx = 1, page_size = 25, opts = nil)
       current_page = pageidx.to_i < 1 ? 1 : pageidx.to_i
       pageidx = current_page - 1
       total_size = 0
@@ -12,32 +12,36 @@ module Sidekiq
 
       Sidekiq.redis do |conn|
         type = conn.type(key)
+        rev = opts && opts[:reverse]
 
         case type
-        when 'zset'
-          rev = opts && opts[:reverse]
-          total_size, items = conn.multi do
-            conn.zcard(key)
+        when "zset"
+          total_size, items = conn.multi { |transaction|
+            transaction.zcard(key)
             if rev
-              conn.zrevrange(key, starting, ending, :with_scores => true)
+              transaction.zrevrange(key, starting, ending, withscores: true)
             else
-              conn.zrange(key, starting, ending, :with_scores => true)
+              transaction.zrange(key, starting, ending, withscores: true)
             end
-          end
+          }
           [current_page, total_size, items]
-        when 'list'
-          total_size, items = conn.multi do
-            conn.llen(key)
-            conn.lrange(key, starting, ending)
-          end
+        when "list"
+          total_size, items = conn.multi { |transaction|
+            transaction.llen(key)
+            if rev
+              transaction.lrange(key, -ending - 1, -starting - 1)
+            else
+              transaction.lrange(key, starting, ending)
+            end
+          }
+          items.reverse! if rev
           [current_page, total_size, items]
-        when 'none'
+        when "none"
           [1, 0, []]
         else
           raise "can't page a #{type}"
         end
       end
     end
-
   end
 end

data/lib/sidekiq/processor.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
-require 'sidekiq/util'
-require 'sidekiq/fetch'
-require 'thread'
-require 'concurrent/map'
-require 'concurrent/atomic/atomic_fixnum'
+
+require "sidekiq/fetch"
+require "sidekiq/job_logger"
+require "sidekiq/job_retry"
 
 module Sidekiq
   ##
@@ -11,44 +10,45 @@ module Sidekiq
   #
   # 1. fetches a job from Redis
   # 2. executes the job
-  #   a. instantiate the Worker
+  #   a. instantiate the job class
   #   b. run the middleware chain
   #   c. call #perform
   #
-  # A Processor can exit due to shutdown (processor_stopped)
-  # or due to an error during job execution (processor_died)
+  # A Processor can exit due to shutdown or due to
+  # an error during job execution.
   #
   # If an error occurs in the job execution, the
   # Processor calls the Manager to create a new one
   # to replace itself and exits.
   #
   class Processor
-
-    include Util
+    include Sidekiq::Component
 
     attr_reader :thread
     attr_reader :job
 
-    def initialize(mgr)
-      @mgr = mgr
+    def initialize(options, &block)
+      @callback = block
       @down = false
       @done = false
       @job = nil
       @thread = nil
-      @strategy = (mgr.options[:fetch] || Sidekiq::BasicFetch).new(mgr.options)
-      @reloader = Sidekiq.options[:reloader]
-      @executor = Sidekiq.options[:executor]
+      @config = options
+      @strategy = options[:fetch]
+      @reloader = options[:reloader] || proc { |&block| block.call }
+      @job_logger = (options[:job_logger] || Sidekiq::JobLogger).new
+      @retrier = Sidekiq::JobRetry.new(options)
     end
 
-    def terminate(wait=false)
+    def terminate(wait = false)
       @done = true
-      return if !@thread
+      return unless @thread
       @thread.value if wait
     end
 
-    def kill(wait=false)
+    def kill(wait = false)
       @done = true
-      return if !@thread
+      return unless @thread
       # unlike the other actors, terminate does not wait
       # for the thread to finish because we don't know how
       # long the job will take to finish.  Instead we
@@ -65,33 +65,30 @@ module Sidekiq
     private unless $TESTING
 
     def run
-      begin
-        while !@done
-          process_one
-        end
-        @mgr.processor_stopped(self)
-      rescue Sidekiq::Shutdown
-        @mgr.processor_stopped(self)
-      rescue Exception => ex
-        @mgr.processor_died(self, ex)
-      end
+      process_one until @done
+      @callback.call(self)
+    rescue Sidekiq::Shutdown
+      @callback.call(self)
+    rescue Exception => ex
+      @callback.call(self, ex)
     end
 
-    def process_one
+    def process_one(&block)
       @job = fetch
       process(@job) if @job
       @job = nil
     end
 
     def get_one
-      begin
-        work = @strategy.retrieve_work
-        (logger.info { "Redis is online, #{Time.now - @down} sec downtime" }; @down = nil) if @down
-        work
-      rescue Sidekiq::Shutdown
-      rescue => ex
-        handle_fetch_exception(ex)
+      uow = @strategy.retrieve_work
+      if @down
+        logger.info { "Redis is online, #{::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - @down} sec downtime" }
+        @down = nil
       end
+      uow
+    rescue Sidekiq::Shutdown
+    rescue => ex
+      handle_fetch_exception(ex)
     end
 
     def fetch
@@ -105,97 +102,185 @@ module Sidekiq
     end
 
     def handle_fetch_exception(ex)
-      if !@down
-        @down = Time.now
+      unless @down
+        @down = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
         logger.error("Error fetching job: #{ex}")
-        ex.backtrace.each do |bt|
-          logger.error(bt)
-        end
+        handle_exception(ex)
       end
       sleep(1)
       nil
     end
 
-    def process(work)
-      jobstr = work.job
-      queue = work.queue_name
+    def dispatch(job_hash, queue, jobstr)
+      # since middleware can mutate the job hash
+      # we need to clone it to report the original
+      # job structure to the Web UI
+      # or to push back to redis when retrying.
+      # To avoid costly and, most of the time, useless cloning here,
+      # we pass original String of JSON to respected methods
+      # to re-parse it there if we need access to the original, untouched job
 
-      ack = false
-      begin
-        job_hash = Sidekiq.load_json(jobstr)
-        @reloader.call do
-          klass  = job_hash['class'.freeze].constantize
-          worker = klass.new
-          worker.jid = job_hash['jid'.freeze]
-
-          stats(worker, job_hash, queue) do
-            Sidekiq::Logging.with_context(log_context(job_hash)) do
-              ack = true
-              Sidekiq.server_middleware.invoke(worker, job_hash, queue) do
-                @executor.call do
-                  # Only ack if we either attempted to start this job or
-                  # successfully completed it. This prevents us from
-                  # losing jobs if a middleware raises an exception before yielding
-                  execute_job(worker, cloned(job_hash['args'.freeze]))
+      @job_logger.prepare(job_hash) do
+        @retrier.global(jobstr, queue) do
+          @job_logger.call(job_hash, queue) do
+            stats(jobstr, queue) do
+              # Rails 5 requires a Reloader to wrap code execution.  In order to
+              # constantize the worker and instantiate an instance, we have to call
+              # the Reloader.  It handles code loading, db connection management, etc.
+              # Effectively this block denotes a "unit of work" to Rails.
+              @reloader.call do
+                klass = constantize(job_hash["class"])
+                inst = klass.new
+                inst.jid = job_hash["jid"]
+                @retrier.local(inst, jobstr, queue) do
+                  yield inst
                 end
               end
             end
           end
-          ack = true
         end
+      end
+    end
+
+    def process(uow)
+      jobstr = uow.job
+      queue = uow.queue_name
+
+      # Treat malformed JSON as a special case: job goes straight to the morgue.
+      job_hash = nil
+      begin
+        job_hash = Sidekiq.load_json(jobstr)
+      rescue => ex
+        handle_exception(ex, {context: "Invalid JSON for job", jobstr: jobstr})
+        now = Time.now.to_f
+        config.redis do |conn|
+          conn.multi do |xa|
+            xa.zadd("dead", now.to_s, jobstr)
+            xa.zremrangebyscore("dead", "-inf", now - config[:dead_timeout_in_seconds])
+            xa.zremrangebyrank("dead", 0, - config[:dead_max_jobs])
+          end
+        end
+        return uow.acknowledge
+      end
+
+      ack = false
+      begin
+        dispatch(job_hash, queue, jobstr) do |inst|
+          @config.server_middleware.invoke(inst, job_hash, queue) do
+            execute_job(inst, job_hash["args"])
+          end
+        end
+        ack = true
       rescue Sidekiq::Shutdown
         # Had to force kill this job because it didn't finish
         # within the timeout.  Don't acknowledge the work since
         # we didn't properly finish it.
-        ack = false
+      rescue Sidekiq::JobRetry::Handled => h
+        # this is the common case: job raised error and Sidekiq::JobRetry::Handled
+        # signals that we created a retry successfully.  We can acknowlege the job.
+        ack = true
+        e = h.cause || h
+        handle_exception(e, {context: "Job raised exception", job: job_hash})
+        raise e
       rescue Exception => ex
-        handle_exception(ex, { :context => "Job raised exception", :job => job_hash, :jobstr => jobstr })
-        raise
+        # Unexpected error!  This is very bad and indicates an exception that got past
+        # the retry subsystem (e.g. network partition).  We won't acknowledge the job
+        # so it can be rescued when using Sidekiq Pro.
+        handle_exception(ex, {context: "Internal exception!", job: job_hash, jobstr: jobstr})
+        raise ex
       ensure
-        work.acknowledge if ack
+        if ack
+          # We don't want a shutdown signal to interrupt job acknowledgment.
+          Thread.handle_interrupt(Sidekiq::Shutdown => :never) do
+            uow.acknowledge
+          end
+        end
       end
     end
 
-    # If we're using a wrapper class, like ActiveJob, use the "wrapped"
-    # attribute to expose the underlying thing.
-    def log_context(item)
-      klass = item['wrapped'.freeze] || item['class'.freeze]
-      "#{klass} JID-#{item['jid'.freeze]}#{" BID-#{item['bid'.freeze]}" if item['bid'.freeze]}"
+    def execute_job(inst, cloned_args)
+      inst.perform(*cloned_args)
     end
 
-    def execute_job(worker, cloned_args)
-      worker.perform(*cloned_args)
+    # Ruby doesn't provide atomic counters out of the box so we'll
+    # implement something simple ourselves.
+    # https://bugs.ruby-lang.org/issues/14706
+    class Counter
+      def initialize
+        @value = 0
+        @lock = Mutex.new
+      end
+
+      def incr(amount = 1)
+        @lock.synchronize { @value += amount }
+      end
+
+      def reset
+        @lock.synchronize {
+          val = @value
+          @value = 0
+          val
+        }
+      end
     end
 
-    def thread_identity
-      @str ||= Thread.current.object_id.to_s(36)
+    # jruby's Hash implementation is not threadsafe, so we wrap it in a mutex here
+    class SharedWorkState
+      def initialize
+        @work_state = {}
+        @lock = Mutex.new
+      end
+
+      def set(tid, hash)
+        @lock.synchronize { @work_state[tid] = hash }
+      end
+
+      def delete(tid)
+        @lock.synchronize { @work_state.delete(tid) }
+      end
+
+      def dup
+        @lock.synchronize { @work_state.dup }
+      end
+
+      def size
+        @lock.synchronize { @work_state.size }
+      end
+
+      def clear
+        @lock.synchronize { @work_state.clear }
+      end
     end
 
-    WORKER_STATE = Concurrent::Map.new
-    PROCESSED = Concurrent::AtomicFixnum.new
-    FAILURE = Concurrent::AtomicFixnum.new
+    PROCESSED = Counter.new
+    FAILURE = Counter.new
+    WORK_STATE = SharedWorkState.new
 
-    def stats(worker, job_hash, queue)
-      tid = thread_identity
-      WORKER_STATE[tid] = {:queue => queue, :payload => cloned(job_hash), :run_at => Time.now.to_i }
+    def stats(jobstr, queue)
+      WORK_STATE.set(tid, {queue: queue, payload: jobstr, run_at: Time.now.to_i})
 
       begin
         yield
       rescue Exception
-        FAILURE.increment
+        FAILURE.incr
         raise
       ensure
-        WORKER_STATE.delete(tid)
-        PROCESSED.increment
+        WORK_STATE.delete(tid)
+        PROCESSED.incr
       end
     end
 
-    # Deep clone the arguments passed to the worker so that if
-    # the job fails, what is pushed back onto Redis hasn't
-    # been mutated by the worker.
-    def cloned(ary)
-      Marshal.load(Marshal.dump(ary))
-    end
+    def constantize(str)
+      return Object.const_get(str) unless str.include?("::")
 
+      names = str.split("::")
+      names.shift if names.empty? || names.first.empty?
+
+      names.inject(Object) do |constant, name|
+        # the false flag limits search for name to under the constant namespace
+        #   which mimics Rails' behaviour
+        constant.const_get(name, false)
+      end
+    end
   end
 end