activejob 7.0.8 → 7.2.0

data/lib/active_job/queue_adapters/sidekiq_adapter.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
 
+gem "sidekiq", ">= 4.1.0"
 require "sidekiq"
 
 module ActiveJob
   module QueueAdapters
-    # == Sidekiq adapter for Active Job
+    # = Sidekiq adapter for Active Job
     #
     # Simple, efficient background processing for Ruby. Sidekiq uses threads to
     # handle many jobs at the same time in the same process. It does not
-    # require Rails but will integrate tightly with it to make background
+    # require \Rails but will integrate tightly with it to make background
     # processing dead simple.
     #
     # Read more about Sidekiq {here}[http://sidekiq.org].
@@ -16,23 +17,50 @@ module ActiveJob
     # To use Sidekiq set the queue_adapter config to +:sidekiq+.
     #
     #   Rails.application.config.active_job.queue_adapter = :sidekiq
-    class SidekiqAdapter
+    class SidekiqAdapter < AbstractAdapter
       def enqueue(job) # :nodoc:
-        # Sidekiq::Client does not support symbols as keys
-        job.provider_job_id = Sidekiq::Client.push \
-          "class"   => JobWrapper,
-          "wrapped" => job.class,
-          "queue"   => job.queue_name,
-          "args"    => [ job.serialize ]
+        job.provider_job_id = JobWrapper.set(
+          wrapped: job.class,
+          queue: job.queue_name
+        ).perform_async(job.serialize)
       end
 
       def enqueue_at(job, timestamp) # :nodoc:
-        job.provider_job_id = Sidekiq::Client.push \
-          "class"   => JobWrapper,
-          "wrapped" => job.class,
-          "queue"   => job.queue_name,
-          "args"    => [ job.serialize ],
-          "at"      => timestamp
+        job.provider_job_id = JobWrapper.set(
+          wrapped: job.class,
+          queue: job.queue_name,
+        ).perform_at(timestamp, job.serialize)
+      end
+
+      def enqueue_all(jobs) # :nodoc:
+        enqueued_count = 0
+        jobs.group_by(&:class).each do |job_class, same_class_jobs|
+          same_class_jobs.group_by(&:queue_name).each do |queue, same_class_and_queue_jobs|
+            immediate_jobs, scheduled_jobs = same_class_and_queue_jobs.partition { |job| job.scheduled_at.nil? }
+
+            if immediate_jobs.any?
+              jids = Sidekiq::Client.push_bulk(
+                "class" => JobWrapper,
+                "wrapped" => job_class,
+                "queue" => queue,
+                "args" => immediate_jobs.map { |job| [job.serialize] },
+              )
+              enqueued_count += jids.compact.size
+            end
+
+            if scheduled_jobs.any?
+              jids = Sidekiq::Client.push_bulk(
+                "class" => JobWrapper,
+                "wrapped" => job_class,
+                "queue" => queue,
+                "args" => scheduled_jobs.map { |job| [job.serialize] },
+                "at" => scheduled_jobs.map { |job| job.scheduled_at&.to_f }
+              )
+              enqueued_count += jids.compact.size
+            end
+          end
+        end
+        enqueued_count
       end
 
       class JobWrapper # :nodoc:

data/lib/active_job/queue_adapters/sneakers_adapter.rb

@@ -5,7 +5,7 @@ require "monitor"
 
 module ActiveJob
   module QueueAdapters
-    # == Sneakers adapter for Active Job
+    # = Sneakers adapter for Active Job
     #
     # A high-performance RabbitMQ background processing framework for Ruby.
     # Sneakers is being used in production for both I/O and CPU intensive
@@ -17,7 +17,7 @@ module ActiveJob
     # To use Sneakers set the queue_adapter config to +:sneakers+.
     #
     #   Rails.application.config.active_job.queue_adapter = :sneakers
-    class SneakersAdapter
+    class SneakersAdapter < AbstractAdapter
       def initialize
         @monitor = Monitor.new
       end

data/lib/active_job/queue_adapters/sucker_punch_adapter.rb

