sidekiq 5.2.7 → 6.0.0

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

data/lib/sidekiq/job_retry.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
-require 'sidekiq/scheduled'
-require 'sidekiq/api'
+
+require "sidekiq/scheduled"
+require "sidekiq/api"
 
 module Sidekiq
   ##
@@ -81,22 +82,19 @@ module Sidekiq
       # ignore, will be pushed back onto queue during hard_shutdown
       raise Sidekiq::Shutdown if exception_caused_by_shutdown?(e)
 
-      if msg['retry']
+      if msg["retry"]
         attempt_retry(nil, msg, queue, e)
       else
         Sidekiq.death_handlers.each do |handler|
-          begin
-            handler.call(msg, e)
-          rescue => handler_ex
-            handle_exception(handler_ex, { context: "Error calling death handler", job: msg })
-          end
+          handler.call(msg, e)
+        rescue => handler_ex
+          handle_exception(handler_ex, {context: "Error calling death handler", job: msg})
         end
       end
 
       raise Handled
     end
 
-
     # The local retry support means that any errors that occur within
     # this block can be associated with the given worker instance.
     # This is required to support the `sidekiq_retries_exhausted` block.
@@ -116,11 +114,11 @@ module Sidekiq
       # ignore, will be pushed back onto queue during hard_shutdown
       raise Sidekiq::Shutdown if exception_caused_by_shutdown?(e)
 
-      if msg['retry'] == nil
-        msg['retry'] = worker.class.get_sidekiq_options['retry']
+      if msg["retry"].nil?
+        msg["retry"] = worker.class.get_sidekiq_options["retry"]
       end
 
-      raise e unless msg['retry']
+      raise e unless msg["retry"]
       attempt_retry(worker, msg, queue, e)
       # We've handled this error associated with this job, don't
       # need to handle it at the global level
@@ -133,13 +131,9 @@ module Sidekiq
     # instantiate the worker instance.  All access must be guarded and
     # best effort.
     def attempt_retry(worker, msg, queue, exception)
-      max_retry_attempts = retry_attempts_from(msg['retry'], @max_retries)
+      max_retry_attempts = retry_attempts_from(msg["retry"], @max_retries)
 
-      msg['queue'] = if msg['retry_queue']
-        msg['retry_queue']
-      else
-        queue
-      end
+      msg["queue"] = (msg["retry_queue"] || queue)
 
       m = exception_message(exception)
       if m.respond_to?(:scrub!)
@@ -147,32 +141,32 @@ module Sidekiq
         m.scrub!
       end
 
-      msg['error_message'] = m
-      msg['error_class'] = exception.class.name
-      count = if msg['retry_count']
-        msg['retried_at'] = Time.now.to_f
-        msg['retry_count'] += 1
+      msg["error_message"] = m
+      msg["error_class"] = exception.class.name
+      count = if msg["retry_count"]
+        msg["retried_at"] = Time.now.to_f
+        msg["retry_count"] += 1
       else
-        msg['failed_at'] = Time.now.to_f
-        msg['retry_count'] = 0
+        msg["failed_at"] = Time.now.to_f
+        msg["retry_count"] = 0
       end
 
-      if msg['backtrace'] == true
-        msg['error_backtrace'] = exception.backtrace
-      elsif !msg['backtrace']
+      if msg["backtrace"] == true
+        msg["error_backtrace"] = exception.backtrace
+      elsif !msg["backtrace"]
         # do nothing
-      elsif msg['backtrace'].to_i != 0
-        msg['error_backtrace'] = exception.backtrace[0...msg['backtrace'].to_i]
+      elsif msg["backtrace"].to_i != 0
+        msg["error_backtrace"] = exception.backtrace[0...msg["backtrace"].to_i]
       end
 
       if count < max_retry_attempts
         delay = delay_for(worker, count, exception)
         # Logging here can break retries if the logging device raises ENOSPC #3979
-        #logger.debug { "Failure! Retry #{count} in #{delay} seconds" }
+        # logger.debug { "Failure! Retry #{count} in #{delay} seconds" }
         retry_at = Time.now.to_f + delay
         payload = Sidekiq.dump_json(msg)
         Sidekiq.redis do |conn|
-          conn.zadd('retry', retry_at.to_s, payload)
+          conn.zadd("retry", retry_at.to_s, payload)
         end
       else
         # Goodbye dear message, you (re)tried your best I'm sure.
@@ -182,25 +176,23 @@ module Sidekiq
 
     def retries_exhausted(worker, msg, exception)
       begin
-        block = worker && worker.sidekiq_retries_exhausted_block
-        block.call(msg, exception) if block
+        block = worker&.sidekiq_retries_exhausted_block
+        block&.call(msg, exception)
       rescue => e
-        handle_exception(e, { context: "Error calling retries_exhausted", job: msg })
+        handle_exception(e, {context: "Error calling retries_exhausted", job: msg})
       end
 
       Sidekiq.death_handlers.each do |handler|
-        begin
-          handler.call(msg, exception)
-        rescue => e
-          handle_exception(e, { context: "Error calling death handler", job: msg })
-        end
+        handler.call(msg, exception)
+      rescue => e
+        handle_exception(e, {context: "Error calling death handler", job: msg})
       end
 
-      send_to_morgue(msg) unless msg['dead'] == false
+      send_to_morgue(msg) unless msg["dead"] == false
     end
 
     def send_to_morgue(msg)
-      logger.info { "Adding dead #{msg['class']} job #{msg['jid']}" }
+      logger.info { "Adding dead #{msg["class"]} job #{msg["jid"]}" }
       payload = Sidekiq.dump_json(msg)
       DeadSet.new.kill(payload, notify_failure: false)
     end
@@ -214,7 +206,7 @@ module Sidekiq
     end
 
     def delay_for(worker, count, exception)
-      if worker && worker.sidekiq_retry_in_block
+      if worker&.sidekiq_retry_in_block
         custom_retry_in = retry_in(worker, count, exception).to_i
         return custom_retry_in if custom_retry_in > 0
       end
@@ -223,16 +215,14 @@ module Sidekiq
 
     # delayed_job uses the same basic formula
     def seconds_to_delay(count)
-      (count ** 4) + 15 + (rand(30)*(count+1))
+      (count**4) + 15 + (rand(30) * (count + 1))
     end
 
     def retry_in(worker, count, exception)
-      begin
-        worker.sidekiq_retry_in_block.call(count, exception)
-      rescue Exception => e
-        handle_exception(e, { context: "Failure scheduling retry using the defined `sidekiq_retry_in` in #{worker.class.name}, falling back to default" })
-        nil
-      end
+      worker.sidekiq_retry_in_block.call(count, exception)
+    rescue Exception => e
+      handle_exception(e, {context: "Failure scheduling retry using the defined `sidekiq_retry_in` in #{worker.class.name}, falling back to default"})
+      nil
     end
 
     def exception_caused_by_shutdown?(e, checked_causes = [])
@@ -249,14 +239,11 @@ module Sidekiq
     # Extract message from exception.
     # Set a default if the message raises an error
     def exception_message(exception)
-      begin
-        # App code can stuff all sorts of crazy binary data into the error message
-        # that won't convert to JSON.
-        exception.message.to_s[0, 10_000]
-      rescue
-        "!!! ERROR MESSAGE THREW AN ERROR !!!".dup
-      end
+      # App code can stuff all sorts of crazy binary data into the error message
+      # that won't convert to JSON.
+      exception.message.to_s[0, 10_000]
+    rescue
+      +"!!! ERROR MESSAGE THREW AN ERROR !!!"
     end
-
   end
 end