activejob 7.1.5.2 → 8.1.2.1

data/lib/active_job/core.rb

@@ -1,6 +1,13 @@
 # frozen_string_literal: true
 
 module ActiveJob
+  # Raised during job payload deserialization when it references an uninitialized job class.
+  class UnknownJobClassError < NameError
+    def initialize(job_class_name)
+      super("Failed to instantiate job, class `#{job_class_name}` doesn't exist", job_class_name)
+    end
+  end
+
   # = Active Job \Core
   #
   # Provides general behavior that will be included into every Active Job
@@ -13,9 +20,7 @@ module ActiveJob
     attr_writer :serialized_arguments
 
     # Time when the job should be performed
-    attr_reader :scheduled_at
-
-    attr_reader :_scheduled_at_time # :nodoc:
+    attr_accessor :scheduled_at
 
     # Job Identifier
     attr_accessor :job_id
@@ -62,7 +67,10 @@ module ActiveJob
     module ClassMethods
       # Creates a new job instance from a hash created with +serialize+
       def deserialize(job_data)
-        job = job_data["job_class"].constantize.new
+        job_class = job_data["job_class"].safe_constantize
+        raise UnknownJobClassError, job_data["job_class"] unless job_class
+
+        job = job_class.new
         job.deserialize(job_data)
         job
       end
@@ -97,7 +105,6 @@ module ActiveJob
       @job_id     = SecureRandom.uuid
       @queue_name = self.class.queue_name
       @scheduled_at = nil
-      @_scheduled_at_time = nil
       @priority   = self.class.priority
       @executions = 0
       @exception_executions = {}
@@ -117,10 +124,10 @@ module ActiveJob
         "arguments"  => serialize_arguments_if_needed(arguments),
         "executions" => executions,
         "exception_executions" => exception_executions,
-        "locale"     => I18n.locale.to_s,
+        "locale"     => locale || I18n.locale.to_s,
         "timezone"   => timezone,
         "enqueued_at" => Time.now.utc.iso8601(9),
-        "scheduled_at" => _scheduled_at_time ? _scheduled_at_time.utc.iso8601(9) : nil,
+        "scheduled_at" => scheduled_at ? scheduled_at.utc.iso8601(9) : nil,
       }
     end
 
@@ -160,8 +167,8 @@ module ActiveJob
       self.exception_executions = job_data["exception_executions"]
       self.locale               = job_data["locale"] || I18n.locale.to_s
       self.timezone             = job_data["timezone"] || Time.zone&.name
-      self.enqueued_at          = Time.iso8601(job_data["enqueued_at"]) if job_data["enqueued_at"]
-      self.scheduled_at         = Time.iso8601(job_data["scheduled_at"]) if job_data["scheduled_at"]
+      self.enqueued_at          = deserialize_time(job_data["enqueued_at"]) if job_data["enqueued_at"]
+      self.scheduled_at         = deserialize_time(job_data["scheduled_at"]) if job_data["scheduled_at"]
     end
 
     # Configures the job with the given options.
@@ -174,18 +181,6 @@ module ActiveJob
       self
     end
 
-    def scheduled_at=(value)
-      @_scheduled_at_time = if value&.is_a?(Numeric)
-        ActiveJob.deprecator.warn(<<~MSG.squish)
-          Assigning a numeric/epoch value to scheduled_at is deprecated. Use a Time object instead.
-        MSG
-        Time.at(value)
-      else
-        value
-      end
-      @scheduled_at = value
-    end
-
     private
       def serialize_arguments_if_needed(arguments)
         if arguments_serialized?
@@ -211,7 +206,15 @@ module ActiveJob
       end
 
       def arguments_serialized?
-        defined?(@serialized_arguments) && @serialized_arguments
+        @serialized_arguments
+      end
+
+      def deserialize_time(time)
+        if time.is_a?(Time)
+          time
+        else
+          Time.iso8601(time)
+        end
       end
   end
 end

