activejob 8.0.3 → 8.1.0.rc1

data/lib/active_job/queue_adapters/sidekiq_adapter.rb

@@ -18,6 +18,25 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :sidekiq
     class SidekiqAdapter < AbstractAdapter
+      def initialize(*) # :nodoc:
+        @stopping = false
+
+        Sidekiq.configure_server do |config|
+          config.on(:quiet) { @stopping = true }
+        end
+
+        Sidekiq.configure_client do |config|
+          config.on(:quiet) { @stopping = true }
+        end
+      end
+
+      def check_adapter
+        ActiveJob.deprecator.warn <<~MSG.squish
+          The built-in `sidekiq` adapter is deprecated and will be removed in Rails 8.2.
+          Please upgrade `sidekiq` gem to version 7.3.3 or later to use the `sidekiq` gem's adapter.
+        MSG
+      end
+
       def enqueue(job) # :nodoc:
         job.provider_job_id = JobWrapper.set(
           wrapped: job.class,

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 < AbstractAdapter
-      attr_accessor(:perform_enqueued_jobs, :perform_enqueued_at_jobs, :filter, :reject, :queue, :at)
+      attr_accessor(:perform_enqueued_jobs, :perform_enqueued_at_jobs, :filter, :reject, :queue, :at, :stopping)
       attr_writer(:enqueued_jobs, :performed_jobs)
 
       # Provides a store of all the enqueued jobs with the TestAdapter so you can check them.
@@ -35,6 +35,10 @@ module ActiveJob
         perform_or_enqueue(perform_enqueued_at_jobs && !filtered?(job), job, job_data)
       end
 
+      def stopping?
+        @stopping.is_a?(Proc) ? @stopping.call : @stopping
+      end
+
       private
         def job_to_hash(job, extras = {})
           job.serialize.tap do |job_data|

data/lib/active_job/railtie.rb

@@ -19,7 +19,7 @@ module ActiveJob
     end
 
     initializer "active_job.custom_serializers" do |app|
-      config.after_initialize do
+      ActiveSupport.on_load(:active_job) do
         custom_serializers = app.config.active_job.custom_serializers
         ActiveJob::Serializers.add_serializers custom_serializers
       end
@@ -29,25 +29,14 @@ module ActiveJob
       ActiveSupport.on_load(:active_job) do
         ActiveSupport.on_load(:active_record) do
           ActiveJob::Base.include EnqueueAfterTransactionCommit
+        end
+      end
+    end
 
-          if app.config.active_job.key?(:enqueue_after_transaction_commit)
-            ActiveJob.deprecator.warn(<<~MSG.squish)
-              `config.active_job.enqueue_after_transaction_commit` is deprecated and will be removed in Rails 8.1.
-              This configuration can still be set on individual jobs using `self.enqueue_after_transaction_commit=`,
-              but due the nature of this behavior, it is not recommended to be set globally.
-            MSG
-
-            value = case app.config.active_job.enqueue_after_transaction_commit
-            when :always
-              true
-            when :never
-              false
-            else
-              false
-            end
-
-            ActiveJob::Base.enqueue_after_transaction_commit = value
-          end
+    initializer "active_job.action_controller_parameters" do |app|
+      ActiveSupport.on_load(:active_job) do
+        ActiveSupport.on_load(:action_controller) do
+          ActiveJob::Serializers.add_serializers ActiveJob::Serializers::ActionControllerParametersSerializer
         end
       end
     end
@@ -70,6 +59,7 @@ module ActiveJob
         options = options.except(
           :log_query_tags_around_perform,
           :custom_serializers,
+          # This config can't be applied globally, so we need to remove otherwise it will be applied to `ActiveJob::Base`.
           :enqueue_after_transaction_commit
         )
 

data/lib/active_job/serializers/action_controller_parameters_serializer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class ActionControllerParametersSerializer < ObjectSerializer
+      def serialize(argument)
+        Arguments.serialize_argument(argument.to_h.with_indifferent_access)
+      end
+
+      def deserialize(hash)
+        raise NotImplementedError # Serialized as a HashWithIndifferentAccess
+      end
+
+      def serialize?(argument)
+        argument.respond_to?(:permitted?) && argument.respond_to?(:to_h)
+      end
+
+      def klass
+        if defined?(ActionController::Parameters)
+          ActionController::Parameters
+        end
+      end
+    end
+  end
+end

data/lib/active_job/serializers/big_decimal_serializer.rb

@@ -13,10 +13,9 @@ module ActiveJob
         BigDecimal(hash["value"])
       end
 
-      private
-        def klass
-          BigDecimal
-        end
+      def klass
+        BigDecimal
+      end
     end
   end
 end

data/lib/active_job/serializers/date_serializer.rb

@@ -11,10 +11,9 @@ module ActiveJob
         Date.iso8601(hash["value"])
       end
 
-      private
-        def klass
-          Date
-        end
+      def klass
+        Date
+      end
     end
   end
 end

data/lib/active_job/serializers/date_time_serializer.rb

@@ -7,10 +7,9 @@ module ActiveJob
         DateTime.iso8601(hash["value"])
       end
 
-      private
-        def klass
-          DateTime
-        end
+      def klass
+        DateTime
+      end
     end
   end
 end

data/lib/active_job/serializers/duration_serializer.rb

@@ -6,20 +6,19 @@ module ActiveJob
       def serialize(duration)
         # Ideally duration.parts would be wrapped in an array before passing to Arguments.serialize,
         # but we continue passing the bare hash for backwards compatibility:
-        super("value" => duration.value, "parts" => Arguments.serialize(duration.parts))
+        super("value" => duration.value, "parts" => Arguments.serialize(duration.parts.to_a))
       end
 
       def deserialize(hash)
         value = hash["value"]
-        parts = Arguments.deserialize(hash["parts"])
+        parts = Arguments.deserialize(hash["parts"].to_h)
         # `parts` is originally a hash, but will have been flattened to an array by Arguments.serialize
         klass.new(value, parts.to_h)
       end
 
-      private
-        def klass
-          ActiveSupport::Duration
-        end
+      def klass
+        ActiveSupport::Duration
+      end
     end
   end
 end

data/lib/active_job/serializers/module_serializer.rb

@@ -12,10 +12,9 @@ module ActiveJob
         hash["value"].constantize
       end
 
-      private
-        def klass
-          Module
-        end
+      def klass
+        Module
+      end
     end
   end
 end

data/lib/active_job/serializers/object_serializer.rb

@@ -17,11 +17,9 @@ module ActiveJob
     #       Money.new(hash["amount"], hash["currency"])
     #     end
     #
-    #     private
-    #
-    #       def klass
-    #         Money
-    #       end
+    #     def klass
+    #       Money
+    #     end
     #   end
     class ObjectSerializer
       include Singleton
@@ -30,6 +28,11 @@ module ActiveJob
         delegate :serialize?, :serialize, :deserialize, to: :instance
       end
 
+      def initialize
+        super
+        @template = { Arguments::OBJECT_SERIALIZER_KEY => self.class.name }.freeze
+      end
+
       # Determines if an argument should be serialized by a serializer.
       def serialize?(argument)
         argument.is_a?(klass)
@@ -37,19 +40,13 @@ module ActiveJob
 
       # Serializes an argument to a JSON primitive type.
       def serialize(hash)
-        { Arguments::OBJECT_SERIALIZER_KEY => self.class.name }.merge!(hash)
+        @template.merge(hash)
       end
 
       # Deserializes an argument from a JSON primitive type.
-      def deserialize(json)
-        raise NotImplementedError
+      def deserialize(hash)
+        raise NotImplementedError, "#{self.class.name} should implement a public #deserialize(hash) method"
       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/range_serializer.rb

@@ -3,21 +3,21 @@
 module ActiveJob
   module Serializers
     class RangeSerializer < ObjectSerializer
-      KEYS = %w[begin end exclude_end].freeze
-
       def serialize(range)
-        args = Arguments.serialize([range.begin, range.end, range.exclude_end?])
-        super(KEYS.zip(args).to_h)
+        super(
+          "begin" => Arguments.serialize_argument(range.begin),
+          "end" => Arguments.serialize_argument(range.end),
+          "exclude_end" => range.exclude_end?, # Always boolean, no need to serialize
+        )
       end
 
       def deserialize(hash)
-        klass.new(*Arguments.deserialize(hash.values_at(*KEYS)))
+        Range.new(*Arguments.deserialize([hash["begin"], hash["end"]]), hash["exclude_end"])
       end
 
-      private
-        def klass
-          ::Range
-        end
+      def klass
+        ::Range
+      end
     end
   end
 end

data/lib/active_job/serializers/symbol_serializer.rb

@@ -4,17 +4,16 @@ module ActiveJob
   module Serializers
     class SymbolSerializer < ObjectSerializer # :nodoc:
       def serialize(argument)
-        super("value" => argument.to_s)
+        super("value" => argument.name)
       end
 
       def deserialize(argument)
         argument["value"].to_sym
       end
 
-      private
-        def klass
-          Symbol
-        end
+      def klass
+        Symbol
+      end
     end
   end
 end

data/lib/active_job/serializers/time_serializer.rb

@@ -7,10 +7,9 @@ module ActiveJob
         Time.iso8601(hash["value"])
       end
 
-      private
-        def klass
-          Time
-        end
+      def klass
+        Time
+      end
     end
   end
 end

data/lib/active_job/serializers/time_with_zone_serializer.rb

@@ -16,10 +16,9 @@ module ActiveJob
         Time.iso8601(hash["value"]).in_time_zone(hash["time_zone"] || Time.zone)
       end
 
-      private
-        def klass
-          ActiveSupport::TimeWithZone
-        end
+      def klass
+        ActiveSupport::TimeWithZone
+      end
     end
   end
 end

data/lib/active_job/serializers.rb

@@ -19,16 +19,17 @@ module ActiveJob
     autoload :ModuleSerializer
     autoload :RangeSerializer
     autoload :BigDecimalSerializer
+    autoload :ActionControllerParametersSerializer
 
-    mattr_accessor :_additional_serializers
-    self._additional_serializers = Set.new
+    @serializers = Set.new
+    @serializers_index = {}
 
     class << self
       # Returns serialized representative of the passed object.
       # Will look up through all known serializers.
       # Raises ActiveJob::SerializationError if it can't find a proper serializer.
       def serialize(argument)
-        serializer = serializers.detect { |s| s.serialize?(argument) }
+        serializer = @serializers_index[argument.class] || serializers.find { |s| s.serialize?(argument) }
         raise SerializationError.new("Unsupported argument type: #{argument.class.name}") unless serializer
         serializer.serialize(argument)
       end
@@ -47,24 +48,62 @@ module ActiveJob
       end
 
       # Returns list of known serializers.
-      def serializers
-        self._additional_serializers
+      attr_reader :serializers
+
+      def serializers=(serializers)
+        @serializers = serializers
+        index_serializers
       end
 
       # Adds new serializers to a list of known serializers.
       def add_serializers(*new_serializers)
-        self._additional_serializers += new_serializers.flatten
+        new_serializers = new_serializers.flatten
+        new_serializers.map! do |s|
+          if s.is_a?(Class) && s < ObjectSerializer
+            s.instance
+          else
+            s
+          end
+        end
+
+        @serializers += new_serializers
+        index_serializers
+        @serializers
       end
+
+      private
+        def index_serializers
+          @serializers_index.clear
+          serializers.each do |s|
+            if s.respond_to?(:klass)
+              @serializers_index[s.klass] = s
+            elsif s.respond_to?(:klass, true)
+              klass = s.send(:klass)
+              ActiveJob.deprecator.warn(<<~MSG.squish)
+                #{s.class.name}#klass method should be public.
+                This will raise an error in Rails 8.2.
+              MSG
+              @serializers_index[klass] = s
+            else
+              ActiveJob.deprecator.warn(
+                <<~MSG.squish
+                  #{s.class.name} should implement a public #klass method.
+                  This will raise an error in Rails 8.2.
+                MSG
+              )
+            end
+          end
+        end
     end
 
-    add_serializers SymbolSerializer,
-      DurationSerializer,
-      DateTimeSerializer,
-      DateSerializer,
-      TimeWithZoneSerializer,
-      TimeSerializer,
-      ModuleSerializer,
-      RangeSerializer,
-      BigDecimalSerializer
+    add_serializers SymbolSerializer.instance,
+      DurationSerializer.instance,
+      DateTimeSerializer.instance,
+      DateSerializer.instance,
+      TimeWithZoneSerializer.instance,
+      TimeSerializer.instance,
+      ModuleSerializer.instance,
+      RangeSerializer.instance,
+      BigDecimalSerializer.instance
   end
 end

data/lib/active_job/structured_event_subscriber.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "active_support/structured_event_subscriber"
+
+module ActiveJob
+  class StructuredEventSubscriber < ActiveSupport::StructuredEventSubscriber # :nodoc:
+    def enqueue(event)
+      job = event.payload[:job]
+      adapter = event.payload[:adapter]
+      exception = event.payload[:exception_object] || job.enqueue_error
+      payload = {
+        job_class: job.class.name,
+        job_id: job.job_id,
+        queue: job.queue_name,
+        adapter: ActiveJob.adapter_name(adapter),
+        aborted: event.payload[:aborted],
+      }
+
+      if exception
+        payload[:exception_class] = exception.class.name
+        payload[:exception_message] = exception.message
+      end
+
+      if job.class.log_arguments?
+        payload[:arguments] = job.arguments
+      end
+
+      emit_event("active_job.enqueued", payload)
+    end
+
+    def enqueue_at(event)
+      job = event.payload[:job]
+      adapter = event.payload[:adapter]
+      exception = event.payload[:exception_object] || job.enqueue_error
+      payload = {
+        job_class: job.class.name,
+        job_id: job.job_id,
+        queue: job.queue_name,
+        scheduled_at: job.scheduled_at,
+        adapter: ActiveJob.adapter_name(adapter),
+        aborted: event.payload[:aborted],
+      }
+
+      if exception
+        payload[:exception_class] = exception.class.name
+        payload[:exception_message] = exception.message
+      end
+
+      if job.class.log_arguments?
+        payload[:arguments] = job.arguments
+      end
+
+      emit_event("active_job.enqueued_at", payload)
+    end
+
+    def enqueue_all(event)
+      jobs = event.payload[:jobs]
+      adapter = event.payload[:adapter]
+      enqueued_count = event.payload[:enqueued_count].to_i
+      failed_count = jobs.size - enqueued_count
+
+      emit_event("active_job.bulk_enqueued",
+        adapter: ActiveJob.adapter_name(adapter),
+        job_count: jobs.size,
+        enqueued_count: enqueued_count,
+        failed_enqueue_count: failed_count,
+        enqueued_classes: jobs.filter_map { |job| job.class.name }.tally
+      )
+    end
+
+    def perform_start(event)
+      job = event.payload[:job]
+      payload = {
+        job_class: job.class.name,
+        job_id: job.job_id,
+        queue: job.queue_name,
+        enqueued_at: job.enqueued_at&.utc&.iso8601(9),
+      }
+      if job.class.log_arguments?
+        payload[:arguments] = job.arguments
+      end
+      emit_event("active_job.started", payload)
+    end
+
+    def perform(event)
+      job = event.payload[:job]
+      exception = event.payload[:exception_object]
+      payload = {
+        job_class: job.class.name,
+        job_id: job.job_id,
+        queue: job.queue_name,
+        aborted: event.payload[:aborted],
+        duration: event.duration.round(2),
+      }
+
+      if exception
+        payload[:exception_class] = exception.class.name
+        payload[:exception_message] = exception.message
+        payload[:exception_backtrace] = exception.backtrace
+      end
+
+      emit_event("active_job.completed", payload)
+    end
+
+    def enqueue_retry(event)
+      job = event.payload[:job]
+      exception = event.payload[:error]
+      wait = event.payload[:wait]
+
+      emit_event("active_job.retry_scheduled",
+        job_class: job.class.name,
+        job_id: job.job_id,
+        executions: job.executions,
+        wait_seconds: wait.to_i,
+        exception_class: exception&.class&.name,
+        exception_message: exception&.message
+      )
+    end
+
+    def retry_stopped(event)
+      job = event.payload[:job]
+      exception = event.payload[:error]
+
+      emit_event("active_job.retry_stopped",
+        job_class: job.class.name,
+        job_id: job.job_id,
+        executions: job.executions,
+        exception_class: exception.class.name,
+        exception_message: exception.message
+      )
+    end
+
+    def discard(event)
+      job = event.payload[:job]
+      exception = event.payload[:error]
+
+      emit_event("active_job.discarded",
+        job_class: job.class.name,
+        job_id: job.job_id,
+        exception_class: exception.class.name,
+        exception_message: exception.message
+      )
+    end
+
+    def interrupt(event)
+      job = event.payload[:job]
+      description = event.payload[:description]
+      reason = event.payload[:reason]
+
+      emit_event("active_job.interrupt",
+        job_class: job.class.name,
+        job_id: job.job_id,
+        description: description,
+        reason: reason,
+      )
+    end
+
+    def resume(event)
+      job = event.payload[:job]
+      description = event.payload[:description]
+
+      emit_event("active_job.resume",
+        job_class: job.class.name,
+        job_id: job.job_id,
+        description: description,
+      )
+    end
+
+    def step_skipped(event)
+      job = event.payload[:job]
+      step = event.payload[:step]
+
+      emit_event("active_job.step_skipped",
+        job_class: job.class.name,
+        job_id: job.job_id,
+        step: step.name,
+      )
+    end
+
+    def step_started(event)
+      job = event.payload[:job]
+      step = event.payload[:step]
+
+      emit_event("active_job.step_started",
+        job_class: job.class.name,
+        job_id: job.job_id,
+        step: step.name,
+        cursor: step.cursor,
+        resumed: step.resumed?,
+      )
+    end
+
+    def step(event)
+      job = event.payload[:job]
+      step = event.payload[:step]
+      exception = event.payload[:exception_object]
+      payload = {
+        job_class: job.class.name,
+        job_id: job.job_id,
+        step: step.name,
+        cursor: step.cursor,
+        interrupted: event.payload[:interrupted],
+        duration: event.duration.round(2),
+      }
+
+      if exception
+        payload[:exception_class] = exception.class.name
+        payload[:exception_message] = exception.message
+      end
+
+      emit_event("active_job.step", payload)
+    end
+  end
+end
+
+ActiveJob::StructuredEventSubscriber.attach_to :active_job

data/lib/active_job.rb

@@ -39,9 +39,12 @@ module ActiveJob
   autoload :Arguments
   autoload :DeserializationError, "active_job/arguments"
   autoload :SerializationError, "active_job/arguments"
+  autoload :UnknownJobClassError, "active_job/core"
   autoload :EnqueueAfterTransactionCommit
 
   eager_autoload do
+    autoload :Continuable
+    autoload :Continuation
     autoload :Serializers
     autoload :ConfiguredJob
   end