activejob 6.0.3.3 → 6.1.1

data/lib/active_job/enqueuing.rb

@@ -54,9 +54,9 @@ module ActiveJob
 
       run_callbacks :enqueue do
         if scheduled_at
-          self.class.queue_adapter.enqueue_at self, scheduled_at
+          queue_adapter.enqueue_at self, scheduled_at
         else
-          self.class.queue_adapter.enqueue self
+          queue_adapter.enqueue self
         end
 
         successfully_enqueued = true
@@ -65,17 +65,7 @@ module ActiveJob
       if successfully_enqueued
         self
       else
-        if self.class.return_false_on_aborted_enqueue
-          false
-        else
-          ActiveSupport::Deprecation.warn(
-            "Rails 6.1 will return false when the enqueuing is aborted. Make sure your code doesn't depend on it" \
-            " returning the instance of the job and set `config.active_job.return_false_on_aborted_enqueue = true`" \
-            " to remove the deprecations."
-          )
-
-          self
-        end
+        false
       end
     end
   end

data/lib/active_job/exceptions.rb

@@ -7,6 +7,10 @@ module ActiveJob
   module Exceptions
     extend ActiveSupport::Concern
 
+    included do
+      class_attribute :retry_jitter, instance_accessor: false, instance_predicate: false, default: 0.0
+    end
+
     module ClassMethods
       # Catch the exception and reschedule job for re-execution after so many seconds, for a specific number of attempts.
       # If the exception keeps getting raised beyond the specified number of attempts, the exception is allowed to
@@ -18,23 +22,25 @@ module ActiveJob
       #
       # ==== Options
       # * <tt>:wait</tt> - Re-enqueues the job with a delay specified either in seconds (default: 3 seconds),
-      #   as a computing proc that the number of executions so far as an argument, or as a symbol reference of
-      #   <tt>:exponentially_longer</tt>, which applies the wait algorithm of <tt>(executions ** 4) + 2</tt>
-      #   (first wait 3s, then 18s, then 83s, etc)
+      #   as a computing proc that takes the number of executions so far as an argument, or as a symbol reference of
+      #   <tt>:exponentially_longer</tt>, which applies the wait algorithm of <tt>((executions**4) + (Kernel.rand * (executions**4) * jitter)) + 2</tt>
+      #   (first wait ~3s, then ~18s, then ~83s, etc)
       # * <tt>:attempts</tt> - Re-enqueues the job the specified number of times (default: 5 attempts)
       # * <tt>:queue</tt> - Re-enqueues the job on a different queue
       # * <tt>:priority</tt> - Re-enqueues the job with a different priority
+      # * <tt>:jitter</tt> - A random delay of wait time used when calculating backoff. The default is 15% (0.15) which represents the upper bound of possible wait time (expressed as a percentage)
       #
       # ==== Examples
       #
       #  class RemoteServiceJob < ActiveJob::Base
-      #    retry_on CustomAppException # defaults to 3s wait, 5 attempts
+      #    retry_on CustomAppException # defaults to ~3s wait, 5 attempts
       #    retry_on AnotherCustomAppException, wait: ->(executions) { executions * 2 }
       #
       #    retry_on ActiveRecord::Deadlocked, wait: 5.seconds, attempts: 3
       #    retry_on Net::OpenTimeout, Timeout::Error, wait: :exponentially_longer, attempts: 10 # retries at most 10 times for Net::OpenTimeout and Timeout::Error combined
       #    # To retry at most 10 times for each individual exception:
       #    # retry_on Net::OpenTimeout, wait: :exponentially_longer, attempts: 10
+      #    # retry_on Net::ReadTimeout, wait: 5.seconds, jitter: 0.30, attempts: 10
       #    # retry_on Timeout::Error, wait: :exponentially_longer, attempts: 10
       #
       #    retry_on(YetAnotherCustomAppException) do |job, error|
@@ -47,12 +53,11 @@ module ActiveJob
       #      # Might raise Net::OpenTimeout or Timeout::Error when the remote service is down
       #    end
       #  end
-      def retry_on(*exceptions, wait: 3.seconds, attempts: 5, queue: nil, priority: nil)
+      def retry_on(*exceptions, wait: 3.seconds, attempts: 5, queue: nil, priority: nil, jitter: JITTER_DEFAULT)
         rescue_from(*exceptions) do |error|
           executions = executions_for(exceptions)
-
           if executions < attempts