data/lib/active_job/enqueue_after_transaction_commit.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module EnqueueAfterTransactionCommit # :nodoc:
+    class << self
+      def included(base)
+        ActiveJob.singleton_class.prepend(ActiveJobMethods)
+      end
+    end
+
+    module ActiveJobMethods
+      # Ensures perform_all_later respects each job's enqueue_after_transaction_commit configuration.
+      # Jobs with enqueue_after_transaction_commit set to true are deferred and enqueued only after the transaction commits;
+      # other jobs are enqueued immediately. This ensures enqueuing timing matches the per-job setting.
+      def perform_all_later(*jobs)
+        jobs.flatten!
+        deferred_jobs, immediate_jobs = jobs.partition { |job| job.class.enqueue_after_transaction_commit }
+        super(immediate_jobs) if immediate_jobs.any?
+        ActiveRecord.after_all_transactions_commit { super(deferred_jobs) } if deferred_jobs.any?
+        nil
+      end
+    end
+
+    private
+      def raw_enqueue
+        if self.class.enqueue_after_transaction_commit
+          self.successfully_enqueued = true
+          ActiveRecord.after_all_transactions_commit do
+            self.successfully_enqueued = false
+            super
+          end
+          self
+        else
+          super
+        end
+      end
+  end
+end

data/lib/active_job/enqueuing.rb

@@ -21,7 +21,7 @@ module ActiveJob
             adapter_jobs.each do |job|
               job.successfully_enqueued = false
               if job.scheduled_at
-                queue_adapter.enqueue_at(job, job._scheduled_at_time.to_f)
+                queue_adapter.enqueue_at(job, job.scheduled_at.to_f)
               else
                 queue_adapter.enqueue(job)
               end
@@ -40,6 +40,19 @@ module ActiveJob
   module Enqueuing
     extend ActiveSupport::Concern
 
+    included do
+      ##
+      # :singleton-method:
+      #
+      # Defines if enqueueing this job from inside an Active Record transaction
+      # automatically defers the enqueue to after the transaction commits.
+      #
+      # It can be set on a per job basis:
+      #  - true forces the job to be deferred.
+      #  - false forces the job to be queued immediately.
+      class_attribute :enqueue_after_transaction_commit, instance_accessor: false, instance_predicate: false, default: false
+    end
+
     # Includes the +perform_later+ method for job initialization.
     module ClassMethods
       # Push a job onto the queue. By default the arguments must be either String,
@@ -50,9 +63,21 @@ module ActiveJob
       # custom serializers.
       #
       # Returns an instance of the job class queued with arguments available in
-      # Job#arguments or false if the enqueue did not succeed.
+      # Job#arguments or +false+ if the enqueue did not succeed.
       #
       # After the attempted enqueue, the job will be yielded to an optional block.
+      #
+      # If Active Job is used conjointly with Active Record, and #perform_later is called
+      # inside an Active Record transaction, then the enqueue is implicitly deferred to after
+      # the transaction is committed, or dropped if it's rolled back. In such case #perform_later
+      # will return the job instance like if it was successfully enqueued, but will still return
+      # +false+ if a callback prevented the job from being enqueued.
+      #
+      # This behavior can be changed on a per job basis:
+      #
+      #  class NotificationJob < ApplicationJob
+      #    self.enqueue_after_transaction_commit = false
+      #  end
       def perform_later(...)
         job = job_or_instantiate(...)
         enqueue_result = job.enqueue
@@ -63,7 +88,7 @@ module ActiveJob
       end
 
       private
-        def job_or_instantiate(*args) # :doc:
+        def job_or_instantiate(*args, &) # :doc:
           args.first.is_a?(self) ? args.first : new(*args)
         end
         ruby2_keywords(:job_or_instantiate)
@@ -88,9 +113,25 @@ module ActiveJob
       set(options)
       self.successfully_enqueued = false
 
-      run_callbacks :enqueue do
+      raw_enqueue
+
+      if successfully_enqueued?
+        self
+      else
+        false
+      end
+    end
+
+    private
+      def raw_enqueue
+        run_callbacks :enqueue do
+          _raw_enqueue
+        end
+      end
+
+      def _raw_enqueue
         if scheduled_at
-          queue_adapter.enqueue_at self, _scheduled_at_time.to_f
+          queue_adapter.enqueue_at self, scheduled_at.to_f
         else
           queue_adapter.enqueue self
         end
@@ -99,12 +140,5 @@ module ActiveJob
       rescue EnqueueError => e
         self.enqueue_error = e
       end
-
-      if successfully_enqueued?
-        self
-      else
-        false
-      end
-    end
   end
 end

data/lib/active_job/exceptions.rb

