activejob 5.2.8.1 → 6.0.0.beta1

data/lib/active_job/exceptions.rb

@@ -30,28 +30,38 @@ module ActiveJob
       #  class RemoteServiceJob < ActiveJob::Base
       #    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 Timeout::Error, wait: :exponentially_longer, attempts: 10
+      #
       #    retry_on(YetAnotherCustomAppException) do |job, error|
       #      ExceptionNotifier.caught(error)
       #    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
+      #      # Might raise Net::OpenTimeout or Timeout::Error 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
+      def retry_on(*exceptions, wait: 3.seconds, attempts: 5, queue: nil, priority: nil)
+        rescue_from(*exceptions) do |error|
+          # Guard against jobs that were persisted before we started having individual executions counters per retry_on
+          self.exception_executions ||= {}
+          self.exception_executions[exceptions.to_s] = (exception_executions[exceptions.to_s] || 0) + 1
+
+          if exception_executions[exceptions.to_s] < attempts
+            retry_job wait: determine_delay(wait), queue: queue, priority: priority, error: error
           else
             if block_given?
-              yield self, error
+              instrument :retry_stopped, error: error do
+                yield self, error
+              end
             else
-              logger.error "Stopped retrying #{self.class} due to a #{exception}, which reoccurred on #{executions} attempts. The original exception was #{error.cause.inspect}."
+              instrument :retry_stopped, error: error
               raise error
             end
           end
@@ -76,12 +86,10 @@ module ActiveJob
       #      # Might raise CustomAppException for something domain specific
       #    end
       #  end
-      def discard_on(exception)
-        rescue_from exception do |error|
-          if block_given?
-            yield self, error
-          else
-            logger.error "Discarded #{self.class} due to a #{exception}. The original exception was #{error.cause.inspect}."
+      def discard_on(*exceptions)
+        rescue_from(*exceptions) do |error|
+          instrument :discard, error: error do
+            yield self, error if block_given?
           end
         end
       end
@@ -109,7 +117,9 @@ module ActiveJob
     #    end
     #  end
     def retry_job(options = {})
-      enqueue options
+      instrument :enqueue_retry, options.slice(:error, :wait) do
+        enqueue options
+      end
     end
 
     private
@@ -130,5 +140,11 @@ module ActiveJob
           raise "Couldn't determine a delay based on #{seconds_or_duration_or_algorithm.inspect}"
         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)
+      end
   end
 end

data/lib/active_job/execution.rb

@@ -26,7 +26,7 @@ module ActiveJob
       end
     end
 
-    # Performs the job immediately. The job is not sent to the queueing adapter
+    # 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.
     #
     #   MyJob.new(*args).perform_now

data/lib/active_job/gem_version.rb

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

data/lib/active_job/logging.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/hash/transform_values"
 require "active_support/core_ext/string/filters"
 require "active_support/tagged_logging"
 require "active_support/logger"
@@ -12,13 +11,13 @@ module ActiveJob
     included do
       cattr_accessor :logger, default: ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT))
 
-      around_enqueue do |_, block, _|
+      around_enqueue do |_, block|
         tag_logger do
           block.call
         end
       end
 
-      around_perform do |job, block, _|
+      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)
@@ -28,13 +27,13 @@ module ActiveJob
         end
       end
 
-      after_enqueue do |job|
+      around_enqueue do |job, block|
         if job.scheduled_at
-          ActiveSupport::Notifications.instrument "enqueue_at.active_job",
-            adapter: job.class.queue_adapter, job: job
+          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
+          ActiveSupport::Notifications.instrument("enqueue.active_job",
+            adapter: job.class.queue_adapter, job: job, &block)
         end
       end
     end
@@ -89,6 +88,38 @@ module ActiveJob
           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})"

data/lib/active_job/queue_adapter.rb

@@ -22,6 +22,8 @@ module ActiveJob
         _queue_adapter
       end
 
+      # Returns string denoting the name of the configured queue adapter.
+      # By default returns +"async"+.
       def queue_adapter_name
         _queue_adapter_name
       end

data/lib/active_job/queue_adapters/async_adapter.rb

@@ -31,7 +31,7 @@ module ActiveJob
     # jobs. Since jobs share a single thread pool, long-running jobs will block
     # short-lived jobs. Fine for dev/test; bad for production.
     class AsyncAdapter
-      # See {Concurrent::ThreadPoolExecutor}[https://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ThreadPoolExecutor.html] for executor options.
+      # See {Concurrent::ThreadPoolExecutor}[https://ruby-concurrency.github.io/concurrent-ruby/master/Concurrent/ThreadPoolExecutor.html] for executor options.
       def initialize(**executor_options)
         @scheduler = Scheduler.new(**executor_options)
       end

