activejob 5.2.8.1 → 6.1.6.1

data/lib/active_job/logging.rb

@@ -1,7 +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"
 
@@ -11,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
-
-      after_enqueue do |job|
-        if job.scheduled_at
-          ActiveSupport::Notifications.instrument "enqueue_at.active_job",
-            adapter: job.class.queue_adapter, job: job
-        else
-          ActiveSupport::Notifications.instrument "enqueue.active_job",
-            adapter: job.class.queue_adapter, job: job
-        end
-      end
+      around_enqueue { |_, block| tag_logger(&block) }
+      around_perform { |job, block| tag_logger(job.class.name, job.job_id, &block) }
     end
 
     private
@@ -52,79 +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)}" + 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
-
-        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

data/lib/active_job/queue_adapter.rb

@@ -11,6 +11,9 @@ module ActiveJob
     included do
       class_attribute :_queue_adapter_name, instance_accessor: false, instance_predicate: false
       class_attribute :_queue_adapter, instance_accessor: false, instance_predicate: false
+
+      delegate :queue_adapter, to: :class
+
       self.queue_adapter = :async
     end
 
@@ -22,6 +25,8 @@ module ActiveJob
         _queue_adapter
       end
 
+      # Returns string denoting the name of the configured queue adapter.
+      # By default returns <tt>"async"</tt>.
       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/que_adapter.rb

@@ -18,13 +18,13 @@ module ActiveJob
     #   Rails.application.config.active_job.queue_adapter = :que
     class QueAdapter
       def enqueue(job) #:nodoc:
-        que_job = JobWrapper.enqueue job.serialize, priority: job.priority
+        que_job = JobWrapper.enqueue job.serialize, priority: job.priority, queue: job.queue_name
         job.provider_job_id = que_job.attrs["job_id"]
         que_job
       end
 
       def enqueue_at(job, timestamp) #:nodoc:
-        que_job = JobWrapper.enqueue job.serialize, priority: job.priority, run_at: Time.at(timestamp)
+        que_job = JobWrapper.enqueue job.serialize, priority: job.priority, queue: job.queue_name, run_at: Time.at(timestamp)
         job.provider_job_id = que_job.attrs["job_id"]
         que_job
       end

data/lib/active_job/queue_adapters/sidekiq_adapter.rb

@@ -21,7 +21,7 @@ module ActiveJob
         # Sidekiq::Client does not support symbols as keys
         job.provider_job_id = Sidekiq::Client.push \
           "class"   => JobWrapper,
-          "wrapped" => job.class.to_s,
+          "wrapped" => job.class,
           "queue"   => job.queue_name,
           "args"    => [ job.serialize ]
       end
@@ -29,7 +29,7 @@ module ActiveJob
       def enqueue_at(job, timestamp) #:nodoc:
         job.provider_job_id = Sidekiq::Client.push \
           "class"   => JobWrapper,
-          "wrapped" => job.class.to_s,
+          "wrapped" => job.class,
           "queue"   => job.queue_name,
           "args"    => [ job.serialize ],
           "at"      => timestamp

data/lib/active_job/queue_adapters/sucker_punch_adapter.rb

@@ -10,7 +10,7 @@ module ActiveJob
     # This reduces the cost of hosting on a service like Heroku along
     # with the memory footprint of having to maintain additional jobs if
     # hosting on a dedicated server. All queues can run within a
-    # single application (eg. Rails, Sinatra, etc.) process.
+    # single application (e.g. Rails, Sinatra, etc.) process.
     #
     # Read more about Sucker Punch {here}[https://github.com/brandonhilkert/sucker_punch].
     #

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, :at)
       attr_writer(:enqueued_jobs, :performed_jobs)
 
       # Provides a store of all the enqueued jobs with the TestAdapter so you can check them.
@@ -26,42 +26,60 @@ module ActiveJob
       end
 
       def enqueue(job) #:nodoc:
-        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 && !filtered?(job), 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 && !filtered?(job), job, job_data)
       end
 
       private
         def job_to_hash(job, extras = {})
-          { job: job.class, args: job.serialize.fetch("arguments"), queue: job.queue_name }.merge!(extras)
+          job.serialize.tap do |job_data|
+            job_data[:job] = job.class
+            job_data[:args] = job_data.fetch("arguments")
+            job_data[:queue] = job_data.fetch("queue_name")
+          end.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
+            Base.execute(job.serialize)
           else
             enqueued_jobs << job_data
           end
         end
 
         def filtered?(job)
+          filtered_queue?(job) || filtered_job_class?(job) || filtered_time?(job)
+        end
+
+        def filtered_time?(job)
+          job.scheduled_at > at.to_f if at && job.scheduled_at
+        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,19 +3,19 @@
 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]
