sidekiq 5.2.9 → 6.0.0

data/lib/sidekiq/logger.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "logger"
+require "time"
+
+module Sidekiq
+  class Logger < ::Logger
+    def initialize(*args)
+      super
+
+      self.formatter = Sidekiq.log_formatter
+    end
+
+    def with_context(hash)
+      ctx.merge!(hash)
+      yield
+    ensure
+      hash.keys.each { |key| ctx.delete(key) }
+    end
+
+    def ctx
+      Thread.current[:sidekiq_context] ||= {}
+    end
+
+    module Formatters
+      class Base < ::Logger::Formatter
+        def tid
+          Thread.current["sidekiq_tid"] ||= (Thread.current.object_id ^ ::Process.pid).to_s(36)
+        end
+
+        def ctx
+          Thread.current[:sidekiq_context] ||= {}
+        end
+
+        def format_context
+          " " + ctx.compact.map { |k, v| "#{k}=#{v}" }.join(" ") if ctx.any?
+        end
+      end
+
+      class Pretty < Base
+        def call(severity, time, program_name, message)
+          "#{time.utc.iso8601(3)} pid=#{::Process.pid} tid=#{tid}#{format_context} #{severity}: #{message}\n"
+        end
+      end
+
+      class WithoutTimestamp < Pretty
+        def call(severity, time, program_name, message)
+          "pid=#{::Process.pid} tid=#{tid}#{format_context} #{severity}: #{message}\n"
+        end
+      end
+
+      class JSON < Base
+        def call(severity, time, program_name, message)
+          hash = {
+            ts: time.utc.iso8601(3),
+            pid: ::Process.pid,
+            tid: tid,
+            lvl: severity,
+            msg: message,
+          }
+          c = ctx
+          hash["ctx"] = c unless c.empty?
+
+          Sidekiq.dump_json(hash) << "\n"
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/manager.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
-require 'sidekiq/util'
-require 'sidekiq/processor'
-require 'sidekiq/fetch'
-require 'thread'
-require 'set'
 
-module Sidekiq
+require "sidekiq/util"
+require "sidekiq/processor"
+require "sidekiq/fetch"
+require "set"
 
+module Sidekiq
   ##
   # The Manager is the central coordination point in Sidekiq, controlling
   # the lifecycle of the Processors.
@@ -27,7 +26,7 @@ module Sidekiq
     attr_reader :workers
     attr_reader :options
 
-    def initialize(options={})
+    def initialize(options = {})
       logger.debug { options.inspect }
       @options = options
       @count = options[:concurrency] || 10
@@ -113,7 +112,7 @@ module Sidekiq
       end
 
       if cleanup.size > 0
-        jobs = cleanup.map {|p| p.job }.compact
+        jobs = cleanup.map { |p| p.job }.compact
 
         logger.warn { "Terminating #{cleanup.size} busy worker threads" }
         logger.warn { "Work still in progress #{jobs.inspect}" }
@@ -132,6 +131,5 @@ module Sidekiq
         processor.kill
       end
     end
-
   end
 end

data/lib/sidekiq/middleware/chain.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Sidekiq
   # Middleware is code configured to run before/after
   # a message is processed.  It is patterned after Rack
@@ -106,7 +107,7 @@ module Sidekiq
         i = entries.index { |entry| entry.klass == newklass }
         new_entry = i.nil? ? Entry.new(newklass, *args) : entries.delete_at(i)
         i = entries.index { |entry| entry.klass == oldklass } || entries.count - 1
-        entries.insert(i+1, new_entry)
+        entries.insert(i + 1, new_entry)
       end
 
       def exists?(klass)
@@ -139,7 +140,7 @@ module Sidekiq
 
       def initialize(klass, *args)
         @klass = klass