@@ -4,20 +4,20 @@ require "sucker_punch"
 
 module ActiveJob
   module QueueAdapters
-    # == Sucker Punch adapter for Active Job
+    # = Sucker Punch adapter for Active Job
     #
     # Sucker Punch is a single-process Ruby asynchronous processing library.
     # 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 (e.g. Rails, Sinatra, etc.) process.
+    # single application (e.g. \Rails, Sinatra, etc.) process.
     #
     # Read more about Sucker Punch {here}[https://github.com/brandonhilkert/sucker_punch].
     #
     # To use Sucker Punch set the queue_adapter config to +:sucker_punch+.
     #
     #   Rails.application.config.active_job.queue_adapter = :sucker_punch
-    class SuckerPunchAdapter
+    class SuckerPunchAdapter < AbstractAdapter
       def enqueue(job) # :nodoc:
         if JobWrapper.respond_to?(:perform_async)
           # sucker_punch 2.0 API
@@ -33,7 +33,7 @@ module ActiveJob
           delay = timestamp - Time.current.to_f
           JobWrapper.perform_in delay, job.serialize
         else
-          raise NotImplementedError, "sucker_punch 1.0 does not support `enqueued_at`. Please upgrade to version ~> 2.0.0 to enable this behavior."
+          raise NotImplementedError, "sucker_punch 1.0 does not support `enqueue_at`. Please upgrade to version ~> 2.0.0 to enable this behavior."
         end
       end
 

data/lib/active_job/queue_adapters/test_adapter.rb

@@ -2,19 +2,27 @@
 
 module ActiveJob
   module QueueAdapters
-    # == Test adapter for Active Job
+    # = Test adapter for Active Job
     #
     # The test adapter should be used only in testing. Along with
     # ActiveJob::TestCase and ActiveJob::TestHelper
-    # it makes a great tool to test your Rails application.
+    # it makes a great tool to test your \Rails application.
     #
     # To use the test adapter set +queue_adapter+ config to +:test+.
     #
     #   Rails.application.config.active_job.queue_adapter = :test
-    class TestAdapter
-      attr_accessor(:perform_enqueued_jobs, :perform_enqueued_at_jobs, :filter, :reject, :queue, :at)
+    class TestAdapter < AbstractAdapter
+      attr_accessor(:perform_enqueued_jobs, :perform_enqueued_at_jobs, :filter, :reject, :queue, :at, :enqueue_after_transaction_commit)
       attr_writer(:enqueued_jobs, :performed_jobs)
 
+      def initialize(enqueue_after_transaction_commit: true)
+        @enqueue_after_transaction_commit = enqueue_after_transaction_commit
+      end
+
+      def enqueue_after_transaction_commit? # :nodoc:
+        @enqueue_after_transaction_commit
+      end
+
       # Provides a store of all the enqueued jobs with the TestAdapter so you can check them.
       def enqueued_jobs
         @enqueued_jobs ||= []
@@ -59,7 +67,7 @@ module ActiveJob
         end
 
         def filtered_time?(job)
-          job.scheduled_at > at.to_f if at && job.scheduled_at
+          job.scheduled_at > at if at && job.scheduled_at
         end
 
         def filtered_queue?(job)

data/lib/active_job/queue_adapters.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveJob
-  # == Active Job adapters
+  # = Active Job adapters
   #
   # Active Job has adapters for the following queuing backends:
   #
@@ -13,10 +13,14 @@ module ActiveJob
   # * {Sidekiq}[https://sidekiq.org]
   # * {Sneakers}[https://github.com/jondot/sneakers]
   # * {Sucker Punch}[https://github.com/brandonhilkert/sucker_punch]
-  # * {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.
   #
+  # For testing and development Active Job has three built-in adapters:
+  #
+  # * {Active Job Async}[https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters/AsyncAdapter.html]
+  # * {Active Job Inline}[https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]
+  # * {Active Job Test}[https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters/TestAdapter.html]
+  #
   # === Backends Features
   #
   #   |                   | Async | Queues | Delayed    | Priorities | Timeout | Retries |