@@ -21,7 +21,7 @@ module ActiveJob
       # You can also pass a block that'll be invoked if the retry attempts fail for custom logic rather than letting
       # the exception bubble up. This block is yielded with the job instance as the first and the error instance as the second parameter.
       #
-      # `retry_on` and `discard_on` handlers are searched from bottom to top, and up the class hierarchy. The handler of the first class for
+      # +retry_on+ and +discard_on+ handlers are searched from bottom to top, and up the class hierarchy. The handler of the first class for
       # which <tt>exception.is_a?(klass)</tt> holds true is the one invoked, if any.
       #
       # ==== Options
@@ -29,11 +29,12 @@ module ActiveJob
       #   as a computing proc that takes the number of executions so far as an argument, or as a symbol reference of
       #   <tt>:polynomially_longer</tt>, which applies the wait algorithm of <tt>((executions**4) + (Kernel.rand * (executions**4) * jitter)) + 2</tt>
       #   (first wait ~3s, then ~18s, then ~83s, etc)
-      # * <tt>:attempts</tt> - Re-enqueues the job the specified number of times (default: 5 attempts) or a symbol reference of <tt>:unlimited</tt>
-      #   to retry the job until it succeeds
+      # * <tt>:attempts</tt> - Enqueues the job the specified number of times (default: 5 attempts) or a symbol reference of <tt>:unlimited</tt>
+      #   to retry the job until it succeeds. The number of attempts includes the original job execution.
       # * <tt>:queue</tt> - Re-enqueues the job on a different queue
       # * <tt>:priority</tt> - Re-enqueues the job with a different priority
       # * <tt>:jitter</tt> - A random delay of wait time used when calculating backoff. The default is 15% (0.15) which represents the upper bound of possible wait time (expressed as a percentage)
+      # * <tt>:report</tt> - Errors will be reported to the Rails.error reporter before being retried
       #
       # ==== Examples
       #
@@ -49,8 +50,9 @@ module ActiveJob
       #    # retry_on Net::ReadTimeout, wait: 5.seconds, jitter: 0.30, attempts: 10
       #    # retry_on Timeout::Error, wait: :polynomially_longer, attempts: 10
       #
-      #    retry_on(YetAnotherCustomAppException) do |job, error|
-      #      ExceptionNotifier.caught(error)
+      #    retry_on YetAnotherCustomAppException, report: true
+      #    retry_on EvenWorseCustomAppException do |job, error|
+      #      CustomErrorHandlingCode.handle(job, error)
       #    end
       #
       #    def perform(*args)
@@ -59,16 +61,11 @@ module ActiveJob
       #      # Might raise Net::OpenTimeout or Timeout::Error when the remote service is down
       #    end
       #  end
-      def retry_on(*exceptions, wait: 3.seconds, attempts: 5, queue: nil, priority: nil, jitter: JITTER_DEFAULT)
-        if wait == :exponentially_longer
-          ActiveJob.deprecator.warn(<<~MSG.squish)
-            `wait: :exponentially_longer` will actually wait polynomially longer and is therefore deprecated.
-            Prefer `wait: :polynomially_longer` to avoid confusion and keep the same behavior.
-          MSG
-        end
+      def retry_on(*exceptions, wait: 3.seconds, attempts: 5, queue: nil, priority: nil, jitter: JITTER_DEFAULT, report: false)
         rescue_from(*exceptions) do |error|
           executions = executions_for(exceptions)
           if attempts == :unlimited || executions < attempts
+            ActiveSupport.error_reporter.report(error, source: "application.active_job") if report
             retry_job wait: determine_delay(seconds_or_duration_or_algorithm: wait, executions: executions, jitter: jitter), queue: queue, priority: priority, error: error
           else
             if block_given?
@@ -88,17 +85,20 @@ module ActiveJob
       # Discard the job with no attempts to retry, if the exception is raised. This is useful when the subject of the job,
       # like an Active Record, is no longer available, and the job is thus no longer relevant.
       #
+      # Passing the <tt>:report</tt> option reports the error through the error reporter before discarding the job.
+      #
       # You can also pass a block that'll be invoked. This block is yielded with the job instance as the first and the error instance as the second parameter.
       #