data/lib/active_job/queue_adapters/backburner_adapter.rb

@@ -16,12 +16,12 @@ module ActiveJob
     #   Rails.application.config.active_job.queue_adapter = :backburner
     class BackburnerAdapter
       def enqueue(job) #:nodoc:
-        Backburner::Worker.enqueue JobWrapper, [ job.serialize ], queue: job.queue_name
+        Backburner::Worker.enqueue(JobWrapper, [job.serialize], queue: job.queue_name, pri: job.priority)
       end
 
       def enqueue_at(job, timestamp) #:nodoc:
         delay = timestamp - Time.current.to_f
-        Backburner::Worker.enqueue JobWrapper, [ job.serialize ], queue: job.queue_name, delay: delay
+        Backburner::Worker.enqueue(JobWrapper, [job.serialize], queue: job.queue_name, pri: job.priority, delay: delay)
       end
 
       class JobWrapper #:nodoc:

data/lib/active_job/queue_adapters/inline_adapter.rb

@@ -16,7 +16,7 @@ module ActiveJob
       end
 
       def enqueue_at(*) #:nodoc:
-        raise NotImplementedError, "Use a queueing backend to enqueue jobs in the future. Read more at http://guides.rubyonrails.org/active_job_basics.html"
+        raise NotImplementedError, "Use a queueing backend to enqueue jobs in the future. Read more at https://guides.rubyonrails.org/active_job_basics.html"
       end
     end
   end

data/lib/active_job/queue_adapters/test_adapter.rb

@@ -12,7 +12,7 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :test
     class TestAdapter
-      attr_accessor(:perform_enqueued_jobs, :perform_enqueued_at_jobs, :filter, :reject)
+      attr_accessor(:perform_enqueued_jobs, :perform_enqueued_at_jobs, :filter, :reject, :queue)
       attr_writer(:enqueued_jobs, :performed_jobs)
 
       # Provides a store of all the enqueued jobs with the TestAdapter so you can check them.
@@ -29,14 +29,14 @@ module ActiveJob
         return if filtered?(job)
 
         job_data = job_to_hash(job)
-        enqueue_or_perform(perform_enqueued_jobs, job, job_data)
+        perform_or_enqueue(perform_enqueued_jobs, job, job_data)
       end
 
       def enqueue_at(job, timestamp) #:nodoc:
         return if filtered?(job)
 
         job_data = job_to_hash(job, at: timestamp)
-        enqueue_or_perform(perform_enqueued_at_jobs, job, job_data)
+        perform_or_enqueue(perform_enqueued_at_jobs, job, job_data)
       end
 
       private
@@ -44,7 +44,7 @@ module ActiveJob
           { job: job.class, args: job.serialize.fetch("arguments"), queue: job.queue_name }.merge!(extras)
         end
 
-        def enqueue_or_perform(perform, job, job_data)
+        def perform_or_enqueue(perform, job, job_data)
           if perform
             performed_jobs << job_data
             Base.execute job.serialize
@@ -54,14 +54,28 @@ module ActiveJob
         end
 
         def filtered?(job)
+          filtered_queue?(job) || filtered_job_class?(job)
+        end
+
+        def filtered_queue?(job)
+          if queue
+            job.queue_name != queue.to_s
+          end
+        end
+
+        def filtered_job_class?(job)
           if filter
-            !Array(filter).include?(job.class)
+            !filter_as_proc(filter).call(job)
           elsif reject
-            Array(reject).include?(job.class)
-          else
-            false
+            filter_as_proc(reject).call(job)
           end
         end
+
+        def filter_as_proc(filter)
+          return filter if filter.is_a?(Proc)
+
+          ->(job) { Array(filter).include?(job.class) }
+        end
     end
   end
 end

data/lib/active_job/queue_adapters.rb

@@ -3,11 +3,10 @@
 module ActiveJob
   # == Active Job adapters
   #
-  # Active Job has adapters for the following queueing backends:
+  # Active Job has adapters for the following queuing backends:
   #
   # * {Backburner}[https://github.com/nesquena/backburner]
   # * {Delayed Job}[https://github.com/collectiveidea/delayed_job]
-  # * {Qu}[https://github.com/bkeepers/qu]
   # * {Que}[https://github.com/chanks/que]
   # * {queue_classic}[https://github.com/QueueClassic/queue_classic]
   # * {Resque}[https://github.com/resque/resque]
@@ -16,6 +15,7 @@ module ActiveJob
   # * {Sucker Punch}[https://github.com/brandonhilkert/sucker_punch]
   # * {Active Job Async Job}[http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters/AsyncAdapter.html]
   # * {Active Job Inline}[http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]
+  # * Please Note: We are not accepting pull requests for new adapters. See the {README}[link:files/activejob/README_md.html] for more details.
   #
   # === Backends Features
   #