-  # * {Sidekiq}[http://sidekiq.org]
+  # * {Sidekiq}[https://sidekiq.org]
   # * {Sneakers}[https://github.com/jondot/sneakers]
   # * {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]
+  # * {Active Job Async Job}[https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters/AsyncAdapter.html]
+  # * {Active Job Inline}[https://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.
@@ -73,9 +72,9 @@ module ActiveJob
   # Yes: Allows the priority to be set on the job object, at the queue level or
   # as default configuration option.
   #
-  # No: Does not allow the priority of jobs to be configured.
+  # No: The adapter 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
   #
@@ -87,6 +86,8 @@ module ActiveJob
   #
   # Global: The adapter is configured that all jobs have a maximum run time.
   #
+  # No: The adapter does not allow the timeout of jobs to be configured.
+  #
   # N/A: This adapter does not run in a separate process, and therefore timeout
   # is unsupported.
   #
@@ -100,6 +101,8 @@ module ActiveJob
   #
   # Global: The adapter has a global number of retries.
   #
+  # No: The adapter does not allow the number of retries to be configured.
+  #
   # N/A: The adapter does not run in a separate process, and therefore doesn't
   # support retries.
   #
@@ -114,7 +117,6 @@ module ActiveJob
     autoload :InlineAdapter
     autoload :BackburnerAdapter
     autoload :DelayedJobAdapter
-    autoload :QuAdapter
     autoload :QueAdapter
     autoload :QueueClassicAdapter
     autoload :ResqueAdapter
@@ -123,7 +125,7 @@ module ActiveJob
     autoload :SuckerPunchAdapter
     autoload :TestAdapter
 
-    ADAPTER = "Adapter".freeze
+    ADAPTER = "Adapter"
     private_constant :ADAPTER
 
     class << self

data/lib/active_job/queue_name.rb

@@ -6,7 +6,6 @@ module ActiveJob
 
     # Includes the ability to override the default queue name and prefix.
     module ClassMethods
-      mattr_accessor :queue_name_prefix
       mattr_accessor :default_queue_name, default: "default"
 
       # Specifies the name of the queue to process the job on.
@@ -18,6 +17,26 @@ module ActiveJob
       #       post.to_feed!
       #     end
       #   end
+      #
+      # Can be given a block that will evaluate in the context of the job
+      # allowing +self.arguments+ to be accessed so that a dynamic queue name
+      # can be applied:
+      #
+      #   class PublishToFeedJob < ApplicationJob
+      #     queue_as do
+      #       post = self.arguments.first
+      #
+      #       if post.paid?
+      #         :paid_feeds
+      #       else
+      #         :feeds
+      #       end
+      #     end
+      #
+      #     def perform(post)
+      #       post.to_feed!
+      #     end
+      #   end
       def queue_as(part_name = nil, &block)
         if block_given?
           self.queue_name = block
@@ -29,13 +48,14 @@ module ActiveJob
       def queue_name_from_part(part_name) #:nodoc:
         queue_name = part_name || default_queue_name
         name_parts = [queue_name_prefix.presence, queue_name]
-        name_parts.compact.join(queue_name_delimiter)
+        -name_parts.compact.join(queue_name_delimiter)
       end
     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: "_"
+      class_attribute :queue_name_prefix
     end
 
     # Returns the name of the queue the job will be run on.

data/lib/active_job/railtie.rb

@@ -7,17 +7,36 @@ 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
+
+      ActiveSupport.on_load(:active_record) do
+        self.destroy_association_async_job = ActiveRecord::DestroyAssociationAsyncJob
       end
     end
 

data/lib/active_job/serializers/date_serializer.rb

@@ -0,0 +1,20 @@
+# 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,16 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class DateTimeSerializer < TimeObjectSerializer # :nodoc:
+      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,23 @@
+# 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/module_serializer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class ModuleSerializer < ObjectSerializer # :nodoc:
+      def serialize(constant)
+        super("value" => constant.name)
+      end
+
+      def deserialize(hash)
+        hash["value"].constantize
+      end
+
+      private
+        def klass
+          Module
+        end
+    end
+  end
+end

data/lib/active_job/serializers/object_serializer.rb

@@ -0,0 +1,53 @@
+# 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(json)
+        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,20 @@
+# 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_object_serializer.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class TimeObjectSerializer < ObjectSerializer # :nodoc:
+      NANO_PRECISION = 9
+
+      def serialize(time)
+        super("value" => time.iso8601(NANO_PRECISION))
+      end
+    end
+  end
+end

data/lib/active_job/serializers/time_serializer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class TimeSerializer < TimeObjectSerializer # :nodoc:
+      def deserialize(hash)
+        Time.iso8601(hash["value"])
+      end
+
+      private
+        def klass
+          Time
+        end
+    end
+  end
+end