-      # `retry_on` and `discard_on` handlers are searched from bottom to top, and up the class hierarchy. The handler of the first class for
+      # +retry_on+ and +discard_on+ handlers are searched from bottom to top, and up the class hierarchy. The handler of the first class for
       # which <tt>exception.is_a?(klass)</tt> holds true is the one invoked, if any.
       #
       # ==== Example
       #
       #  class SearchIndexingJob < ActiveJob::Base
       #    discard_on ActiveJob::DeserializationError
-      #    discard_on(CustomAppException) do |job, error|
-      #      ExceptionNotifier.caught(error)
+      #    discard_on CustomAppException, report: true
+      #    discard_on(AnotherCustomAppException) do |job, error|
+      #      CustomErrorHandlingCode.handle(job, error)
       #    end
       #
       #    def perform(record)
@@ -106,9 +106,10 @@ module ActiveJob
       #      # Might raise CustomAppException for something domain specific
       #    end
       #  end
-      def discard_on(*exceptions)
+      def discard_on(*exceptions, report: false)
         rescue_from(*exceptions) do |error|
           instrument :discard, error: error do
+            ActiveSupport.error_reporter.report(error, source: "application.active_job") if report
             yield self, error if block_given?
             run_after_discard_procs(error)
           end
@@ -156,7 +157,10 @@ module ActiveJob
     #  end
     def retry_job(options = {})
       instrument :enqueue_retry, options.slice(:error, :wait) do
+        scheduled_at, queue_name, priority = self.scheduled_at, self.queue_name, self.priority
         enqueue options
+      ensure
+        self.scheduled_at, self.queue_name, self.priority = scheduled_at, queue_name, priority
       end
     end
 
@@ -168,7 +172,7 @@ module ActiveJob
         jitter = jitter == JITTER_DEFAULT ? self.class.retry_jitter : (jitter || 0.0)
 
         case seconds_or_duration_or_algorithm
-        when :exponentially_longer, :polynomially_longer
+        when  :polynomially_longer
           # This delay uses a polynomial backoff strategy, which was previously misnamed as exponential
           delay = executions**4
           delay_jitter = determine_jitter_for_delay(delay, jitter)

data/lib/active_job/execution_state.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module ExecutionState # :nodoc:
+    def perform_now
+      I18n.with_locale(locale) do
+        Time.use_zone(timezone) { super }
+      end
+    end
+  end
+end

data/lib/active_job/gem_version.rb

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

data/lib/active_job/instrumentation.rb

@@ -26,24 +26,24 @@ module ActiveJob
       instrument(:perform) { super }
     end
 
+    def instrument(operation, payload = {}, &block) # :nodoc:
+      payload[:job] = self
+      payload[:adapter] = queue_adapter
+
+      ActiveSupport::Notifications.instrument("#{operation}.active_job", payload) do |payload|
+        value = block.call(payload) if block
+        payload[:aborted] = @_halted_callback_hook_called if defined?(@_halted_callback_hook_called)
+        @_halted_callback_hook_called = nil
+        value
+      end
+    end
+
     private
       def _perform_job
         instrument(:perform_start)
         super
       end
 
-      def instrument(operation, payload = {}, &block)
-        payload[:job] = self
-        payload[:adapter] = queue_adapter
-
-        ActiveSupport::Notifications.instrument("#{operation}.active_job", payload) do
-          value = block.call if block
-          payload[:aborted] = @_halted_callback_hook_called if defined?(@_halted_callback_hook_called)
-          @_halted_callback_hook_called = nil
-          value
-        end
-      end
-
       def halted_callback_hook(*)
         super
         @_halted_callback_hook_called = true

data/lib/active_job/log_subscriber.rb

@@ -50,7 +50,7 @@ module ActiveJob
       info do
         jobs = event.payload[:jobs]
         adapter = event.payload[:adapter]
-        enqueued_count = event.payload[:enqueued_count]
+        enqueued_count = event.payload[:enqueued_count].to_i
 
         if enqueued_count == jobs.size
           enqueued_jobs_message(adapter, jobs)
@@ -87,8 +87,9 @@ module ActiveJob
       job = event.payload[:job]
       ex = event.payload[:exception_object]
       if ex
+        cleaned_backtrace = backtrace_cleaner.clean(ex.backtrace)
         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")
+          "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(cleaned_backtrace).join("\n")
         end
       elsif event.payload[:aborted]
         error do