@@ -23,7 +23,6 @@ module ActiveJob
   #   |-------------------|-------|--------|------------|------------|---------|---------|
   #   | Backburner        | Yes   | Yes    | Yes        | Yes        | Job     | Global  |
   #   | Delayed Job       | Yes   | Yes    | Yes        | Job        | Global  | Global  |
-  #   | Qu                | Yes   | Yes    | No         | No         | No      | Global  |
   #   | Que               | Yes   | Yes    | Yes        | Job        | No      | Job     |
   #   | queue_classic     | Yes   | Yes    | Yes*       | No         | No      | No      |
   #   | Resque            | Yes   | Yes    | Yes (Gem)  | Queue      | Global  | Yes     |
@@ -53,7 +52,7 @@ module ActiveJob
   #
   # No: The adapter will run jobs at the next opportunity and cannot use perform_later.
   #
-  # N/A: The adapter does not support queueing.
+  # N/A: The adapter does not support queuing.
   #
   # NOTE:
   # queue_classic supports job scheduling since version 3.1.
@@ -75,7 +74,7 @@ module ActiveJob
   #
   # No: Does not allow the priority of jobs to be configured.
   #
-  # N/A: The adapter does not support queueing, and therefore sorting them.
+  # N/A: The adapter does not support queuing, and therefore sorting them.
   #
   # ==== Timeout
   #
@@ -114,7 +113,6 @@ module ActiveJob
     autoload :InlineAdapter
     autoload :BackburnerAdapter
     autoload :DelayedJobAdapter
-    autoload :QuAdapter
     autoload :QueAdapter
     autoload :QueueClassicAdapter
     autoload :ResqueAdapter
@@ -123,7 +121,7 @@ module ActiveJob
     autoload :SuckerPunchAdapter
     autoload :TestAdapter
 
-    ADAPTER = "Adapter".freeze
+    ADAPTER = "Adapter"
     private_constant :ADAPTER
 
     class << self

data/lib/active_job/queue_name.rb

@@ -34,7 +34,7 @@ module ActiveJob
     end
 
     included do
-      class_attribute :queue_name, instance_accessor: false, default: default_queue_name
+      class_attribute :queue_name, instance_accessor: false, default: -> { self.class.default_queue_name }
       class_attribute :queue_name_delimiter, instance_accessor: false, default: "_"
     end
 

data/lib/active_job/railtie.rb

@@ -7,17 +7,32 @@ module ActiveJob
   # = Active Job Railtie
   class Railtie < Rails::Railtie # :nodoc:
     config.active_job = ActiveSupport::OrderedOptions.new
+    config.active_job.custom_serializers = []
 
     initializer "active_job.logger" do
       ActiveSupport.on_load(:active_job) { self.logger = ::Rails.logger }
     end
 
+    initializer "active_job.custom_serializers" do |app|
+      config.after_initialize do
+        custom_serializers = app.config.active_job.delete(:custom_serializers)
+        ActiveJob::Serializers.add_serializers custom_serializers
+      end
+    end
+
     initializer "active_job.set_configs" do |app|
       options = app.config.active_job
       options.queue_adapter ||= :async
 
       ActiveSupport.on_load(:active_job) do
-        options.each { |k, v| send("#{k}=", v) }
+        options.each do  |k, v|
+          k = "#{k}="
+          send(k, v) if respond_to? k
+        end
+      end
+
+      ActiveSupport.on_load(:action_dispatch_integration_test) do
+        include ActiveJob::TestHelper
       end
     end
 

data/lib/active_job/serializers/date_serializer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class DateSerializer < ObjectSerializer # :nodoc:
+      def serialize(date)
+        super("value" => date.iso8601)
+      end
+
+      def deserialize(hash)
+        Date.iso8601(hash["value"])
+      end
+
+      private
+
+        def klass
+          Date
+        end
+    end
+  end
+end

data/lib/active_job/serializers/date_time_serializer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class DateTimeSerializer < ObjectSerializer # :nodoc:
+      def serialize(time)
+        super("value" => time.iso8601)
+      end
+
+      def deserialize(hash)
+        DateTime.iso8601(hash["value"])
+      end
+
+      private
+
+        def klass
+          DateTime
+        end
+    end
+  end
+end

data/lib/active_job/serializers/duration_serializer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class DurationSerializer < ObjectSerializer # :nodoc:
+      def serialize(duration)
+        super("value" => duration.value, "parts" => Arguments.serialize(duration.parts))
+      end
+
+      def deserialize(hash)
+        value = hash["value"]
+        parts = Arguments.deserialize(hash["parts"])
+
+        klass.new(value, parts)
+      end
+
+      private
+
+        def klass
+          ActiveSupport::Duration
+        end
+    end
+  end
+end