@@ -31,6 +35,7 @@ module ActiveJob
   #   | Sucker Punch      | Yes   | Yes    | Yes        | No         | No      | No      |
   #   | Active Job Async  | Yes   | Yes    | Yes        | No         | No      | No      |
   #   | Active Job Inline | No    | Yes    | N/A        | N/A        | N/A     | N/A     |
+  #   | Active Job Test   | No    | Yes    | N/A        | N/A        | N/A     | N/A     |
   #
   # ==== Async
   #
@@ -106,13 +111,10 @@ module ActiveJob
   # N/A: The adapter does not run in a separate process, and therefore doesn't
   # support retries.
   #
-  # === Async and Inline Queue Adapters
-  #
-  # Active Job has two built-in queue adapters intended for development and
-  # testing: +:async+ and +:inline+.
   module QueueAdapters
     extend ActiveSupport::Autoload
 
+    autoload :AbstractAdapter
     autoload :AsyncAdapter
     autoload :InlineAdapter
     autoload :BackburnerAdapter

data/lib/active_job/queue_priority.rb

@@ -18,7 +18,24 @@ module ActiveJob
       #     end
       #   end
       #
-      # Specify either an argument or a block.
+      # Can be given a block that will evaluate in the context of the job
+      # so that a dynamic priority can be applied:
+      #
+      #   class PublishToFeedJob < ApplicationJob
+      #     queue_with_priority do
+      #       post = self.arguments.first
+      #
+      #       if post.paid?
+      #         10
+      #       else
+      #         50
+      #       end
+      #     end
+      #
+      #     def perform(post)
+      #       post.to_feed!
+      #     end
+      #   end
       def queue_with_priority(priority = nil, &block)
         if block_given?
           self.priority = block

data/lib/active_job/railtie.rb

@@ -10,6 +10,10 @@ module ActiveJob
     config.active_job.custom_serializers = []
     config.active_job.log_query_tags_around_perform = true
 
+    initializer "active_job.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:active_job] = ActiveJob.deprecator
+    end
+
     initializer "active_job.logger" do
       ActiveSupport.on_load(:active_job) { self.logger = ::Rails.logger }
     end
@@ -21,9 +25,30 @@ module ActiveJob
       end
     end
 
+    initializer "active_job.enqueue_after_transaction_commit" do |app|
+      ActiveSupport.on_load(:active_job) do
+        ActiveSupport.on_load(:active_record) do
+          ActiveJob::Base.include EnqueueAfterTransactionCommit
+
+          if app.config.active_job.key?(:enqueue_after_transaction_commit)
+            ActiveJob::Base.enqueue_after_transaction_commit = app.config.active_job.delete(:enqueue_after_transaction_commit)
+          end
+        end
+      end
+    end
+
     initializer "active_job.set_configs" do |app|
       options = app.config.active_job
-      options.queue_adapter ||= :async
+      options.queue_adapter ||= (Rails.env.test? ? :test : :async)
+
+      config.after_initialize do
+        options.each do |k, v|
+          k = "#{k}="
+          if ActiveJob.respond_to?(k)
+            ActiveJob.send(k, v)
+          end
+        end
+      end
 
       ActiveSupport.on_load(:active_job) do
         # Configs used in other initializers
@@ -32,19 +57,19 @@ module ActiveJob
           :custom_serializers
         )
 
-        options.each do  |k, v|
+        options.each do |k, v|
           k = "#{k}="
-          send(k, v) if respond_to? k
+          if ActiveJob.respond_to?(k)
+            ActiveJob.send(k, v)
+          elsif respond_to? k
+            send(k, v)
+          end
         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
 
     initializer "active_job.set_reloader_hook" do |app|
@@ -70,5 +95,11 @@ module ActiveJob
         end
       end
     end
+
+    initializer "active_job.backtrace_cleaner" do
+      ActiveSupport.on_load(:active_job) do
+        LogSubscriber.backtrace_cleaner = ::Rails.backtrace_cleaner
+      end
+    end
   end
 end