@@ -125,7 +126,7 @@ module ActiveJob
         "Stopped retrying #{job.class} (Job ID: #{job.job_id}) due to a #{ex.class} (#{ex.message}), which reoccurred on #{job.executions} attempts."
       end
     end
-    subscribe_log_level :enqueue_retry, :error
+    subscribe_log_level :retry_stopped, :error
 
     def discard(event)
       job = event.payload[:job]
@@ -137,6 +138,64 @@ module ActiveJob
     end
     subscribe_log_level :discard, :error
 
+    def interrupt(event)
+      job = event.payload[:job]
+      info do
+        "Interrupted #{job.class} (Job ID: #{job.job_id}) #{event.payload[:description]} (#{event.payload[:reason]})"
+      end
+    end
+    subscribe_log_level :interrupt, :info
+
+    def resume(event)
+      job = event.payload[:job]
+      info do
+        "Resuming #{job.class} (Job ID: #{job.job_id}) #{event.payload[:description]}"
+      end
+    end
+    subscribe_log_level :resume, :info
+
+    def step_skipped(event)
+      job = event.payload[:job]
+      info do
+        "Step '#{event.payload[:step].name}' skipped #{job.class}"
+      end
+    end
+    subscribe_log_level :step_skipped, :info
+
+    def step_started(event)
+      job = event.payload[:job]
+      step = event.payload[:step]
+      info do
+        if step.resumed?
+          "Step '#{step.name}' resumed from cursor '#{step.cursor}' for #{job.class} (Job ID: #{job.job_id})"
+        else
+          "Step '#{step.name}' started for #{job.class} (Job ID: #{job.job_id})"
+        end
+      end
+    end
+    subscribe_log_level :step_started, :info
+
+    def step(event)
+      job = event.payload[:job]
+      step = event.payload[:step]
+      ex = event.payload[:exception_object]
+
+      if event.payload[:interrupted]
+        info do
+          "Step '#{step.name}' interrupted at cursor '#{step.cursor}' for #{job.class} (Job ID: #{job.job_id}) in #{event.duration.round(2)}ms"
+        end
+      elsif ex
+        error do
+          "Error during step '#{step.name}' at cursor '#{step.cursor}' for #{job.class} (Job ID: #{job.job_id}) in #{event.duration.round(2)}ms: #{ex.class} (#{ex.message})"
+        end
+      else
+        info do
+          "Step '#{step.name}' completed for #{job.class} (Job ID: #{job.job_id}) in #{event.duration.round(2)}ms"
+        end
+      end
+    end
+    subscribe_log_level :step, :error
+
     private
       def queue_name(event)
         ActiveJob.adapter_name(event.payload[:adapter]) + "(#{event.payload[:job].queue_name})"
@@ -189,15 +248,15 @@ module ActiveJob
       end
 
       def log_enqueue_source
-        source = extract_enqueue_source_location(caller)
+        source = enqueue_source_location
 
         if source
           logger.info("↳ #{source}")
         end
       end
 
-      def extract_enqueue_source_location(locations)
-        backtrace_cleaner.clean(locations.lazy).first
+      def enqueue_source_location
+        backtrace_cleaner.first_clean_frame
       end
 
       def enqueued_jobs_message(adapter, enqueued_jobs)

data/lib/active_job/logging.rb

@@ -4,17 +4,31 @@ require "active_support/tagged_logging"
 require "active_support/logger"
 
 module ActiveJob
-  module Logging # :nodoc:
+  module Logging
     extend ActiveSupport::Concern
 
     included do
+      ##
+      # Accepts a logger conforming to the interface of Log4r or the default
+      # Ruby +Logger+ class. You can retrieve this logger by calling +logger+ on
+      # either an Active Job job class or an Active Job job instance.
       cattr_accessor :logger, default: ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT))
+
+      ##
+      # Configures whether a job's arguments should be logged. This can be
+      # useful when a job's arguments may be sensitive and so should not be
+      # logged.
+      #
+      # The value defaults to +true+, but this can be configured with
+      # +config.active_job.log_arguments+. Additionally, individual jobs can
+      # also configure a value, which will apply to themselves and any
+      # subclasses.
       class_attribute :log_arguments, instance_accessor: false, default: true
 
       around_enqueue(prepend: true) { |_, block| tag_logger(&block) }
     end
 
-    def perform_now
+    def perform_now # :nodoc:
       tag_logger(self.class.name, self.job_id) { super }
     end
 