-            retry_job wait: determine_delay(seconds_or_duration_or_algorithm: wait, executions: executions), queue: queue, priority: priority, error: error
+            retry_job wait: determine_delay(seconds_or_duration_or_algorithm: wait, executions: executions, jitter: jitter), queue: queue, priority: priority, error: error
           else
             if block_given?
               instrument :retry_stopped, error: error do
@@ -115,22 +120,27 @@ module ActiveJob
     #    end
     #  end
     def retry_job(options = {})
-      instrument :enqueue_retry, **options.slice(:error, :wait) do
+      instrument :enqueue_retry, options.slice(:error, :wait) do
         enqueue options
       end
     end
 
     private
-      def determine_delay(seconds_or_duration_or_algorithm:, executions:)
+      JITTER_DEFAULT = Object.new
+      private_constant :JITTER_DEFAULT
+
+      def determine_delay(seconds_or_duration_or_algorithm:, executions:, jitter: JITTER_DEFAULT)
+        jitter = jitter == JITTER_DEFAULT ? self.class.retry_jitter : (jitter || 0.0)
+
         case seconds_or_duration_or_algorithm
         when :exponentially_longer
-          (executions**4) + 2
-        when ActiveSupport::Duration
-          duration = seconds_or_duration_or_algorithm
-          duration.to_i
-        when Integer
-          seconds = seconds_or_duration_or_algorithm
-          seconds
+          delay = executions**4
+          delay_jitter = determine_jitter_for_delay(delay, jitter)
+          delay + delay_jitter + 2
+        when ActiveSupport::Duration, Integer
+          delay = seconds_or_duration_or_algorithm.to_i
+          delay_jitter = determine_jitter_for_delay(delay, jitter)
+          delay + delay_jitter
         when Proc
           algorithm = seconds_or_duration_or_algorithm
           algorithm.call(executions)
@@ -139,10 +149,9 @@ module ActiveJob
         end
       end
 
-      def instrument(name, error: nil, wait: nil, &block)
-        payload = { job: self, adapter: self.class.queue_adapter, error: error, wait: wait }
-
-        ActiveSupport::Notifications.instrument("#{name}.active_job", payload, &block)
+      def determine_jitter_for_delay(delay, jitter)
+        return 0.0 if jitter.zero?
+        Kernel.rand * delay * jitter
       end
 
       def executions_for(exceptions)

data/lib/active_job/execution.rb

@@ -29,13 +29,21 @@ module ActiveJob
 
     # Performs the job immediately. The job is not sent to the queuing adapter
     # but directly executed by blocking the execution of others until it's finished.
+    # `perform_now` returns the value of your job's `perform` method.
     #
-    #   MyJob.new(*args).perform_now
+    #   class MyJob < ActiveJob::Base
+    #     def perform
+    #       "Hello World!"
+    #     end
+    #   end
+    #
+    #   puts MyJob.new(*args).perform_now # => "Hello World!"
     def perform_now
       # Guard against jobs that were persisted before we started counting executions by zeroing out nil counters
       self.executions = (executions || 0) + 1
 
       deserialize_arguments_if_needed
+
       run_callbacks :perform do
         perform(*arguments)
       end

data/lib/active_job/gem_version.rb

@@ -8,9 +8,9 @@ module ActiveJob
 
   module VERSION
     MAJOR = 6
-    MINOR = 0
-    TINY  = 3
-    PRE   = "3"
+    MINOR = 1
+    TINY  = 1
+    PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_job/instrumentation.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Instrumentation #:nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      around_enqueue do |_, block|
+        scheduled_at ? instrument(:enqueue_at, &block) : instrument(:enqueue, &block)
+      end
+
+      around_perform do |_, block|
+        instrument :perform_start
+        instrument :perform, &block
+      end
+    end
+
+    private
+      def instrument(operation, payload = {}, &block)
+        enhanced_block = ->(event_payload) do
+          value = block.call if block
+
+          if defined?(@_halted_callback_hook_called) && @_halted_callback_hook_called
+            event_payload[:aborted] = true
+            @_halted_callback_hook_called = nil
+          end
+
+          value
+        end
+
+        ActiveSupport::Notifications.instrument \
+          "#{operation}.active_job", payload.merge(adapter: queue_adapter, job: self), &enhanced_block
+      end
+
+      def halted_callback_hook(*)
+        super
+        @_halted_callback_hook_called = true
+      end
+  end
+end

