sidekiq 5.2.10 → 6.0.0.pre1

data/lib/sidekiq/ctl.rb

@@ -1,109 +1,36 @@
 #!/usr/bin/env ruby
 
-require 'fileutils'
-require 'sidekiq/api'
+require "fileutils"
+require "sidekiq/api"
 
 class Sidekiq::Ctl
-  DEFAULT_KILL_TIMEOUT = 10
-  CMD = File.basename($0)
+  CMD = File.basename($PROGRAM_NAME)
 
-  attr_reader :stage, :pidfile, :kill_timeout
+  attr_reader :stage
 
   def self.print_usage
     puts "#{CMD} - control Sidekiq from the command line."
     puts
-    puts "Usage: #{CMD} quiet <pidfile> <kill_timeout>"
-    puts "       #{CMD} stop <pidfile> <kill_timeout>"
-    puts "       #{CMD} status <section>"
-    puts
-    puts "       <pidfile> is path to a pidfile"
-    puts "       <kill_timeout> is number of seconds to wait until Sidekiq exits"
-    puts "       (default: #{Sidekiq::Ctl::DEFAULT_KILL_TIMEOUT}), after which Sidekiq will be KILL'd"
+    puts "Usage: #{CMD} status <section>"
     puts
     puts "       <section> (optional) view a specific section of the status output"
-    puts "       Valid sections are: #{Sidekiq::Ctl::Status::VALID_SECTIONS.join(', ')}"
-    puts
-    puts "Be sure to set the kill_timeout LONGER than Sidekiq's -t timeout.  If you want"
-    puts "to wait 60 seconds for jobs to finish, use `sidekiq -t 60` and `sidekiqctl stop"
-    puts " path_to_pidfile 61`"
+    puts "       Valid sections are: #{Sidekiq::Ctl::Status::VALID_SECTIONS.join(", ")}"
     puts
   end
 
-  def initialize(stage, pidfile, timeout)
-    @stage = stage
-    @pidfile = pidfile
-    @kill_timeout = timeout
-
-    done('No pidfile given', :error) if !pidfile
-    done("Pidfile #{pidfile} does not exist", :warn) if !File.exist?(pidfile)
-    done('Invalid pidfile content', :error) if pid == 0
-
-    fetch_process
-
-    begin
-      send(stage)
-    rescue NoMethodError
-      done "Invalid command: #{stage}", :error
-    end
-  end
-
-  def fetch_process
-    Process.kill(0, pid)
-  rescue Errno::ESRCH
-    done "Process doesn't exist", :error
-  # We were not allowed to send a signal, but the process must have existed
-  # when Process.kill() was called.
-  rescue Errno::EPERM
-    return pid
-  end
-
-  def done(msg, error = nil)
-    puts msg
-    exit(exit_signal(error))
-  end
-
-  def exit_signal(error)
-    (error == :error) ? 1 : 0
-  end
-
-  def pid
-    @pid ||= File.read(pidfile).to_i
-  end
-
-  def quiet
-    `kill -TSTP #{pid}`
-  end
-
-  def stop
-    `kill -TERM #{pid}`
-    kill_timeout.times do
-      begin
-        Process.kill(0, pid)
-      rescue Errno::ESRCH
-        FileUtils.rm_f pidfile
-        done 'Sidekiq shut down gracefully.'
-      rescue Errno::EPERM
-        done 'Not permitted to shut down Sidekiq.'
-      end
-      sleep 1
-    end
-    `kill -9 #{pid}`
-    FileUtils.rm_f pidfile
-    done 'Sidekiq shut down forcefully.'
-  end
-  alias_method :shutdown, :stop
-
   class Status
     VALID_SECTIONS = %w[all version overview processes queues]
+    COL_PAD = 2
+
     def display(section = nil)
-      section ||= 'all'
+      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(', ')}"
+        puts "Try one of these: #{VALID_SECTIONS.join(", ")}"
         return
       end
       send(section)
-    rescue StandardError => e
+    rescue => e
       puts "Couldn't get status: #{e}"
     end
 
@@ -123,7 +50,7 @@ class Sidekiq::Ctl
     end
 
     def overview
-      puts '---- Overview ----'
+      puts "---- Overview ----"
       puts "  Processed: #{delimit stats.processed}"
       puts "     Failed: #{delimit stats.failed}"
       puts "       Busy: #{delimit stats.workers_size}"