data/lib/active_job/serializers/big_decimal_serializer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module ActiveJob
+  module Serializers
+    class BigDecimalSerializer < ObjectSerializer # :nodoc:
+      def serialize(big_decimal)
+        super("value" => big_decimal.to_s)
+      end
+
+      def deserialize(hash)
+        BigDecimal(hash["value"])
+      end
+
+      private
+        def klass
+          BigDecimal
+        end
+    end
+  end
+end

data/lib/active_job/serializers/duration_serializer.rb

@@ -4,14 +4,16 @@ module ActiveJob
   module Serializers
     class DurationSerializer < ObjectSerializer # :nodoc:
       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))
       end
 
       def deserialize(hash)
         value = hash["value"]
         parts = Arguments.deserialize(hash["parts"])
-
-        klass.new(value, parts)
+        # `parts` is originally a hash, but will have been flattened to an array by Arguments.serialize
+        klass.new(value, parts.to_h)
       end
 
       private

data/lib/active_job/serializers/object_serializer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "singleton"
+
 module ActiveJob
   module Serializers
     # Base class for serializing and deserializing custom objects.

data/lib/active_job/serializers/time_with_zone_serializer.rb

@@ -2,9 +2,18 @@
 
 module ActiveJob
   module Serializers
-    class TimeWithZoneSerializer < TimeObjectSerializer # :nodoc:
+    class TimeWithZoneSerializer < ObjectSerializer # :nodoc:
+      NANO_PRECISION = 9
+
+      def serialize(time_with_zone)
+        super(
+          "value" => time_with_zone.iso8601(NANO_PRECISION),
+          "time_zone" => time_with_zone.time_zone.tzinfo.name
+        )
+      end
+
       def deserialize(hash)
-        Time.iso8601(hash["value"]).in_time_zone
+        Time.iso8601(hash["value"]).in_time_zone(hash["time_zone"] || Time.zone)
       end
 
       private

data/lib/active_job/serializers.rb

@@ -3,7 +3,9 @@
 require "set"
 
 module ActiveJob
-  # The <tt>ActiveJob::Serializers</tt> module is used to store a list of known serializers
+  # = Active Job \Serializers
+  #
+  # The +ActiveJob::Serializers+ 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
@@ -18,6 +20,7 @@ module ActiveJob
     autoload :TimeSerializer
     autoload :ModuleSerializer
     autoload :RangeSerializer
+    autoload :BigDecimalSerializer
 
     mattr_accessor :_additional_serializers
     self._additional_serializers = Set.new
@@ -25,7 +28,7 @@ module ActiveJob
     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.
+      # Raises ActiveJob::SerializationError 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
@@ -63,6 +66,7 @@ module ActiveJob
       TimeWithZoneSerializer,
       TimeSerializer,
       ModuleSerializer,
-      RangeSerializer
+      RangeSerializer,
+      BigDecimalSerializer
   end
 end

data/lib/active_job/test_helper.rb

@@ -34,13 +34,18 @@ module ActiveJob
       end
     end
 
-    ActiveJob::Base.include(TestQueueAdapter)
+    ActiveSupport.on_load(:active_job) do
+      ActiveJob::Base.include(TestQueueAdapter)
+    end
 
     def before_setup # :nodoc:
-      test_adapter = queue_adapter_for_test
-
+      queue_adapter_specific_to_this_test_class = queue_adapter_for_test
       queue_adapter_changed_jobs.each do |klass|
-        klass.enable_test_adapter(test_adapter)
+        if queue_adapter_specific_to_this_test_class
+          klass.enable_test_adapter(queue_adapter_specific_to_this_test_class)
+        elsif klass._queue_adapter.nil?
+          klass.enable_test_adapter(ActiveJob::QueueAdapters::TestAdapter.new)
+        end
       end
 
       clear_enqueued_jobs
@@ -54,17 +59,11 @@ module ActiveJob
       queue_adapter_changed_jobs.each { |klass| klass.disable_test_adapter }
     end
 