data/lib/active_job/log_subscriber.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/filters"
+require "active_support/log_subscriber"
+
+module ActiveJob
+  class LogSubscriber < ActiveSupport::LogSubscriber #:nodoc:
+    def enqueue(event)
+      job = event.payload[:job]
+      ex = event.payload[:exception_object]
+
+      if ex
+        error do
+          "Failed enqueuing #{job.class.name} to #{queue_name(event)}: #{ex.class} (#{ex.message})"
+        end
+      elsif event.payload[:aborted]
+        info do
+          "Failed enqueuing #{job.class.name} to #{queue_name(event)}, a before_enqueue callback halted the enqueuing execution."
+        end
+      else
+        info do
+          "Enqueued #{job.class.name} (Job ID: #{job.job_id}) to #{queue_name(event)}" + args_info(job)
+        end
+      end
+    end
+
+    def enqueue_at(event)
+      job = event.payload[:job]
+      ex = event.payload[:exception_object]
+
+      if ex
+        error do
+          "Failed enqueuing #{job.class.name} to #{queue_name(event)}: #{ex.class} (#{ex.message})"
+        end
+      elsif event.payload[:aborted]
+        info do
+          "Failed enqueuing #{job.class.name} to #{queue_name(event)}, a before_enqueue callback halted the enqueuing execution."
+        end
+      else
+        info do
+          "Enqueued #{job.class.name} (Job ID: #{job.job_id}) to #{queue_name(event)} at #{scheduled_at(event)}" + args_info(job)
+        end
+      end
+    end
+
+    def perform_start(event)
+      info do
+        job = event.payload[:job]
+        "Performing #{job.class.name} (Job ID: #{job.job_id}) from #{queue_name(event)} enqueued at #{job.enqueued_at}" + args_info(job)
+      end
+    end
+
+    def perform(event)
+      job = event.payload[:job]
+      ex = event.payload[:exception_object]
+      if ex
+        error do
+          "Error performing #{job.class.name} (Job ID: #{job.job_id}) from #{queue_name(event)} in #{event.duration.round(2)}ms: #{ex.class} (#{ex.message}):\n" + Array(ex.backtrace).join("\n")
+        end
+      elsif event.payload[:aborted]
+        error do
+          "Error performing #{job.class.name} (Job ID: #{job.job_id}) from #{queue_name(event)} in #{event.duration.round(2)}ms: a before_perform callback halted the job execution"
+        end
+      else
+        info do
+          "Performed #{job.class.name} (Job ID: #{job.job_id}) from #{queue_name(event)} in #{event.duration.round(2)}ms"
+        end
+      end
+    end
+
+    def enqueue_retry(event)
+      job = event.payload[:job]
+      ex = event.payload[:error]
+      wait = event.payload[:wait]
+
+      info do
+        if ex
+          "Retrying #{job.class} in #{wait.to_i} seconds, due to a #{ex.class}."
+        else
+          "Retrying #{job.class} in #{wait.to_i} seconds."
+        end
+      end
+    end
+
+    def retry_stopped(event)
+      job = event.payload[:job]
+      ex = event.payload[:error]
+
+      error do
+        "Stopped retrying #{job.class} due to a #{ex.class}, which reoccurred on #{job.executions} attempts."
+      end
+    end
+
+    def discard(event)
+      job = event.payload[:job]
+      ex = event.payload[:error]
+
+      error do
+        "Discarded #{job.class} due to a #{ex.class}."
+      end
+    end
+
+    private
+      def queue_name(event)
+        event.payload[:adapter].class.name.demodulize.remove("Adapter") + "(#{event.payload[:job].queue_name})"
+      end
+
+      def args_info(job)
+        if job.class.log_arguments? && job.arguments.any?
+          " with arguments: " +
+            job.arguments.map { |arg| format(arg).inspect }.join(", ")
+        else
+          ""
+        end
+      end
+
+      def format(arg)
+        case arg
+        when Hash
+          arg.transform_values { |value| format(value) }
+        when Array
+          arg.map { |value| format(value) }
+        when GlobalID::Identification
+          arg.to_global_id rescue arg
+        else
+          arg
+        end
+      end
+
+      def scheduled_at(event)
+        Time.at(event.payload[:job].scheduled_at).utc
+      end
+
+      def logger
+        ActiveJob::Base.logger
+      end
+  end
+end
+
+ActiveJob::LogSubscriber.attach_to :active_job

data/lib/active_job/logging.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/string/filters"
 require "active_support/tagged_logging"
 require "active_support/logger"
 
@@ -10,32 +9,10 @@ module ActiveJob
 
     included do
       cattr_accessor :logger, default: ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT))