@@ -136,21 +63,20 @@ class Sidekiq::Ctl
     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
+        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
 
-    COL_PAD = 2
     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]
+        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
@@ -165,21 +91,21 @@ class Sidekiq::Ctl
     private
 
     def delimit(number)
-      number.to_s.reverse.scan(/.{1,3}/).join(',').reverse
+      number.to_s.reverse.scan(/.{1,3}/).join(",").reverse
     end
 
     def split_multiline(values, opts = {})
-      return 'none' unless values
+      return "none" unless values
       pad = opts[:pad] || 0
       max_length = opts[:max_length] || (80 - pad)
       out = []
-      line = ''
+      line = ""
       values.each do |value|
         if (line.length + value.length) > max_length
           out << line
-          line = ' ' * pad
+          line = " " * pad
         end
-        line << value + ', '
+        line << value + ", "
       end
       out << line[0..-3]
       out.join("\n")
@@ -187,27 +113,27 @@ class Sidekiq::Ctl
 
     def tags_for(process)
       tags = [
-        process['tag'],
-        process['labels'],
-        (process['quiet'] == 'true' ? 'quiet' : nil)
+        process["tag"],
+        process["labels"],
+        (process["quiet"] == "true" ? "quiet" : nil),
       ].flatten.compact
-      tags.any? ? "[#{tags.join('] [')}]" : nil
+      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 "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
+      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 do |q|
-        QUEUE_STRUCT.new(q.name, q.size.to_s, sprintf('%#.2f', q.latency))
-      end
+      @queue_data ||= Sidekiq::Queue.all.map { |q|
+        QUEUE_STRUCT.new(q.name, q.size.to_s, sprintf("%#.2f", q.latency))
+      }
     end
 
     def process_set

data/lib/sidekiq/delay.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
+
 module Sidekiq
   module Extensions
-
     def self.enable_delay!
       if defined?(::ActiveSupport)
-        require 'sidekiq/extensions/active_record'
-        require 'sidekiq/extensions/action_mailer'
+        require "sidekiq/extensions/active_record"
+        require "sidekiq/extensions/action_mailer"
 
         # Need to patch Psych so it can autoload classes whose names are serialized
         # in the delayed YAML.
@@ -19,7 +19,7 @@ module Sidekiq
         end
       end
 
-      require 'sidekiq/extensions/class_methods'
+      require "sidekiq/extensions/class_methods"
       Module.__send__(:include, Sidekiq::Extensions::Klass)
     end
 
@@ -27,7 +27,7 @@ module Sidekiq
       def resolve_class(klass_name)
         return nil if !klass_name || klass_name.empty?
         # constantize
-        names = klass_name.split('::')
+        names = klass_name.split("::")
         names.shift if names.empty? || names.first.empty?
 
         names.inject(Object) do |constant, name|
@@ -39,4 +39,3 @@ module Sidekiq
     end
   end
 end
-

data/lib/sidekiq/exception_handler.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
-require 'sidekiq'
+
+require "sidekiq"
 
 module Sidekiq
   module ExceptionHandler
-
     class Logger
-      def call(ex, ctxHash)
-        Sidekiq.logger.warn(Sidekiq.dump_json(ctxHash)) if !ctxHash.empty?
+      def call(ex, ctx)
+        Sidekiq.logger.warn(Sidekiq.dump_json(ctx)) unless ctx.empty?
         Sidekiq.logger.warn("#{ex.class.name}: #{ex.message}")
         Sidekiq.logger.warn(ex.backtrace.join("\n")) unless ex.backtrace.nil?
       end
@@ -14,15 +14,13 @@ module Sidekiq
       Sidekiq.error_handlers << Sidekiq::ExceptionHandler::Logger.new
     end
 
-    def handle_exception(ex, ctxHash={})
+    def handle_exception(ex, ctx = {})
       Sidekiq.error_handlers.each do |handler|
