activejob 6.0.4.7 → 6.1.0.rc1

data/lib/active_job/gem_version.rb

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

data/lib/active_job/instrumentation.rb

@@ -0,0 +1,37 @@
+# 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
+          block.call if block
+          if defined?(@_halted_callback_hook_called) && @_halted_callback_hook_called
+            event_payload[:aborted] = true
+            @_halted_callback_hook_called = nil
+          end
+        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

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
 

data/lib/active_job/queue_adapters/inline_adapter.rb

@@ -12,7 +12,7 @@ module ActiveJob
     #   Rails.application.config.active_job.queue_adapter = :inline
     class InlineAdapter
       def enqueue(job) #:nodoc:
-        Base.execute(job.serialize)
+        Thread.new { Base.execute(job.serialize) }.join
       end
 
       def enqueue_at(*) #:nodoc:

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, :queue)
+      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.
@@ -54,7 +54,11 @@ module ActiveJob
         end
 
         def filtered?(job)
-          filtered_queue?(job) || filtered_job_class?(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)

data/lib/active_job/queue_adapters.rb

@@ -72,7 +72,7 @@ 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 queuing, and therefore sorting them.
   #
@@ -86,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.
   #
@@ -99,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.
   #

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.
@@ -49,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: -> { 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

@@ -34,6 +34,10 @@ module ActiveJob
       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
 
     initializer "active_job.set_reloader_hook" do |app|

data/lib/active_job/serializers/date_time_serializer.rb

@@ -2,11 +2,7 @@
 
 module ActiveJob
   module Serializers
-    class DateTimeSerializer < ObjectSerializer # :nodoc:
-      def serialize(time)
-        super("value" => time.iso8601)
-      end
-
+    class DateTimeSerializer < TimeObjectSerializer # :nodoc:
       def deserialize(hash)
         DateTime.iso8601(hash["value"])
       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

@@ -39,7 +39,7 @@ module ActiveJob
       end
 
       # Deserializes an argument from a JSON primitive type.
-      def deserialize(_argument)
+      def deserialize(json)
         raise NotImplementedError
       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

@@ -2,11 +2,7 @@
 
 module ActiveJob
   module Serializers
-    class TimeSerializer < ObjectSerializer # :nodoc:
-      def serialize(time)
-        super("value" => time.iso8601)
-      end
-
+    class TimeSerializer < TimeObjectSerializer # :nodoc:
       def deserialize(hash)
         Time.iso8601(hash["value"])
       end

data/lib/active_job/serializers/time_with_zone_serializer.rb

@@ -2,11 +2,7 @@
 
 module ActiveJob
   module Serializers
-    class TimeWithZoneSerializer < ObjectSerializer # :nodoc:
-      def serialize(time)
-        super("value" => time.iso8601)
-      end
-
+    class TimeWithZoneSerializer < TimeObjectSerializer # :nodoc:
       def deserialize(hash)
         Time.iso8601(hash["value"]).in_time_zone
       end

data/lib/active_job/serializers.rb

@@ -9,12 +9,14 @@ module ActiveJob
     extend ActiveSupport::Autoload
 
     autoload :ObjectSerializer
+    autoload :TimeObjectSerializer
     autoload :SymbolSerializer
     autoload :DurationSerializer
     autoload :DateTimeSerializer
     autoload :DateSerializer
     autoload :TimeWithZoneSerializer
     autoload :TimeSerializer
+    autoload :ModuleSerializer
 
     mattr_accessor :_additional_serializers
     self._additional_serializers = Set.new
@@ -58,6 +60,7 @@ module ActiveJob
       DateTimeSerializer,
       DateSerializer,
       TimeWithZoneSerializer,
-      TimeSerializer
+      TimeSerializer,
+      ModuleSerializer
   end
 end