+      class_attribute :log_arguments, instance_accessor: false, default: true
 
-      around_enqueue do |_, block|
-        tag_logger do
-          block.call
-        end
-      end
-
-      around_perform do |job, block|
-        tag_logger(job.class.name, job.job_id) do
-          payload = { adapter: job.class.queue_adapter, job: job }
-          ActiveSupport::Notifications.instrument("perform_start.active_job", payload.dup)
-          ActiveSupport::Notifications.instrument("perform.active_job", payload) do
-            block.call
-          end
-        end
-      end
-
-      around_enqueue do |job, block|
-        if job.scheduled_at
-          ActiveSupport::Notifications.instrument("enqueue_at.active_job",
-            adapter: job.class.queue_adapter, job: job, &block)
-        else
-          ActiveSupport::Notifications.instrument("enqueue.active_job",
-            adapter: job.class.queue_adapter, job: job, &block)
-        end
-      end
+      around_enqueue { |_, block| tag_logger(&block) }
+      around_perform { |job, block| tag_logger(job.class.name, job.job_id, &block) }
     end
 
     private
@@ -51,111 +28,5 @@ module ActiveJob
       def logger_tagged_by_active_job?
         logger.formatter.current_tags.include?("ActiveJob")
       end
-
-      class LogSubscriber < ActiveSupport::LogSubscriber #:nodoc:
-        def enqueue(event)
-          info do
-            job = event.payload[:job]
-            "Enqueued #{job.class.name} (Job ID: #{job.job_id}) to #{queue_name(event)}" + args_info(job)
-          end
-        end
-
-        def enqueue_at(event)
-          info do
-            job = event.payload[:job]
-            "Enqueued #{job.class.name} (Job ID: #{job.job_id}) to #{queue_name(event)} at #{scheduled_at(event)}" + args_info(job)
-          end
-        end
-
-        def perform_start(event)
-          info do
-            job = event.payload[:job]
-            "Performing #{job.class.name} (Job ID: #{job.job_id}) from #{queue_name(event)} enqueued at #{job.enqueued_at}" + args_info(job)
-          end
-        end
-
-        def perform(event)
-          job = event.payload[:job]
-          ex = event.payload[:exception_object]
-          if ex
-            error do
-              "Error performing #{job.class.name} (Job ID: #{job.job_id}) from #{queue_name(event)} in #{event.duration.round(2)}ms: #{ex.class} (#{ex.message}):\n" + Array(ex.backtrace).join("\n")
-            end
-          else
-            info do
-              "Performed #{job.class.name} (Job ID: #{job.job_id}) from #{queue_name(event)} in #{event.duration.round(2)}ms"
-            end
-          end
-        end
-
-        def enqueue_retry(event)
-          job = event.payload[:job]
-          ex = event.payload[:error]
-          wait = event.payload[:wait]
-
-          info do
-            if ex
-              "Retrying #{job.class} in #{wait.to_i} seconds, due to a #{ex.class}."
-            else
-              "Retrying #{job.class} in #{wait.to_i} seconds."
-            end
-          end
-        end
-
-        def retry_stopped(event)
-          job = event.payload[:job]
-          ex = event.payload[:error]
-
-          error do
-            "Stopped retrying #{job.class} due to a #{ex.class}, which reoccurred on #{job.executions} attempts."
-          end
-        end
-
-        def discard(event)
-          job = event.payload[:job]
-          ex = event.payload[:error]
-
-          error do
-            "Discarded #{job.class} due to a #{ex.class}."
-          end
-        end
-
-        private
-          def queue_name(event)
-            event.payload[:adapter].class.name.demodulize.remove("Adapter") + "(#{event.payload[:job].queue_name})"
-          end
-
-          def args_info(job)
-            if job.arguments.any?
-              " with arguments: " +
-                job.arguments.map { |arg| format(arg).inspect }.join(", ")
-            else
-              ""
-            end
-          end
-
-          def format(arg)
-            case arg
-            when Hash
-              arg.transform_values { |value| format(value) }
-            when Array
-              arg.map { |value| format(value) }
-            when GlobalID::Identification
-              arg.to_global_id rescue arg
-            else
-              arg
-            end
-          end
-
-          def scheduled_at(event)
-            Time.at(event.payload[:job].scheduled_at).utc
-          end
-
-          def logger
-            ActiveJob::Base.logger
-          end
-      end
   end
 end
-
-ActiveJob::Logging::LogSubscriber.attach_to :active_job