-    # Specifies the queue adapter to use with all Active Job test helpers.
-    #
-    # Returns an instance of the queue adapter and defaults to
-    # ActiveJob::QueueAdapters::TestAdapter.
-    #
-    # Note: The adapter provided by this method must provide some additional
-    # methods from those expected of a standard ActiveJob::QueueAdapter
-    # in order to be used with the active job test helpers. Refer to
-    # ActiveJob::QueueAdapters::TestAdapter.
+    # Returns a queue adapter instance to use with all Active Job test helpers.
+    # By default, returns an instance of ActiveJob::QueueAdapters::TestAdapter.
+    # Override this method to specify a different adapter. The adapter must
+    # implement the same interface as ActiveJob::QueueAdapters::TestAdapter.
     def queue_adapter_for_test
-      ActiveJob::QueueAdapters::TestAdapter.new
     end
 
     # Asserts that the number of enqueued jobs matches the given number.
@@ -121,6 +120,8 @@ module ActiveJob
     #     end
     #   end
     def assert_enqueued_jobs(number, only: nil, except: nil, queue: nil, &block)
+      require_active_job_test_adapter!("assert_enqueued_jobs")
+
       if block_given?
         original_jobs = enqueued_jobs_with(only: only, except: except, queue: queue)
 
@@ -183,6 +184,8 @@ module ActiveJob
     #
     #   assert_enqueued_jobs 0, &block
     def assert_no_enqueued_jobs(only: nil, except: nil, queue: nil, &block)
+      require_active_job_test_adapter!("assert_no_enqueued_jobs")
+
       assert_enqueued_jobs 0, only: only, except: except, queue: queue, &block
     end
 
@@ -273,6 +276,8 @@ module ActiveJob
     #       end
     #     end
     def assert_performed_jobs(number, only: nil, except: nil, queue: nil, &block)
+      require_active_job_test_adapter!("assert_performed_jobs")
+
       if block_given?
         original_count = performed_jobs.size
 
@@ -341,6 +346,8 @@ module ActiveJob
     #
     #   assert_performed_jobs 0, &block
     def assert_no_performed_jobs(only: nil, except: nil, queue: nil, &block)
+      require_active_job_test_adapter!("assert_no_performed_jobs")
+
       assert_performed_jobs 0, only: only, except: except, queue: queue, &block
     end
 
@@ -354,6 +361,13 @@ module ActiveJob
     #     assert_enqueued_with(at: Date.tomorrow.noon, queue: "my_queue")
     #   end
     #
+    # For keyword arguments, specify them as a hash inside an array:
+    #
+    #   def test_assert_enqueued_with_keyword_arguments
+    #     MyJob.perform_later(arg1: 'value1', arg2: 'value2')
+    #     assert_enqueued_with(job: MyJob, args: [{ arg1: 'value1', arg2: 'value2' }])
+    #   end
+    #
     # The given arguments may also be specified as matcher procs that return a
     # boolean value indicating whether a job's attribute meets certain criteria.
     #
@@ -390,6 +404,8 @@ module ActiveJob
     #     end
     #   end
     def assert_enqueued_with(job: nil, args: nil, at: nil, queue: nil, priority: nil, &block)
+      require_active_job_test_adapter!("assert_enqueued_with")
+
       expected = { job: job, args: args, at: at, queue: queue, priority: priority }.compact
       expected_args = prepare_args_for_assertion(expected)
       potential_matches = []
@@ -492,6 +508,8 @@ module ActiveJob
     #     end
     #   end
     def assert_performed_with(job: nil, args: nil, at: nil, queue: nil, priority: nil, &block)
+      require_active_job_test_adapter!("assert_performed_with")
+
       expected = { job: job, args: args, at: at, queue: queue, priority: priority }.compact
       expected_args = prepare_args_for_assertion(expected)
       potential_matches = []
@@ -593,10 +611,19 @@ module ActiveJob
     #     assert_performed_jobs 1
     #   end
     #
-    # If the +:at+ option is specified, then only run jobs enqueued to run
-    # immediately or before the given time
+    # If the +:at+ option is specified, then only jobs that have been enqueued
+    # to run at or before the given time will be performed. This includes jobs
+    # that have been enqueued without a time.
+    #
+    # If queue_adapter_for_test is overridden to return a different adapter,
+    # +perform_enqueued_jobs+ will merely execute the block.
     def perform_enqueued_jobs(only: nil, except: nil, queue: nil, at: nil, &block)
