activejob 5.0.7.2 → 5.1.0.beta1

data/lib/active_job/enqueuing.rb

@@ -1,7 +1,7 @@
-require 'active_job/arguments'
+require "active_job/arguments"
 
 module ActiveJob
-  # Provides behavior for enqueuing and retrying jobs.
+  # Provides behavior for enqueuing jobs.
   module Enqueuing
     extend ActiveSupport::Concern
 
@@ -18,37 +18,12 @@ module ActiveJob
         job_or_instantiate(*args).enqueue
       end
 
-      protected
-        def job_or_instantiate(*args)
+      private
+        def job_or_instantiate(*args) # :doc:
           args.first.is_a?(self) ? args.first : new(*args)
         end
     end
 
-    # Reschedules the job to be re-executed. This is useful in combination
-    # with the +rescue_from+ option. When you rescue an exception from your job
-    # you can ask Active Job to retry performing your job.
-    #
-    # ==== Options
-    # * <tt>:wait</tt> - Enqueues the job with the specified delay
-    # * <tt>:wait_until</tt> - Enqueues the job at the time specified
-    # * <tt>:queue</tt> - Enqueues the job on the specified queue
-    # * <tt>:priority</tt> - Enqueues the job with the specified priority
-    #
-    # ==== Examples
-    #
-    #  class SiteScraperJob < ActiveJob::Base
-    #    rescue_from(ErrorLoadingSite) do
-    #      retry_job queue: :low_priority
-    #    end
-    #
-    #    def perform(*args)
-    #      # raise ErrorLoadingSite if cannot scrape
-    #    end
-    #  end
-    def retry_job(options={})
-      enqueue options
-    end
-
     # Enqueues the job to be performed by the queue adapter.
     #
     # ==== Options
@@ -64,14 +39,14 @@ module ActiveJob
     #    my_job_instance.enqueue queue: :important
     #    my_job_instance.enqueue wait_until: Date.tomorrow.midnight
     #    my_job_instance.enqueue priority: 10
-    def enqueue(options={})
+    def enqueue(options = {})
       self.scheduled_at = options[:wait].seconds.from_now.to_f if options[:wait]
       self.scheduled_at = options[:wait_until].to_f if options[:wait_until]
       self.queue_name   = self.class.queue_name_from_part(options[:queue]) if options[:queue]
       self.priority     = options[:priority].to_i if options[:priority]
       run_callbacks :enqueue do
-        if self.scheduled_at
-          self.class.queue_adapter.enqueue_at self, self.scheduled_at
+        if scheduled_at
+          self.class.queue_adapter.enqueue_at self, scheduled_at
         else
           self.class.queue_adapter.enqueue self
         end

data/lib/active_job/exceptions.rb