data/lib/active_job/serializers/object_serializer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    # Base class for serializing and deserializing custom objects.
+    #
+    # Example:
+    #
+    #   class MoneySerializer < ActiveJob::Serializers::ObjectSerializer
+    #     def serialize(money)
+    #       super("amount" => money.amount, "currency" => money.currency)
+    #     end
+    #
+    #     def deserialize(hash)
+    #       Money.new(hash["amount"], hash["currency"])
+    #     end
+    #
+    #     private
+    #
+    #       def klass
+    #         Money
+    #       end
+    #   end
+    class ObjectSerializer
+      include Singleton
+
+      class << self
+        delegate :serialize?, :serialize, :deserialize, to: :instance
+      end
+
+      # Determines if an argument should be serialized by a serializer.
+      def serialize?(argument)
+        argument.is_a?(klass)
+      end
+
+      # Serializes an argument to a JSON primitive type.
+      def serialize(hash)
+        { Arguments::OBJECT_SERIALIZER_KEY => self.class.name }.merge!(hash)
+      end
+
+      # Deserializes an argument from a JSON primitive type.
+      def deserialize(_argument)
+        raise NotImplementedError
+      end
+
+      private
+
+        # The class of the object that will be serialized.
+        def klass # :doc:
+          raise NotImplementedError
+        end
+    end
+  end
+end

data/lib/active_job/serializers/symbol_serializer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class SymbolSerializer < ObjectSerializer # :nodoc:
+      def serialize(argument)
+        super("value" => argument.to_s)
+      end
+
+      def deserialize(argument)
+        argument["value"].to_sym
+      end
+
+      private
+
+        def klass
+          Symbol
+        end
+    end
+  end
+end

data/lib/active_job/serializers/time_serializer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class TimeSerializer < ObjectSerializer # :nodoc:
+      def serialize(time)
+        super("value" => time.iso8601)
+      end
+
+      def deserialize(hash)
+        Time.iso8601(hash["value"])
+      end
+
+      private
+
+        def klass
+          Time
+        end
+    end
+  end
+end

data/lib/active_job/serializers/time_with_zone_serializer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class TimeWithZoneSerializer < ObjectSerializer # :nodoc:
+      def serialize(time)
+        super("value" => time.iso8601)
+      end
+
+      def deserialize(hash)
+        Time.iso8601(hash["value"]).in_time_zone
+      end
+
+      private
+
+        def klass
+          ActiveSupport::TimeWithZone
+        end
+    end
+  end
+end

data/lib/active_job/serializers.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "set"
+
+module ActiveJob
+  # The <tt>ActiveJob::Serializers</tt> module is used to store a list of known serializers
+  # and to add new ones. It also has helpers to serialize/deserialize objects.
+  module Serializers # :nodoc:
+    extend ActiveSupport::Autoload
+
+    autoload :ObjectSerializer
+    autoload :SymbolSerializer
+    autoload :DurationSerializer
+    autoload :DateTimeSerializer
+    autoload :DateSerializer
+    autoload :TimeWithZoneSerializer
+    autoload :TimeSerializer
+
+    mattr_accessor :_additional_serializers
+    self._additional_serializers = Set.new
+
+    class << self
+      # Returns serialized representative of the passed object.
+      # Will look up through all known serializers.
+      # Raises <tt>ActiveJob::SerializationError</tt> if it can't find a proper serializer.
+      def serialize(argument)
+        serializer = serializers.detect { |s| s.serialize?(argument) }
+        raise SerializationError.new("Unsupported argument type: #{argument.class.name}") unless serializer
+        serializer.serialize(argument)
+      end
+
+      # Returns deserialized object.
+      # Will look up through all known serializers.
+      # If no serializer found will raise <tt>ArgumentError</tt>.
+      def deserialize(argument)
+        serializer_name = argument[Arguments::OBJECT_SERIALIZER_KEY]
+        raise ArgumentError, "Serializer name is not present in the argument: #{argument.inspect}" unless serializer_name
+
+        serializer = serializer_name.safe_constantize
+        raise ArgumentError, "Serializer #{serializer_name} is not known" unless serializer
+
+        serializer.deserialize(argument)
+      end
+
+      # Returns list of known serializers.
+      def serializers
+        self._additional_serializers
+      end
+
+      # Adds new serializers to a list of known serializers.
+      def add_serializers(*new_serializers)
+        self._additional_serializers += new_serializers.flatten
+      end
+    end
+
+    add_serializers SymbolSerializer,
+      DurationSerializer,
+      DateTimeSerializer,
+      DateSerializer,
+      TimeWithZoneSerializer,
+      TimeSerializer
+  end
+end