-        begin
-          handler.call(ex, ctxHash)
-        rescue => ex
-          Sidekiq.logger.error "!!! ERROR HANDLER THREW AN ERROR !!!"
-          Sidekiq.logger.error ex
-          Sidekiq.logger.error ex.backtrace.join("\n") unless ex.backtrace.nil?
-        end
+        handler.call(ex, ctx)
+      rescue => ex
+        Sidekiq.logger.error "!!! ERROR HANDLER THREW AN ERROR !!!"
+        Sidekiq.logger.error ex
+        Sidekiq.logger.error ex.backtrace.join("\n") unless ex.backtrace.nil?
       end
     end
   end

data/lib/sidekiq/extensions/action_mailer.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require 'sidekiq/extensions/generic_proxy'
+
+require "sidekiq/extensions/generic_proxy"
 
 module Sidekiq
   module Extensions
@@ -19,39 +20,28 @@ module Sidekiq
         # The email method can return nil, which causes ActionMailer to return
         # an undeliverable empty message.
         if msg
-          deliver(msg)
-        else
-          raise "#{target.name}##{method_name} returned an undeliverable mail object"
-        end
-      end
-
-      private
-
-      def deliver(msg)
-        if msg.respond_to?(:deliver_now)
-          # Rails 4.2/5.0
           msg.deliver_now
         else
-          # Rails 3.2/4.0/4.1
-          msg.deliver
+          raise "#{target.name}##{method_name} returned an undeliverable mail object"
         end
       end
     end
 
     module ActionMailer
-      def sidekiq_delay(options={})
+      def sidekiq_delay(options = {})
         Proxy.new(DelayedMailer, self, options)
       end
-      def sidekiq_delay_for(interval, options={})
-        Proxy.new(DelayedMailer, self, options.merge('at' => Time.now.to_f + interval.to_f))
+
+      def sidekiq_delay_for(interval, options = {})
+        Proxy.new(DelayedMailer, self, options.merge("at" => Time.now.to_f + interval.to_f))
       end
-      def sidekiq_delay_until(timestamp, options={})
-        Proxy.new(DelayedMailer, self, options.merge('at' => timestamp.to_f))
+
+      def sidekiq_delay_until(timestamp, options = {})
+        Proxy.new(DelayedMailer, self, options.merge("at" => timestamp.to_f))
       end
       alias_method :delay, :sidekiq_delay
       alias_method :delay_for, :sidekiq_delay_for
       alias_method :delay_until, :sidekiq_delay_until
     end
-
   end
 end

data/lib/sidekiq/extensions/active_record.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require 'sidekiq/extensions/generic_proxy'
+
+require "sidekiq/extensions/generic_proxy"
 
 module Sidekiq
   module Extensions
@@ -22,19 +23,20 @@ module Sidekiq
     end
 
     module ActiveRecord
-      def sidekiq_delay(options={})
+      def sidekiq_delay(options = {})
         Proxy.new(DelayedModel, self, options)
       end
-      def sidekiq_delay_for(interval, options={})
-        Proxy.new(DelayedModel, self, options.merge('at' => Time.now.to_f + interval.to_f))
+
+      def sidekiq_delay_for(interval, options = {})
+        Proxy.new(DelayedModel, self, options.merge("at" => Time.now.to_f + interval.to_f))
       end
-      def sidekiq_delay_until(timestamp, options={})
-        Proxy.new(DelayedModel, self, options.merge('at' => timestamp.to_f))
+
+      def sidekiq_delay_until(timestamp, options = {})
+        Proxy.new(DelayedModel, self, options.merge("at" => timestamp.to_f))
       end
       alias_method :delay, :sidekiq_delay
       alias_method :delay_for, :sidekiq_delay_for
       alias_method :delay_until, :sidekiq_delay_until
     end
-
   end
 end

data/lib/sidekiq/extensions/class_methods.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require 'sidekiq/extensions/generic_proxy'
+
+require "sidekiq/extensions/generic_proxy"
 
 module Sidekiq
   module Extensions
@@ -20,20 +21,21 @@ module Sidekiq
     end
 
     module Klass
-      def sidekiq_delay(options={})
+      def sidekiq_delay(options = {})
         Proxy.new(DelayedClass, self, options)
       end
-      def sidekiq_delay_for(interval, options={})
-        Proxy.new(DelayedClass, self, options.merge('at' => Time.now.to_f + interval.to_f))
+
+      def sidekiq_delay_for(interval, options = {})
+        Proxy.new(DelayedClass, self, options.merge("at" => Time.now.to_f + interval.to_f))
       end