@@ -0,0 +1,122 @@
+require "active_support/core_ext/numeric/time"
+
+module ActiveJob
+  # Provides behavior for retrying and discarding jobs on exceptions.
+  module Exceptions
+    extend ActiveSupport::Concern
+
+    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
+      # bubble up to the underlying queuing system, which may have its own retry mechanism or place it in a
+      # holding queue for inspection.
+      #
+      # You can also pass a block that'll be invoked if the retry attempts fail for custom logic rather than letting
+      # the exception bubble up. This block is yielded with the job instance as the first and the error instance as the second parameter.
+      #
+      # ==== 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)
+      # * <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
+      #
+      # ==== Examples
+      #
+      #  class RemoteServiceJob < ActiveJob::Base
+      #    retry_on CustomAppException # defaults to 3s wait, 5 attempts
+      #    retry_on AnotherCustomAppException, wait: ->(executions) { executions * 2 }
+      #    retry_on(YetAnotherCustomAppException) do |job, exception|
+      #      ExceptionNotifier.caught(exception)
+      #    end
+      #    retry_on ActiveRecord::Deadlocked, wait: 5.seconds, attempts: 3
+      #    retry_on Net::OpenTimeout, wait: :exponentially_longer, attempts: 10
+      #
+      #    def perform(*args)
+      #      # Might raise CustomAppException, AnotherCustomAppException, or YetAnotherCustomAppException for something domain specific
+      #      # Might raise ActiveRecord::Deadlocked when a local db deadlock is detected
+      #      # Might raise Net::OpenTimeout when the remote service is down
+      #    end
+      #  end
+      def retry_on(exception, wait: 3.seconds, attempts: 5, queue: nil, priority: nil)
+        rescue_from exception do |error|
+          if executions < attempts
+            logger.error "Retrying #{self.class} in #{wait} seconds, due to a #{exception}. The original exception was #{error.cause.inspect}."
+            retry_job wait: determine_delay(wait), queue: queue, priority: priority
+          else
+            if block_given?
+              yield self, exception
+            else
+              logger.error "Stopped retrying #{self.class} due to a #{exception}, which reoccurred on #{executions} attempts. The original exception was #{error.cause.inspect}."
+              raise error
+            end
+          end
+        end
+      end
+
+      # Discard the job with no attempts to retry, if the exception is raised. This is useful when the subject of the job,
+      # like an Active Record, is no longer available, and the job is thus no longer relevant.
+      #
+      # ==== Example
+      #
+      #  class SearchIndexingJob < ActiveJob::Base
+      #    discard_on ActiveJob::DeserializationError
+      #
+      #    def perform(record)
+      #      # Will raise ActiveJob::DeserializationError if the record can't be deserialized
+      #    end
+      #  end
+      def discard_on(exception)
+        rescue_from exception do |error|
+          logger.error "Discarded #{self.class} due to a #{exception}. The original exception was #{error.cause.inspect}."
+        end
+      end
+    end
+
+    # Reschedules the job to be re-executed. This is useful in combination
+    # with the +rescue_from+ option. When you rescue an exception from your job
+    # you can ask Active Job to retry performing your job.
+    #
+    # ==== Options
+    # * <tt>:wait</tt> - Enqueues the job with the specified delay in seconds
+    # * <tt>:wait_until</tt> - Enqueues the job at the time specified
+    # * <tt>:queue</tt> - Enqueues the job on the specified queue
+    # * <tt>:priority</tt> - Enqueues the job with the specified priority
+    #
+    # ==== Examples
+    #
+    #  class SiteScraperJob < ActiveJob::Base
+    #    rescue_from(ErrorLoadingSite) do
+    #      retry_job queue: :low_priority
+    #    end
+    #
+    #    def perform(*args)
+    #      # raise ErrorLoadingSite if cannot scrape
+    #    end
+    #  end
+    def retry_job(options = {})
+      enqueue options
+    end
+
+    private
+      def determine_delay(seconds_or_duration_or_algorithm)
+        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
+        when Proc
+          algorithm = seconds_or_duration_or_algorithm
+          algorithm.call(executions)
+        else
+          raise "Couldn't determine a delay based on #{seconds_or_duration_or_algorithm.inspect}"
+        end
+      end
+  end
+end

data/lib/active_job/execution.rb

@@ -1,5 +1,5 @@
-require 'active_support/rescuable'
-require 'active_job/arguments'
+require "active_support/rescuable"
+require "active_job/arguments"
 
 module ActiveJob
   module Execution
@@ -31,6 +31,9 @@ module ActiveJob
     def perform_now
       deserialize_arguments_if_needed
       run_callbacks :perform do
+        # Guard against jobs that were persisted before we started counting executions by zeroing out nil counters
+        self.executions = (executions || 0) + 1
+
         perform(*arguments)
       end
     rescue => exception

data/lib/active_job/gem_version.rb

@@ -6,9 +6,9 @@ module ActiveJob
 
   module VERSION
     MAJOR = 5
-    MINOR = 0
-    TINY  = 7
-    PRE   = "2"
+    MINOR = 1
+    TINY  = 0
+    PRE   = "beta1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_job/logging.rb

@@ -1,7 +1,7 @@
-require 'active_support/core_ext/hash/transform_values'
-require 'active_support/core_ext/string/filters'
-require 'active_support/tagged_logging'
-require 'active_support/logger'
+require "active_support/core_ext/hash/transform_values"
+require "active_support/core_ext/string/filters"
+require "active_support/tagged_logging"
+require "active_support/logger"
 
 module ActiveJob
   module Logging #:nodoc:
@@ -18,7 +18,7 @@ module ActiveJob
 
       around_perform do |job, block, _|
         tag_logger(job.class.name, job.job_id) do
-          payload = {adapter: job.class.queue_adapter, job: job}
+          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
@@ -41,7 +41,7 @@ module ActiveJob
       def tag_logger(*tags)
         if logger.respond_to?(:tagged)
           tags.unshift "ActiveJob" unless logger_tagged_by_active_job?
-          logger.tagged(*tags){ yield }
+          logger.tagged(*tags) { yield }
         else
           yield
         end
@@ -51,70 +51,70 @@ module ActiveJob
         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)
+      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
-      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)
+        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
-      end
 
-      def perform_start(event)
-        info do
-          job = event.payload[:job]
-          "Performing #{job.class.name} from #{queue_name(event)}" + args_info(job)
+        def perform_start(event)
+          info do
+            job = event.payload[:job]
+            "Performing #{job.class.name} from #{queue_name(event)}" + args_info(job)
+          end
         end
-      end
 
-      def perform(event)
-        info do
-          job = event.payload[:job]
-          "Performed #{job.class.name} from #{queue_name(event)} in #{event.duration.round(2)}ms"
+        def perform(event)
+          info do
+            job = event.payload[:job]
+            "Performed #{job.class.name} from #{queue_name(event)} in #{event.duration.round(2)}ms"
+          end
         end