-      return flush_enqueued_jobs(only: only, except: except, queue: queue, at: at) unless block_given?
+      unless block_given?
+        require_active_job_test_adapter!("perform_enqueued_jobs (without a block)")
+        return flush_enqueued_jobs(only: only, except: except, queue: queue, at: at)
+      end
+
+      return _assert_nothing_raised_or_warn("perform_enqueued_jobs", &block) unless using_test_adapter?
 
       validate_option(only: only, except: except)
 
@@ -636,12 +663,22 @@ module ActiveJob
     end
 
     private
+      def require_active_job_test_adapter!(method)
+        unless using_test_adapter?
+          raise ArgumentError.new("#{method} requires the Active Job test adapter, you're using #{queue_adapter.class.name}.")
+        end
+      end
+
+      def using_test_adapter?
+        queue_adapter.is_a?(ActiveJob::QueueAdapters::TestAdapter)
+      end
+
       def clear_enqueued_jobs
-        enqueued_jobs.clear
+        enqueued_jobs.clear if using_test_adapter?
       end
 
       def clear_performed_jobs
-        performed_jobs.clear
+        performed_jobs.clear if using_test_adapter?
       end
 
       def jobs_with(jobs, only: nil, except: nil, queue: nil, at: nil)
@@ -694,6 +731,10 @@ module ActiveJob
 
       def prepare_args_for_assertion(args)
         args.dup.tap do |arguments|
+          if arguments[:queue].is_a?(Symbol)
+            arguments[:queue] = arguments[:queue].to_s
+          end
+
           if arguments[:at].acts_like?(:time)
             at_range = arguments[:at] - 1..arguments[:at] + 1
             arguments[:at] = ->(at) { at_range.cover?(at) }

data/lib/active_job/version.rb

@@ -3,7 +3,7 @@
 require_relative "gem_version"
 
 module ActiveJob
-  # Returns the currently loaded version of Active Job as a <tt>Gem::Version</tt>.
+  # Returns the currently loaded version of Active Job as a +Gem::Version+.
   def self.version
     gem_version
   end

data/lib/active_job.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #--
-# Copyright (c) 2014-2022 David Heinemeier Hansson
+# Copyright (c) David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -26,16 +26,46 @@
 require "active_support"
 require "active_support/rails"
 require "active_job/version"
+require "active_job/deprecator"
 require "global_id"
 
+# :markup: markdown
+# :include: ../README.md
 module ActiveJob
   extend ActiveSupport::Autoload
 
   autoload :Base
   autoload :QueueAdapters
-  autoload :Serializers
-  autoload :ConfiguredJob
+  autoload :Arguments
+  autoload :DeserializationError, "active_job/arguments"
+  autoload :SerializationError, "active_job/arguments"
+  autoload :EnqueueAfterTransactionCommit
+
+  eager_autoload do
+    autoload :Serializers
+    autoload :ConfiguredJob
+  end
+
   autoload :TestCase
   autoload :TestHelper
-  autoload :QueryTags
+
+  def self.use_big_decimal_serializer
+    ActiveJob.deprecator.warn <<-WARNING.squish
+      Rails.application.config.active_job.use_big_decimal_serializer is deprecated and will be removed in Rails 8.0.
+    WARNING
+  end
+
+  def self.use_big_decimal_serializer=(value)
+    ActiveJob.deprecator.warn <<-WARNING.squish
+      Rails.application.config.active_job.use_big_decimal_serializer is deprecated and will be removed in Rails 8.0.
+    WARNING
+  end
+
+  ##
+  # :singleton-method: verbose_enqueue_logs
+  #
+  # Specifies if the methods calling background job enqueue should be logged below
+  # their relevant enqueue log lines. Defaults to false.
+  singleton_class.attr_accessor :verbose_enqueue_logs
+  self.verbose_enqueue_logs = false
 end