-      def sidekiq_delay_until(timestamp, options={})
-        Proxy.new(DelayedClass, self, options.merge('at' => timestamp.to_f))
+
+      def sidekiq_delay_until(timestamp, options = {})
+        Proxy.new(DelayedClass, self, options.merge("at" => timestamp.to_f))
       end
       alias_method :delay, :sidekiq_delay
       alias_method :delay_for, :sidekiq_delay_for
       alias_method :delay_until, :sidekiq_delay_until
     end
-
   end
 end
 

data/lib/sidekiq/extensions/generic_proxy.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
-require 'yaml'
+
+require "yaml"
 
 module Sidekiq
   module Extensions
     SIZE_LIMIT = 8_192
 
     class Proxy < BasicObject
-      def initialize(performable, target, options={})
+      def initialize(performable, target, options = {})
         @performable = performable
         @target = target
         @opts = options
@@ -23,9 +24,8 @@ module Sidekiq
         if marshalled.size > SIZE_LIMIT
           ::Sidekiq.logger.warn { "#{@target}.#{name} job argument is #{marshalled.bytesize} bytes, you should refactor it to reduce the size" }
         end
-        @performable.client_push({ 'class' => @performable, 'args' => [marshalled] }.merge(@opts))
+        @performable.client_push({"class" => @performable, "args" => [marshalled]}.merge(@opts))
       end
     end
-
   end
 end

data/lib/sidekiq/fetch.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require 'sidekiq'
+
+require "sidekiq"
 
 module Sidekiq
   class BasicFetch
@@ -7,13 +8,13 @@ module Sidekiq
     # can check if the process is shutting down.
     TIMEOUT = 2
 
-    UnitOfWork = Struct.new(:queue, :job) do
+    UnitOfWork = Struct.new(:queue, :job) {
       def acknowledge
         # nothing to do
       end
 
       def queue_name
-        queue.sub(/.*queue:/, '')
+        queue.sub(/.*queue:/, "")
       end
 
       def requeue
@@ -21,7 +22,7 @@ module Sidekiq
           conn.rpush("queue:#{queue_name}", job)
         end
       end
-    end
+    }
 
     def initialize(options)
       @strictly_ordered_queues = !!options[:strict]
@@ -52,7 +53,6 @@ module Sidekiq
       end
     end
 
-
     # By leaving this as a class method, it can be pluggable and used by the Manager actor. Making it
     # an instance method will make it async to the Fetcher actor
     def self.bulk_requeue(inprogress, options)
@@ -76,6 +76,5 @@ module Sidekiq
     rescue => ex
       Sidekiq.logger.warn("Failed to requeue #{inprogress.size} jobs: #{ex.message}")
     end
-
   end
 end

data/lib/sidekiq/job_logger.rb

@@ -1,25 +1,55 @@
 # frozen_string_literal: true
+
 module Sidekiq
   class JobLogger
+    def initialize(logger = Sidekiq.logger)
+      @logger = logger
+    end
 
     def call(item, queue)
       start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-      logger.info("start")
+      @logger.info("start")
+
       yield
-      logger.info("done: #{elapsed(start)} sec")
+
+      with_elapsed_time_context(start) do
+        @logger.info("done")
+      end
     rescue Exception
-      logger.info("fail: #{elapsed(start)} sec")
+      with_elapsed_time_context(start) do
+        @logger.info("fail")
+      end
+
       raise
     end
 
+    def with_job_hash_context(job_hash, &block)
+      @logger.with_context(job_hash_context(job_hash), &block)
+    end
+
+    def job_hash_context(job_hash)
+      # If we're using a wrapper class, like ActiveJob, use the "wrapped"
+      # attribute to expose the underlying thing.
+      h = {
+        class: job_hash["wrapped"] || job_hash["class"],
+        jid: job_hash["jid"],
+      }
+      h[:bid] = job_hash["bid"] if job_hash["bid"]
+      h
+    end
+
+    def with_elapsed_time_context(start, &block)
+      @logger.with_context(elapsed_time_context(start), &block)
+    end
+
+    def elapsed_time_context(start)
+      {elapsed: elapsed(start).to_s}
+    end
+
     private
 
     def elapsed(start)
       (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start).round(3)
     end
-
-    def logger
-      Sidekiq.logger
-    end
   end
 end