-      end
 
-      private
-        def queue_name(event)
-          event.payload[:adapter].class.name.demodulize.remove('Adapter') + "(#{event.payload[:job].queue_name})"
-        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
-            ''
+          def args_info(job)
+            if job.arguments.any?
+              " with arguments: " +
+                job.arguments.map { |arg| format(arg).inspect }.join(", ")
+            else
+              ""
+            end
           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
+          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
-        end
 
-        def scheduled_at(event)
-          Time.at(event.payload[:job].scheduled_at).utc
-        end
+          def scheduled_at(event)
+            Time.at(event.payload[:job].scheduled_at).utc
+          end
 
-        def logger
-          ActiveJob::Base.logger
-        end
-    end
+          def logger
+            ActiveJob::Base.logger
+          end
+      end
   end
 end
 

data/lib/active_job/queue_adapter.rb

@@ -1,6 +1,4 @@
-require 'active_job/queue_adapters/inline_adapter'
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/string/inflections'
+require "active_support/core_ext/string/inflections"
 
 module ActiveJob
   # The <tt>ActiveJob::QueueAdapter</tt> module is used to load the
@@ -30,34 +28,24 @@ module ActiveJob
 
       private
 
-      def interpret_adapter(name_or_adapter_or_class)
-        case name_or_adapter_or_class
-        when Symbol, String
-          ActiveJob::QueueAdapters.lookup(name_or_adapter_or_class).new
-        else
-          if queue_adapter?(name_or_adapter_or_class)
-            name_or_adapter_or_class
-          elsif queue_adapter_class?(name_or_adapter_or_class)
-            ActiveSupport::Deprecation.warn "Passing an adapter class is deprecated " \
-              "and will be removed in Rails 5.1. Please pass an adapter name " \
-              "(.queue_adapter = :#{name_or_adapter_or_class.name.demodulize.remove('Adapter').underscore}) " \
-              "or an instance (.queue_adapter = #{name_or_adapter_or_class.name}.new) instead."
-              name_or_adapter_or_class.new
+        def interpret_adapter(name_or_adapter_or_class)
+          case name_or_adapter_or_class
+          when Symbol, String
+            ActiveJob::QueueAdapters.lookup(name_or_adapter_or_class).new
           else
-            raise ArgumentError
+            if queue_adapter?(name_or_adapter_or_class)
+              name_or_adapter_or_class
+            else
+              raise ArgumentError
+            end
           end
         end
-      end
-
-      QUEUE_ADAPTER_METHODS = [:enqueue, :enqueue_at].freeze
 
-      def queue_adapter?(object)
-        QUEUE_ADAPTER_METHODS.all? { |meth| object.respond_to?(meth) }
-      end
+        QUEUE_ADAPTER_METHODS = [:enqueue, :enqueue_at].freeze
 
-      def queue_adapter_class?(object)
-        object.is_a?(Class) && QUEUE_ADAPTER_METHODS.all? { |meth| object.public_method_defined?(meth) }
-      end
+        def queue_adapter?(object)
+          QUEUE_ADAPTER_METHODS.all? { |meth| object.respond_to?(meth) }
+        end
     end
   end
 end

data/lib/active_job/queue_adapters.rb

@@ -8,7 +8,7 @@ module ActiveJob
   # * {Qu}[https://github.com/bkeepers/qu]
   # * {Que}[https://github.com/chanks/que]
   # * {queue_classic}[https://github.com/QueueClassic/queue_classic]
-  # * {Resque 1.x}[https://github.com/resque/resque/tree/1-x-stable]
+  # * {Resque}[https://github.com/resque/resque]
   # * {Sidekiq}[http://sidekiq.org]
   # * {Sneakers}[https://github.com/jondot/sneakers]
   # * {Sucker Punch}[https://github.com/brandonhilkert/sucker_punch]
@@ -121,7 +121,7 @@ module ActiveJob
     autoload :SuckerPunchAdapter
     autoload :TestAdapter
 
-    ADAPTER = 'Adapter'.freeze
+    ADAPTER = "Adapter".freeze
     private_constant :ADAPTER
 
     class << self

data/lib/active_job/queue_adapters/async_adapter.rb

@@ -1,7 +1,7 @@
-require 'securerandom'
-require 'concurrent/scheduled_task'
-require 'concurrent/executor/thread_pool_executor'
-require 'concurrent/utility/processor_counter'
+require "securerandom"
+require "concurrent/scheduled_task"
+require "concurrent/executor/thread_pool_executor"
+require "concurrent/utility/processor_counter"
 
 module ActiveJob
   module QueueAdapters