-        @args  = args
+        @args = args
       end
 
       def make_new

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,16 @@ 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
+    def call(_worker, msg, _queue, _redis)
+      msg["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
+    def call(_worker, msg, _queue, &block)
+      I18n.with_locale(msg.fetch("locale", I18n.default_locale), &block)
     end
   end
 end

data/lib/sidekiq/monitor.rb

@@ -0,0 +1,148 @@
+#!/usr/bin/env ruby
+
+require "fileutils"
+require "sidekiq/api"
+
+class Sidekiq::Monitor
+  CMD = File.basename($PROGRAM_NAME)
+
+  attr_reader :stage
+
+  def self.print_usage
+    puts "#{CMD} - monitor Sidekiq from the command line."
+    puts
+    puts "Usage: #{CMD} status <section>"
+    puts
+    puts "       <section> (optional) view a specific section of the status output"
+    puts "       Valid sections are: #{Sidekiq::Monitor::Status::VALID_SECTIONS.join(", ")}"
+    puts
+    puts "Set REDIS_URL to the location of your Redis server if not monitoring localhost."
+  end
+
+  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
+      puts "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
+    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
@@ -14,30 +14,29 @@ module Sidekiq
         type = conn.type(key)
 
         case type
-        when 'zset'
+        when "zset"
           rev = opts && opts[:reverse]
-          total_size, items = conn.multi do
+          total_size, items = conn.multi {
             conn.zcard(key)
             if rev
-              conn.zrevrange(key, starting, ending, :with_scores => true)
+              conn.zrevrange(key, starting, ending, with_scores: true)
             else
-              conn.zrange(key, starting, ending, :with_scores => true)
+              conn.zrange(key, starting, ending, with_scores: true)
             end
-          end
+          }
           [current_page, total_size, items]
-        when 'list'
-          total_size, items = conn.multi do
+        when "list"
+          total_size, items = conn.multi {
             conn.llen(key)
             conn.lrange(key, starting, ending)
-          end
+          }
           [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,9 @@
 # frozen_string_literal: true
-require 'sidekiq/util'
-require 'sidekiq/fetch'
-require 'sidekiq/job_logger'
-require 'sidekiq/job_retry'
-require 'thread'
+
+require "sidekiq/util"
+require "sidekiq/fetch"
+require "sidekiq/job_logger"
+require "sidekiq/job_retry"
 
 module Sidekiq
   ##
@@ -23,7 +23,6 @@ module Sidekiq
   # to replace itself and exits.
   #
   class Processor
-
     include Util
 
     attr_reader :thread
@@ -37,19 +36,19 @@ module Sidekiq
       @thread = nil
       @strategy = (mgr.options[:fetch] || Sidekiq::BasicFetch).new(mgr.options)
       @reloader = Sidekiq.options[:reloader]
-      @logging = (mgr.options[:job_logger] || Sidekiq::JobLogger).new
+      @job_logger = (mgr.options[:job_logger] || Sidekiq::JobLogger).new
       @retrier = Sidekiq::JobRetry.new
     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
@@ -66,16 +65,12 @@ 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
+      @mgr.processor_stopped(self)
+    rescue Sidekiq::Shutdown
+      @mgr.processor_stopped(self)
+    rescue Exception => ex
+      @mgr.processor_died(self, ex)
     end
 
     def process_one
@@ -85,14 +80,15 @@ module Sidekiq
     end
 
     def get_one
-      begin
-        work = @strategy.retrieve_work
-        (logger.info { "Redis is online, #{::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - @down} sec downtime" }; @down = nil) if @down
-        work
-      rescue Sidekiq::Shutdown
-      rescue => ex
-        handle_fetch_exception(ex)
+      work = @strategy.retrieve_work
+      if @down
+        logger.info { "Redis is online, #{::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - @down} sec downtime" }
+        @down = nil
       end
+      work
+    rescue Sidekiq::Shutdown
+    rescue => ex
+      handle_fetch_exception(ex)
     end
 
     def fetch
@@ -106,7 +102,7 @@ module Sidekiq
     end
 
     def handle_fetch_exception(ex)
-      if !@down
+      unless @down
         @down = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
         logger.error("Error fetching job: #{ex}")
         handle_exception(ex)
@@ -121,18 +117,18 @@ module Sidekiq
       # job structure to the Web UI
       pristine = cloned(job_hash)
 
-      Sidekiq::Logging.with_job_hash_context(job_hash) do
+      @job_logger.with_job_hash_context(job_hash) do
         @retrier.global(pristine, queue) do
-          @logging.call(job_hash, queue) do
+          @job_logger.call(job_hash, queue) do
             stats(pristine, 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'])
+                klass = constantize(job_hash["class"])
                 worker = klass.new
-                worker.jid = job_hash['jid']
+                worker.jid = job_hash["jid"]
                 @retrier.local(worker, pristine, queue) do
                   yield worker
                 end
@@ -152,39 +148,44 @@ module Sidekiq
       begin
         job_hash = Sidekiq.load_json(jobstr)
       rescue => ex
-        handle_exception(ex, { :context => "Invalid JSON for job", :jobstr => jobstr })
+        handle_exception(ex, {context: "Invalid JSON for job", jobstr: jobstr})
         # we can't notify because the job isn't a valid hash payload.
         DeadSet.new.kill(jobstr, notify_failure: false)
         return work.acknowledge
       end
 
-      ack = true
+      ack = false
       begin
         dispatch(job_hash, queue) do |worker|
           Sidekiq.server_middleware.invoke(worker, job_hash, queue) do
-            execute_job(worker, cloned(job_hash['args']))
+            execute_job(worker, cloned(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.
-        e = h.cause ? h.cause : h
-        handle_exception(e, { :context => "Job raised exception", :job => job_hash, :jobstr => jobstr })
+        ack = true
+        e = h.cause || h
+        handle_exception(e, {context: "Job raised exception", job: job_hash, jobstr: jobstr})
         raise e
       rescue Exception => ex
         # 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.
-        ack = false
-        handle_exception(ex, { :context => "Internal exception!", :job => job_hash, :jobstr => jobstr })
+        handle_exception(ex, {context: "Internal exception!", job: job_hash, jobstr: jobstr})
         raise e
       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
+            work.acknowledge
+          end
+        end
       end
     end
 
@@ -201,12 +202,16 @@ module Sidekiq
         @lock = Mutex.new
       end
 
-      def incr(amount=1)
-        @lock.synchronize { @value = @value + amount }
+      def incr(amount = 1)
+        @lock.synchronize { @value += amount }
       end
 
       def reset
-        @lock.synchronize { val = @value; @value = 0; val }
+        @lock.synchronize {
+          val = @value
+          @value = 0
+          val
+        }
       end
     end
 
@@ -243,8 +248,7 @@ module Sidekiq
     WORKER_STATE = SharedWorkerState.new
 
     def stats(job_hash, queue)
-      tid = Sidekiq::Logging.tid
-      WORKER_STATE.set(tid, {:queue => queue, :payload => job_hash, :run_at => Time.now.to_i })
+      WORKER_STATE.set(tid, {queue: queue, payload: job_hash, run_at: Time.now.to_i})
 
       begin
         yield
@@ -265,7 +269,7 @@ module Sidekiq
     end
 
     def constantize(str)
-      names = str.split('::')
+      names = str.split("::")
       names.shift if names.empty? || names.first.empty?
 
       names.inject(Object) do |constant, name|
@@ -274,6 +278,5 @@ module Sidekiq
         constant.const_defined?(name, false) ? constant.const_get(name, false) : constant.const_missing(name)
       end
     end
-
   end
 end

data/lib/sidekiq/rails.rb

@@ -1,35 +1,35 @@
 # frozen_string_literal: true
 
+require "sidekiq/worker"
+
 module Sidekiq
   class Rails < ::Rails::Engine
-    # We need to setup this up before any application configuration which might
-    # change Sidekiq middleware.
+    # By including the Options module, we allow AJs to directly control sidekiq features
+    # via the *sidekiq_options* class method and, for instance, not use AJ's retry system.
+    # AJ retries don't show up in the Sidekiq UI Retries tab, save any error data, can't be
+    # manually retried, don't automatically die, etc.
     #
-    # This hook happens after `Rails::Application` is inherited within
-    # config/application.rb and before config is touched, usually within the
-    # class block. Definitely before config/environments/*.rb and
-    # config/initializers/*.rb.
-    config.before_configuration do
-      if ::Rails::VERSION::MAJOR < 5 && defined?(::ActiveRecord)
-        Sidekiq.server_middleware do |chain|
-          require 'sidekiq/middleware/server/active_record'
-          chain.add Sidekiq::Middleware::Server::ActiveRecord
-        end
+    #   class SomeJob < ActiveJob::Base
+    #     queue_as :default
+    #     sidekiq_options retry: 3, backtrace: 10
+    #     def perform
+    #     end
+    #   end
+    initializer "sidekiq.active_job_integration" do
+      ActiveSupport.on_load(:active_job) do
+        include ::Sidekiq::Worker::Options unless respond_to?(:sidekiq_options)
       end
     end
 
+    # This hook happens after all initializers are run, just before returning
+    # from config/environment.rb back to sidekiq/cli.rb.
+    # We have to add the reloader after initialize to see if cache_classes has
+    # been turned on.
+    #
+    # None of this matters on the client-side, only within the Sidekiq process itself.
     config.after_initialize do
-      # This hook happens after all initializers are run, just before returning
-      # from config/environment.rb back to sidekiq/cli.rb.
-      # We have to add the reloader after initialize to see if cache_classes has
-      # been turned on.
-      #
-      # None of this matters on the client-side, only within the Sidekiq process itself.
-      #
       Sidekiq.configure_server do |_|
-        if ::Rails::VERSION::MAJOR >= 5
-          Sidekiq.options[:reloader] = Sidekiq::Rails::Reloader.new
-        end
+        Sidekiq.options[:reloader] = Sidekiq::Rails::Reloader.new
       end
     end
 
@@ -48,11 +48,5 @@ module Sidekiq
         "#<Sidekiq::Rails::Reloader @app=#{@app.class.name}>"
       end
     end
-  end if defined?(::Rails)
-end
-
-if defined?(::Rails) && ::Rails::VERSION::MAJOR < 4
-  $stderr.puts("**************************************************")
-  $stderr.puts("⛔️ WARNING: Sidekiq server is no longer supported by Rails 3.2 - please ensure your server/workers are updated")
-  $stderr.puts("**************************************************")
+  end
 end