data/lib/active_job/queue_adapter.rb

@@ -15,7 +15,8 @@ module ActiveJob
   # = Active Job Queue adapter
   #
   # The +ActiveJob::QueueAdapter+ module is used to load the
-  # correct adapter. The default queue adapter is the +:async+ queue.
+  # correct adapter. The default queue adapter is +:async+,
+  # which loads the ActiveJob::QueueAdapters::AsyncAdapter.
   module QueueAdapter # :nodoc:
     extend ActiveSupport::Concern
 
@@ -24,21 +25,21 @@ module ActiveJob
       class_attribute :_queue_adapter, instance_accessor: false, instance_predicate: false
 
       delegate :queue_adapter, to: :class
-
-      self.queue_adapter = :async
     end
 
     # Includes the setter method for changing the active queue adapter.
     module ClassMethods
       # Returns the backend queue provider. The default queue adapter
-      # is the +:async+ queue. See QueueAdapters for more information.
+      # is +:async+. See QueueAdapters for more information.
       def queue_adapter
+        self.queue_adapter = :async if _queue_adapter.nil?
         _queue_adapter
       end
 
       # Returns string denoting the name of the configured queue adapter.
       # By default returns <tt>"async"</tt>.
       def queue_adapter_name
+        self.queue_adapter = :async if _queue_adapter_name.nil?
         _queue_adapter_name
       end
 
@@ -49,6 +50,7 @@ module ActiveJob
         case name_or_adapter
         when Symbol, String
           queue_adapter = ActiveJob::QueueAdapters.lookup(name_or_adapter).new
+          queue_adapter.try(:check_adapter)
           assign_adapter(name_or_adapter.to_s, queue_adapter)
         else
           if queue_adapter?(name_or_adapter)

data/lib/active_job/queue_adapters/abstract_adapter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module QueueAdapters
+    # = Active Job Abstract Adapter
+    #
+    # Active Job supports multiple job queue systems. ActiveJob::QueueAdapters::AbstractAdapter
+    # forms the abstraction layer which makes this possible.
+    class AbstractAdapter
+      attr_accessor :stopping
+
+      def enqueue(job)
+        raise NotImplementedError
+      end
+
+      def enqueue_at(job, timestamp)
+        raise NotImplementedError
+      end
+
+      def stopping?
+        !!@stopping
+      end
+    end
+  end
+end

data/lib/active_job/queue_adapters/async_adapter.rb

@@ -30,7 +30,7 @@ module ActiveJob
     # The adapter uses a {Concurrent Ruby}[https://github.com/ruby-concurrency/concurrent-ruby] thread pool to schedule and execute
     # 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
+    class AsyncAdapter < AbstractAdapter
       # 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)
@@ -74,7 +74,7 @@ module ActiveJob
       class Scheduler # :nodoc:
         DEFAULT_EXECUTOR_OPTIONS = {
           min_threads:     0,
-          max_threads:     Concurrent.processor_count,
+          max_threads:     ENV.fetch("RAILS_MAX_THREADS", 5).to_i,
           auto_terminate:  true,
           idletime:        60, # 1 minute
           max_queue:       0, # unlimited
@@ -86,7 +86,11 @@ module ActiveJob
         def initialize(**options)
           self.immediate = false
           @immediate_executor = Concurrent::ImmediateExecutor.new
-          @async_executor = Concurrent::ThreadPoolExecutor.new(DEFAULT_EXECUTOR_OPTIONS.merge(options))
+          @async_executor = Concurrent::ThreadPoolExecutor.new(
+            name: "ActiveJob-async-scheduler",
+            **DEFAULT_EXECUTOR_OPTIONS,
+            **options
+          )
         end
 
         def enqueue(job, queue_name:)

data/lib/active_job/queue_adapters/backburner_adapter.rb

@@ -14,7 +14,7 @@ module ActiveJob
     # To use Backburner set the queue_adapter config to +:backburner+.
     #
     #   Rails.application.config.active_job.queue_adapter = :backburner
-    class BackburnerAdapter
+    class BackburnerAdapter < AbstractAdapter
       def enqueue(job) # :nodoc:
         response = Backburner::Worker.enqueue(JobWrapper, [job.serialize], queue: job.queue_name, pri: job.priority)
         job.provider_job_id = response[:id] if response.is_a?(Hash)