activejob 6.1.6 → 7.0.0.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aba0689728ed5e18e29d2a9ec94adcee95be2e9c592dfc28e5fa997c993e4838
-  data.tar.gz: 1e05515106a88bf83f153646deca0a15e7dd80c76923abf1a8a01ffe9c89745f
+  metadata.gz: 34ec9d3dc4bb88ce5c06f50a5efb7d34fb383b38088a400a1dc307329be429a9
+  data.tar.gz: 8d2a9541a56b633fabb47adbf164d6568f7487ab07f5749e96917320c5f66b0a
 SHA512:
-  metadata.gz: c7d0c78e869461b7bb1ab9bbce1dd655d1538e3da14808a1d37036868fb828532cb987a6848ec95a93f99b4514564cd8adb1722d4d8a50de7588c6e9b77f40ca
-  data.tar.gz: b51fe0ca5031c5a3245f0cec1b584fde53d742f5e6278f43406642649fb2fedbe040d4d5c229fdb59a411d4990196f34c09dc117ee8d1cb2090229e2da955d35
+  metadata.gz: 52b3116d2eba23f548e2af97a90a31fb544a0bb8c53e2642b6d0d8cdc03d419dc2de8bac6243b409b32d15fbf1af4da42e356f19df765d6b708b5b55b7283bb9
+  data.tar.gz: b8f3195cf56348deed886b834fe67a9f036b931f7b93c386888411d6aabc84467d87fc0a56ac2263b9d21df0e8294a3438d80e0748099ec1bd28bfcd4940c96e

data/CHANGELOG.md

@@ -1,216 +1,60 @@
-## Rails 6.1.5.1 (April 26, 2022) ##
+## Rails 7.0.0.alpha1 (September 15, 2021) ##
 
-*   No changes.
+*   Allow a job to retry indefinitely
 
+    The `attempts` parameter of the `retry_on` method now accepts the
+    symbol reference `:unlimited` in addition to a specific number of retry
+    attempts to allow a developer to specify that a job should retry
+    forever until it succeeds.
 
-## Rails 6.1.5 (March 09, 2022) ##
+        class MyJob < ActiveJob::Base
+          retry_on(AlwaysRetryException, attempts: :unlimited)
 
-*   No changes.
-
-
-## Rails 6.1.4.7 (March 08, 2022) ##
-
-*   No changes.
-
-
-## Rails 6.1.4.6 (February 11, 2022) ##
-
-*   No changes.
-
-
-## Rails 6.1.4.5 (February 11, 2022) ##
-
-*   No changes.
-
-
-## Rails 6.1.4.4 (December 15, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.4.3 (December 14, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.4.2 (December 14, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.4.1 (August 19, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.4 (June 24, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.3.2 (May 05, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.3.1 (March 26, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.3 (February 17, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.2.1 (February 10, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.2 (February 09, 2021) ##
-
-*   No changes.
-
-
-## Rails 6.1.1 (January 07, 2021) ##
-
-*   Make `retry_job` return the job that was created.
-
-    *Rafael Mendonça França*
-
-*   Include `ActiveSupport::Testing::Assertions` in `ActiveJob::TestHelpers`.
-
-    *Mikkel Malmberg*
-
-
-## Rails 6.1.0 (December 09, 2020) ##
-
-*   Recover nano precision when serializing `Time`, `TimeWithZone` and `DateTime` objects.
-
-    *Alan Tan*
-
-*   Deprecate `config.active_job.return_false_on_aborted_enqueue`.
-
-    *Rafael Mendonça França*
-
-*   Return `false` when enqueuing a job is aborted.
-
-    *Rafael Mendonça França*
-
-*   While using `perform_enqueued_jobs` test helper enqueued jobs must be stored for the later check with
-    `assert_enqueued_with`.
-
-    *Dmitry Polushkin*
-
-*   `ActiveJob::TestCase#perform_enqueued_jobs` without a block removes performed jobs from the queue.
-
-    That way the helper can be called multiple times and not perform a job invocation multiple times.
-
-    ```ruby
-    def test_jobs
-      HelloJob.perform_later("rafael")
-      perform_enqueued_jobs # only runs with "rafael"
-      HelloJob.perform_later("david")
-      perform_enqueued_jobs # only runs with "david"
-    end
-    ```
-
-    *Étienne Barrié*
-
-*   `ActiveJob::TestCase#perform_enqueued_jobs` will no longer perform retries:
-
-    When calling `perform_enqueued_jobs` without a block, the adapter will
-    now perform jobs that are **already** in the queue. Jobs that will end up in
-    the queue afterwards won't be performed.
-
-    This change only affects `perform_enqueued_jobs` when no block is given.
-
-    *Edouard Chin*
-
-*   Add queue name support to Que adapter.
-
-    *Brad Nauta*, *Wojciech Wnętrzak*
-
-*   Don't run `after_enqueue` and `after_perform` callbacks if the callback chain is halted.
-
-        class MyJob < ApplicationJob
-          before_enqueue { throw(:abort) }
-          after_enqueue { # won't enter here anymore }
+          # the actual job code
         end
 
-    `after_enqueue` and `after_perform` callbacks will no longer run if the callback chain is halted.
-    This behaviour is a breaking change and won't take effect until Rails 7.0.
-    To enable this behaviour in your app right now, you can add in your app's configuration file
-    `config.active_job.skip_after_callbacks_if_terminated = true`.
-
-    *Edouard Chin*
+    *Daniel Morton*
 
-*   Fix enqueuing and performing incorrect logging message.
+*   Added possibility to check on `:priority` in test helper methods
+    `assert_enqueued_with` and `assert_performed_with`.
 
-    Jobs will no longer always log "Enqueued MyJob" or "Performed MyJob" when they actually didn't get enqueued/performed.
+    *Wojciech Wnętrzak*
 
-    ```ruby
-      class MyJob < ApplicationJob
-        before_enqueue { throw(:abort) }
-      end
+*   OpenSSL constants are now used for Digest computations.
 
-      MyJob.perform_later # Will no longer log "Enqueued MyJob" since job wasn't even enqueued through adapter.
-    ```
+    *Dirkjan Bussink*
 
-    A new message will be logged in case a job couldn't be enqueued, either because the callback chain was halted or
-    because an exception happened during enqueuing. (i.e. Redis is down when you try to enqueue your job)
+*   Add a Serializer for the Range class.
 
-    *Edouard Chin*
+    This should allow things like `MyJob.perform_later(range: 1..100)`.
 
-*   Add an option to disable logging of the job arguments when enqueuing and executing the job.
+*   Communicate enqueue failures to callers of `perform_later`.
 
-        class SensitiveJob < ApplicationJob
-          self.log_arguments = false
+    `perform_later` can now optionally take a block which will execute after
+    the adapter attempts to enqueue the job. The block will receive the job
+    instance as an argument even if the enqueue was not successful.
+    Additionally, `ActiveJob` adapters now have the ability to raise an
+    `ActiveJob::EnqueueError` which will be caught and stored in the job
+    instance so code attempting to enqueue jobs can inspect any raised
+    `EnqueueError` using the block.
 
-          def perform(my_sensitive_argument)
+        MyJob.perform_later do |job|
+          unless job.successfully_enqueued?
+            if job.enqueue_error&.message == "Redis was unavailable"
+              # invoke some code that will retry the job after a delay
+            end
           end
         end
 
-    When dealing with sensitive arguments as password and tokens it is now possible to configure the job
-    to not put the sensitive argument in the logs.
-
-    *Rafael Mendonça França*
-
-*   Changes in `queue_name_prefix` of a job no longer affects all other jobs.
-
-    Fixes #37084.
-
-    *Lucas Mansur*
-
-*   Allow `Class` and `Module` instances to be serialized.
-
-    *Kevin Deisz*
-
-*   Log potential matches in `assert_enqueued_with` and `assert_performed_with`.
-
-    *Gareth du Plooy*
-
-*   Add `at` argument to the `perform_enqueued_jobs` test helper.
-
-    *John Crepezzi*, *Eileen Uchitelle*
-
-*   `assert_enqueued_with` and `assert_performed_with` can now test jobs with relative delay.
-
-    *Vlado Cingel*
+    *Daniel Morton*
 
-*   Add jitter to `ActiveJob::Exceptions.retry_on`.
+*   Don't log rescuable exceptions defined with `rescue_from`.
 
-    `ActiveJob::Exceptions.retry_on` now uses a random amount of jitter in order to
-    prevent the [thundering herd effect](https://en.wikipedia.org/wiki/Thundering_herd_problem). Defaults to
-    15% (represented as 0.15) but overridable via the `:jitter` option when using `retry_on`.
-    Jitter is applied when an `Integer`, `ActiveSupport::Duration` or `:exponentially_longer`, is passed to the `wait` argument in `retry_on`.
+    *Hu Hailin*
 
-    ```ruby
-    retry_on(MyError, wait: :exponentially_longer, jitter: 0.30)
-    ```
+*   Allow `rescue_from` to rescue all exceptions.
 
-    *Anthony Ross*
+    *Adrianna Chang*, *Étienne Barrié*
 
 
-Please check [6-0-stable](https://github.com/rails/rails/blob/6-0-stable/activejob/CHANGELOG.md) for previous changes.
+Please check [6-1-stable](https://github.com/rails/rails/blob/6-1-stable/activejob/CHANGELOG.md) for previous changes.

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014-2022 David Heinemeier Hansson
+Copyright (c) 2014-2021 David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -18,3 +18,4 @@ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.md

@@ -2,13 +2,13 @@
 
 Active Job is a framework for declaring jobs and making them run on a variety
 of queuing backends. These jobs can be everything from regularly scheduled
-clean-ups, to billing charges, to mailings. Anything that can be chopped up into
-small units of work and run in parallel, really.
+clean-ups, to billing charges, to mailings — anything that can be chopped up into
+small units of work and run in parallel.
 
 It also serves as the backend for Action Mailer's #deliver_later functionality
 that makes it easy to turn any mailing into a job for running later. That's
 one of the most common jobs in a modern web application: sending emails outside
-of the request-response cycle, so the user doesn't have to wait on it.
+the request-response cycle, so the user doesn't have to wait on it.
 
 The main point is to ensure that all Rails apps will have a job infrastructure
 in place, even if it's in the form of an "immediate runner". We can then have

data/lib/active_job/arguments.rb

@@ -7,7 +7,7 @@ module ActiveJob
   #
   # Wraps the original exception raised as +cause+.
   class DeserializationError < StandardError
-    def initialize #:nodoc:
+    def initialize # :nodoc:
       super("Error while trying to deserialize arguments: #{$!.message}")
       set_backtrace $!.backtrace
     end
@@ -17,8 +17,8 @@ module ActiveJob
   # currently support String, Integer, Float, NilClass, TrueClass, FalseClass,
   # BigDecimal, Symbol, Date, Time, DateTime, ActiveSupport::TimeWithZone,
   # ActiveSupport::Duration, Hash, ActiveSupport::HashWithIndifferentAccess,
-  # Array or GlobalID::Identification instances, although this can be extended
-  # by adding custom serializers.
+  # Array, Range or GlobalID::Identification instances, although this can be
+  # extended by adding custom serializers.
   # Raised if you set the key for a Hash something else than a string or
   # a symbol. Also raised when trying to serialize an object which can't be
   # identified with a GlobalID - such as an unpersisted Active Record model.
@@ -73,24 +73,19 @@ module ActiveJob
         using Module.new {
           refine Hash do
             class << Hash
-              if RUBY_VERSION >= "2.7"
-                def ruby2_keywords_hash?(hash)
-                  !new(*[hash]).default.equal?(hash)
-                end
-              else
-                def ruby2_keywords_hash?(hash)
-                  false
-                end
+              def ruby2_keywords_hash?(hash)
+                !new(*[hash]).default.equal?(hash)
               end
 
               def ruby2_keywords_hash(hash)
                 _ruby2_keywords_hash(**hash)
               end
 
-              private def _ruby2_keywords_hash(*args)
-                args.last
-              end
-              ruby2_keywords(:_ruby2_keywords_hash) if respond_to?(:ruby2_keywords, true)
+              private
+                def _ruby2_keywords_hash(*args)
+                  args.last
+                end
+                ruby2_keywords(:_ruby2_keywords_hash)
             end
           end
         }

data/lib/active_job/base.rb

@@ -14,7 +14,7 @@ require "active_job/instrumentation"
 require "active_job/timezones"
 require "active_job/translation"
 
-module ActiveJob #:nodoc:
+module ActiveJob # :nodoc:
   # = Active Job
   #
   # Active Job objects can be configured to work with different backend
@@ -69,8 +69,8 @@ module ActiveJob #:nodoc:
     include Execution
     include Callbacks
     include Exceptions
-    include Logging
     include Instrumentation
+    include Logging
     include Timezones
     include Translation
 

data/lib/active_job/configured_job.rb

@@ -1,20 +1,18 @@
 # frozen_string_literal: true
 
 module ActiveJob
-  class ConfiguredJob #:nodoc:
+  class ConfiguredJob # :nodoc:
     def initialize(job_class, options = {})
       @options = options
       @job_class = job_class
     end
 
-    def perform_now(*args)
-      @job_class.new(*args).perform_now
+    def perform_now(...)
+      @job_class.new(...).perform_now
     end
-    ruby2_keywords(:perform_now) if respond_to?(:ruby2_keywords, true)
 
-    def perform_later(*args)
-      @job_class.new(*args).enqueue @options
+    def perform_later(...)
+      @job_class.new(...).enqueue @options
     end
-    ruby2_keywords(:perform_later) if respond_to?(:ruby2_keywords, true)
   end
 end

data/lib/active_job/core.rb

@@ -43,6 +43,16 @@ module ActiveJob
     # Track when a job was enqueued
     attr_accessor :enqueued_at
 
+    # Track whether the adapter received the job successfully.
+    attr_writer :successfully_enqueued # :nodoc:
+
+    def successfully_enqueued?
+      @successfully_enqueued
+    end
+
+    # Track any exceptions raised by the backend so callers can inspect the errors.
+    attr_accessor :enqueue_error
+
     # These methods will be included into any Active Job object, adding
     # helpers for de/serialization and creation of job instances.
     module ClassMethods
@@ -87,7 +97,7 @@ module ActiveJob
       @exception_executions = {}
       @timezone   = Time.zone&.name
     end
-    ruby2_keywords(:initialize) if respond_to?(:ruby2_keywords, true)
+    ruby2_keywords(:initialize)
 
     # Returns a hash with the job data that can safely be passed to the
     # queuing adapter.

data/lib/active_job/enqueuing.rb

@@ -4,6 +4,11 @@ require "active_job/arguments"
 
 module ActiveJob
   # Provides behavior for enqueuing jobs.
+
+  # Can be raised by adapters if they wish to communicate to the caller a reason
+  # why the adapter was unexpectedly unable to enqueue a job.
+  class EnqueueError < StandardError; end
+
   module Enqueuing
     extend ActiveSupport::Concern
 
@@ -12,22 +17,28 @@ module ActiveJob
       # Push a job onto the queue. By default the arguments must be either String,
       # Integer, Float, NilClass, TrueClass, FalseClass, BigDecimal, Symbol, Date,
       # Time, DateTime, ActiveSupport::TimeWithZone, ActiveSupport::Duration,
-      # Hash, ActiveSupport::HashWithIndifferentAccess, Array or
+      # Hash, ActiveSupport::HashWithIndifferentAccess, Array, Range or
       # GlobalID::Identification instances, although this can be extended by adding
       # custom serializers.
       #
       # Returns an instance of the job class queued with arguments available in
-      # Job#arguments.
-      def perform_later(*args)
-        job_or_instantiate(*args).enqueue
+      # Job#arguments or false if the enqueue did not succeed.
+      #
+      # After the attempted enqueue, the job will be yielded to an optional block.
+      def perform_later(...)
+        job = job_or_instantiate(...)
+        enqueue_result = job.enqueue
+
+        yield job if block_given?
+
+        enqueue_result
       end
-      ruby2_keywords(:perform_later) if respond_to?(:ruby2_keywords, true)
 
       private
         def job_or_instantiate(*args) # :doc:
           args.first.is_a?(self) ? args.first : new(*args)
         end
-        ruby2_keywords(:job_or_instantiate) if respond_to?(:ruby2_keywords, true)
+        ruby2_keywords(:job_or_instantiate)
     end
 
     # Enqueues the job to be performed by the queue adapter.
@@ -50,7 +61,7 @@ module ActiveJob
       self.scheduled_at = options[:wait_until].to_f if options[:wait_until]
       self.queue_name   = self.class.queue_name_from_part(options[:queue]) if options[:queue]
       self.priority     = options[:priority].to_i if options[:priority]
-      successfully_enqueued = false
+      self.successfully_enqueued = false
 
       run_callbacks :enqueue do
         if scheduled_at
@@ -59,10 +70,12 @@ module ActiveJob
           queue_adapter.enqueue self
         end
 
-        successfully_enqueued = true
+        self.successfully_enqueued = true
+      rescue EnqueueError => e
+        self.enqueue_error = e
       end
 
-      if successfully_enqueued
+      if successfully_enqueued?
         self
       else
         false

data/lib/active_job/exceptions.rb

@@ -25,7 +25,8 @@ module ActiveJob
       #   as a computing proc that takes the number of executions so far as an argument, or as a symbol reference of
       #   <tt>:exponentially_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)
+      # * <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>: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)
@@ -35,6 +36,7 @@ module ActiveJob
       #  class RemoteServiceJob < ActiveJob::Base
       #    retry_on CustomAppException # defaults to ~3s wait, 5 attempts
       #    retry_on AnotherCustomAppException, wait: ->(executions) { executions * 2 }
+      #    retry_on CustomInfrastructureException, wait: 5.minutes, attempts: :unlimited
       #
       #    retry_on ActiveRecord::Deadlocked, wait: 5.seconds, attempts: 3
       #    retry_on Net::OpenTimeout, Timeout::Error, wait: :exponentially_longer, attempts: 10 # retries at most 10 times for Net::OpenTimeout and Timeout::Error combined
@@ -56,7 +58,7 @@ module ActiveJob
       def retry_on(*exceptions, wait: 3.seconds, attempts: 5, queue: nil, priority: nil, jitter: JITTER_DEFAULT)
         rescue_from(*exceptions) do |error|
           executions = executions_for(exceptions)
-          if executions < attempts
+          if attempts == :unlimited || executions < attempts
             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?

data/lib/active_job/execution.rb

@@ -14,12 +14,11 @@ module ActiveJob
       #
       #   MyJob.perform_now("mike")
       #
-      def perform_now(*args)
-        job_or_instantiate(*args).perform_now
+      def perform_now(...)
+        job_or_instantiate(...).perform_now
       end
-      ruby2_keywords(:perform_now) if respond_to?(:ruby2_keywords, true)
 
-      def execute(job_data) #:nodoc:
+      def execute(job_data) # :nodoc:
         ActiveJob::Callbacks.run_callbacks(:execute) do
           job = deserialize(job_data)
           job.perform_now
@@ -44,15 +43,20 @@ module ActiveJob
 
       deserialize_arguments_if_needed
 
-      run_callbacks :perform do
-        perform(*arguments)
-      end
-    rescue => exception
+      _perform_job
+    rescue Exception => exception
       rescue_with_handler(exception) || raise
     end
 
     def perform(*)
       fail NotImplementedError
     end
+
+    private
+      def _perform_job
+        run_callbacks :perform do
+          perform(*arguments)
+        end
+      end
   end
 end

data/lib/active_job/gem_version.rb

@@ -7,10 +7,10 @@ module ActiveJob
   end
 
   module VERSION
-    MAJOR = 6
-    MINOR = 1
-    TINY  = 6
-    PRE   = nil
+    MAJOR = 7
+    MINOR = 0
+    TINY  = 0
+    PRE   = "alpha1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_job/instrumentation.rb

@@ -1,21 +1,25 @@
 # frozen_string_literal: true
 
 module ActiveJob
-  module Instrumentation #:nodoc:
+  module Instrumentation # :nodoc:
     extend ActiveSupport::Concern
 
     included do
       around_enqueue do |_, block|
         scheduled_at ? instrument(:enqueue_at, &block) : instrument(:enqueue, &block)
       end
+    end
 
-      around_perform do |_, block|
-        instrument :perform_start
-        instrument :perform, &block
-      end
+    def perform_now
+      instrument(:perform) { super }
     end
 
     private
+      def _perform_job
+        instrument(:perform_start)
+        super
+      end
+
       def instrument(operation, payload = {}, &block)
         enhanced_block = ->(event_payload) do
           value = block.call if block

data/lib/active_job/log_subscriber.rb

@@ -4,7 +4,7 @@ require "active_support/core_ext/string/filters"
 require "active_support/log_subscriber"
 
 module ActiveJob
-  class LogSubscriber < ActiveSupport::LogSubscriber #:nodoc:
+  class LogSubscriber < ActiveSupport::LogSubscriber # :nodoc:
     def enqueue(event)
       job = event.payload[:job]
       ex = event.payload[:exception_object]

data/lib/active_job/logging.rb

@@ -4,22 +4,25 @@ require "active_support/tagged_logging"
 require "active_support/logger"
 
 module ActiveJob
-  module Logging #:nodoc:
+  module Logging # :nodoc:
     extend ActiveSupport::Concern
 
     included do
       cattr_accessor :logger, default: ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT))
       class_attribute :log_arguments, instance_accessor: false, default: true
 
-      around_enqueue { |_, block| tag_logger(&block) }
-      around_perform { |job, block| tag_logger(job.class.name, job.job_id, &block) }
+      around_enqueue(prepend: true) { |_, block| tag_logger(&block) }
+    end
+
+    def perform_now
+      tag_logger(self.class.name, self.job_id) { super }
     end
 
     private
-      def tag_logger(*tags)
+      def tag_logger(*tags, &block)
         if logger.respond_to?(:tagged)
           tags.unshift "ActiveJob" unless logger_tagged_by_active_job?
-          logger.tagged(*tags) { yield }
+          logger.tagged(*tags, &block)
         else
           yield
         end

data/lib/active_job/query_tags.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module QueryTags # :nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      around_perform :expose_job_to_query_logs
+    end
+
+    private
+      def expose_job_to_query_logs(&block)
+        ActiveRecord::QueryLogs.set_context(job: self, &block)
+      end
+  end
+end

data/lib/active_job/queue_adapter.rb

@@ -5,7 +5,7 @@ require "active_support/core_ext/string/inflections"
 module ActiveJob
   # The <tt>ActiveJob::QueueAdapter</tt> module is used to load the
   # correct adapter. The default queue adapter is the +:async+ queue.
-  module QueueAdapter #:nodoc:
+  module QueueAdapter # :nodoc:
     extend ActiveSupport::Concern
 
     included do

data/lib/active_job/queue_adapters/async_adapter.rb

@@ -36,23 +36,23 @@ module ActiveJob
         @scheduler = Scheduler.new(**executor_options)
       end
 
-      def enqueue(job) #:nodoc:
+      def enqueue(job) # :nodoc:
         @scheduler.enqueue JobWrapper.new(job), queue_name: job.queue_name
       end
 
-      def enqueue_at(job, timestamp) #:nodoc:
+      def enqueue_at(job, timestamp) # :nodoc:
         @scheduler.enqueue_at JobWrapper.new(job), timestamp, queue_name: job.queue_name
       end
 
       # Gracefully stop processing jobs. Finishes in-progress work and handles
       # any new jobs following the executor's fallback policy (`caller_runs`).
       # Waits for termination by default. Pass `wait: false` to continue.
-      def shutdown(wait: true) #:nodoc:
+      def shutdown(wait: true) # :nodoc:
         @scheduler.shutdown wait: wait
       end
 
       # Used for our test suite.
-      def immediate=(immediate) #:nodoc:
+      def immediate=(immediate) # :nodoc:
         @scheduler.immediate = immediate
       end
 
@@ -60,7 +60,7 @@ module ActiveJob
       # performing them in-process, but we do so anyway for parity with other
       # adapters and deployment environments. Otherwise, serialization bugs
       # may creep in undetected.
-      class JobWrapper #:nodoc:
+      class JobWrapper # :nodoc:
         def initialize(job)
           job.provider_job_id = SecureRandom.uuid
           @job_data = job.serialize
@@ -71,7 +71,7 @@ module ActiveJob
         end
       end
 
-      class Scheduler #:nodoc:
+      class Scheduler # :nodoc:
         DEFAULT_EXECUTOR_OPTIONS = {
           min_threads:     0,
           max_threads:     Concurrent.processor_count,

data/lib/active_job/queue_adapters/backburner_adapter.rb

@@ -15,16 +15,16 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :backburner
     class BackburnerAdapter
-      def enqueue(job) #:nodoc:
+      def enqueue(job) # :nodoc:
         Backburner::Worker.enqueue(JobWrapper, [job.serialize], queue: job.queue_name, pri: job.priority)
       end
 
-      def enqueue_at(job, timestamp) #:nodoc:
+      def enqueue_at(job, timestamp) # :nodoc:
         delay = timestamp - Time.current.to_f
         Backburner::Worker.enqueue(JobWrapper, [job.serialize], queue: job.queue_name, pri: job.priority, delay: delay)
       end
 
-      class JobWrapper #:nodoc:
+      class JobWrapper # :nodoc:
         class << self
           def perform(job_data)
             Base.execute job_data

data/lib/active_job/queue_adapters/delayed_job_adapter.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "delayed_job"
+require "active_support/core_ext/string/inflections"
 
 module ActiveJob
   module QueueAdapters
@@ -15,19 +16,19 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :delayed_job
     class DelayedJobAdapter
-      def enqueue(job) #:nodoc:
+      def enqueue(job) # :nodoc:
         delayed_job = Delayed::Job.enqueue(JobWrapper.new(job.serialize), queue: job.queue_name, priority: job.priority)
         job.provider_job_id = delayed_job.id
         delayed_job
       end
 
-      def enqueue_at(job, timestamp) #:nodoc:
+      def enqueue_at(job, timestamp) # :nodoc:
         delayed_job = Delayed::Job.enqueue(JobWrapper.new(job.serialize), queue: job.queue_name, priority: job.priority, run_at: Time.at(timestamp))
         job.provider_job_id = delayed_job.id
         delayed_job
       end
 
-      class JobWrapper #:nodoc:
+      class JobWrapper # :nodoc:
         attr_accessor :job_data
 
         def initialize(job_data)
@@ -35,12 +36,21 @@ module ActiveJob
         end
 
         def display_name
-          "#{job_data['job_class']} [#{job_data['job_id']}] from DelayedJob(#{job_data['queue_name']}) with arguments: #{job_data['arguments']}"
+          base_name = "#{job_data["job_class"]} [#{job_data["job_id"]}] from DelayedJob(#{job_data["queue_name"]})"
+
+          return base_name unless log_arguments?
+
+          "#{base_name} with arguments: #{job_data["arguments"]}"
         end
 
         def perform
           Base.execute(job_data)
         end
+
+        private
+          def log_arguments?
+            job_data["job_class"].constantize.log_arguments?
+          end
       end
     end
   end

data/lib/active_job/queue_adapters/inline_adapter.rb

@@ -11,11 +11,11 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :inline
     class InlineAdapter
-      def enqueue(job) #:nodoc:
+      def enqueue(job) # :nodoc:
         Base.execute(job.serialize)
       end
 
-      def enqueue_at(*) #:nodoc:
+      def enqueue_at(*) # :nodoc:
         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

data/lib/active_job/queue_adapters/que_adapter.rb

@@ -17,19 +17,19 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :que
     class QueAdapter
-      def enqueue(job) #:nodoc:
+      def enqueue(job) # :nodoc:
         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:
+      def enqueue_at(job, timestamp) # :nodoc:
         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
 
-      class JobWrapper < Que::Job #:nodoc:
+      class JobWrapper < Que::Job # :nodoc:
         def run(job_data)
           Base.execute job_data
         end

data/lib/active_job/queue_adapters/queue_classic_adapter.rb

@@ -19,13 +19,13 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :queue_classic
     class QueueClassicAdapter
-      def enqueue(job) #:nodoc:
+      def enqueue(job) # :nodoc:
         qc_job = build_queue(job.queue_name).enqueue("#{JobWrapper.name}.perform", job.serialize)
         job.provider_job_id = qc_job["id"] if qc_job.is_a?(Hash)
         qc_job
       end
 
-      def enqueue_at(job, timestamp) #:nodoc:
+      def enqueue_at(job, timestamp) # :nodoc:
         queue = build_queue(job.queue_name)
         unless queue.respond_to?(:enqueue_at)
           raise NotImplementedError, "To be able to schedule jobs with queue_classic " \
@@ -46,7 +46,7 @@ module ActiveJob
         QC::Queue.new(queue_name)
       end
 
-      class JobWrapper #:nodoc:
+      class JobWrapper # :nodoc:
         class << self
           def perform(job_data)
             Base.execute job_data

data/lib/active_job/queue_adapters/resque_adapter.rb

@@ -28,12 +28,12 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :resque
     class ResqueAdapter
-      def enqueue(job) #:nodoc:
+      def enqueue(job) # :nodoc:
         JobWrapper.instance_variable_set(:@queue, job.queue_name)
         Resque.enqueue_to job.queue_name, JobWrapper, job.serialize
       end
 
-      def enqueue_at(job, timestamp) #:nodoc:
+      def enqueue_at(job, timestamp) # :nodoc:
         unless Resque.respond_to?(:enqueue_at_with_queue)
           raise NotImplementedError, "To be able to schedule jobs with Resque you need the " \
             "resque-scheduler gem. Please add it to your Gemfile and run bundle install"
@@ -41,7 +41,7 @@ module ActiveJob
         Resque.enqueue_at_with_queue job.queue_name, timestamp, JobWrapper, job.serialize
       end
 
-      class JobWrapper #:nodoc:
+      class JobWrapper # :nodoc:
         class << self
           def perform(job_data)
             Base.execute job_data

data/lib/active_job/queue_adapters/sidekiq_adapter.rb

@@ -17,7 +17,7 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :sidekiq
     class SidekiqAdapter
-      def enqueue(job) #:nodoc:
+      def enqueue(job) # :nodoc:
         # Sidekiq::Client does not support symbols as keys
         job.provider_job_id = Sidekiq::Client.push \
           "class"   => JobWrapper,
@@ -26,7 +26,7 @@ module ActiveJob
           "args"    => [ job.serialize ]
       end
 
-      def enqueue_at(job, timestamp) #:nodoc:
+      def enqueue_at(job, timestamp) # :nodoc:
         job.provider_job_id = Sidekiq::Client.push \
           "class"   => JobWrapper,
           "wrapped" => job.class,
@@ -35,7 +35,7 @@ module ActiveJob
           "at"      => timestamp
       end
 
-      class JobWrapper #:nodoc:
+      class JobWrapper # :nodoc:
         include Sidekiq::Worker
 
         def perform(job_data)

data/lib/active_job/queue_adapters/sneakers_adapter.rb

@@ -22,18 +22,18 @@ module ActiveJob
         @monitor = Monitor.new
       end
 
-      def enqueue(job) #:nodoc:
+      def enqueue(job) # :nodoc:
         @monitor.synchronize do
           JobWrapper.from_queue job.queue_name
           JobWrapper.enqueue ActiveSupport::JSON.encode(job.serialize)
         end
       end
 
-      def enqueue_at(job, timestamp) #:nodoc:
+      def enqueue_at(job, timestamp) # :nodoc:
         raise NotImplementedError, "This queueing backend does not support scheduling jobs. To see what features are supported go to http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"
       end
 
-      class JobWrapper #:nodoc:
+      class JobWrapper # :nodoc:
         include Sneakers::Worker
         from_queue "default"
 

data/lib/active_job/queue_adapters/sucker_punch_adapter.rb

@@ -18,7 +18,7 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :sucker_punch
     class SuckerPunchAdapter
-      def enqueue(job) #:nodoc:
+      def enqueue(job) # :nodoc:
         if JobWrapper.respond_to?(:perform_async)
           # sucker_punch 2.0 API
           JobWrapper.perform_async job.serialize
@@ -28,7 +28,7 @@ module ActiveJob
         end
       end
 
-      def enqueue_at(job, timestamp) #:nodoc:
+      def enqueue_at(job, timestamp) # :nodoc:
         if JobWrapper.respond_to?(:perform_in)
           delay = timestamp - Time.current.to_f
           JobWrapper.perform_in delay, job.serialize
@@ -37,7 +37,7 @@ module ActiveJob
         end
       end
 
-      class JobWrapper #:nodoc:
+      class JobWrapper # :nodoc:
         include SuckerPunch::Job
 
         def perform(job_data)

data/lib/active_job/queue_adapters/test_adapter.rb

@@ -25,12 +25,12 @@ module ActiveJob
         @performed_jobs ||= []
       end
 
-      def enqueue(job) #:nodoc:
+      def enqueue(job) # :nodoc:
         job_data = job_to_hash(job)
         perform_or_enqueue(perform_enqueued_jobs && !filtered?(job), job, job_data)
       end
 
-      def enqueue_at(job, timestamp) #:nodoc:
+      def enqueue_at(job, timestamp) # :nodoc:
         job_data = job_to_hash(job, at: timestamp)
         perform_or_enqueue(perform_enqueued_at_jobs && !filtered?(job), job, job_data)
       end
@@ -41,6 +41,7 @@ module ActiveJob
             job_data[:job] = job.class
             job_data[:args] = job_data.fetch("arguments")
             job_data[:queue] = job_data.fetch("queue_name")
+            job_data[:priority] = job_data.fetch("priority")
           end.merge(extras)
         end
 

data/lib/active_job/queue_name.rb

@@ -45,7 +45,7 @@ module ActiveJob
         end
       end
 
-      def queue_name_from_part(part_name) #:nodoc:
+      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)

data/lib/active_job/railtie.rb

@@ -8,6 +8,7 @@ module ActiveJob
   class Railtie < Rails::Railtie # :nodoc:
     config.active_job = ActiveSupport::OrderedOptions.new
     config.active_job.custom_serializers = []
+    config.active_job.log_query_tags_around_perform = true
 
     initializer "active_job.logger" do
       ActiveSupport.on_load(:active_job) { self.logger = ::Rails.logger }
@@ -15,7 +16,7 @@ module ActiveJob
 
     initializer "active_job.custom_serializers" do |app|
       config.after_initialize do
-        custom_serializers = app.config.active_job.delete(:custom_serializers)
+        custom_serializers = app.config.active_job.custom_serializers
         ActiveJob::Serializers.add_serializers custom_serializers
       end
     end
@@ -25,6 +26,12 @@ module ActiveJob
       options.queue_adapter ||= :async
 
       ActiveSupport.on_load(:active_job) do
+        # Configs used in other initializers
+        options = options.except(
+          :log_query_tags_around_perform,
+          :custom_serializers
+        )
+
         options.each do  |k, v|
           k = "#{k}="
           send(k, v) if respond_to? k
@@ -49,5 +56,23 @@ module ActiveJob
         end
       end
     end
+
+    initializer "active_job.query_log_tags" do |app|
+      query_logs_tags_enabled = app.config.respond_to?(:active_record) &&
+        app.config.active_record.query_log_tags_enabled &&
+        app.config.active_job.log_query_tags_around_perform
+
+      if query_logs_tags_enabled
+        app.config.active_record.query_log_tags << :job
+
+        ActiveSupport.on_load(:active_job) do
+          include ActiveJob::QueryTags
+        end
+
+        ActiveSupport.on_load(:active_record) do
+          ActiveRecord::QueryLogs.taggings[:job] = ->(context) { context[:job].class.name unless context[:job].nil? }
+        end
+      end
+    end
   end
 end

data/lib/active_job/serializers/range_serializer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+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)
+      end
+
+      def deserialize(hash)
+        klass.new(*Arguments.deserialize(hash.values_at(*KEYS)))
+      end
+
+      private
+        def klass
+          ::Range
+        end
+    end
+  end
+end

data/lib/active_job/serializers.rb

@@ -17,6 +17,7 @@ module ActiveJob
     autoload :TimeWithZoneSerializer
     autoload :TimeSerializer
     autoload :ModuleSerializer
+    autoload :RangeSerializer
 
     mattr_accessor :_additional_serializers
     self._additional_serializers = Set.new
@@ -61,6 +62,7 @@ module ActiveJob
       DateSerializer,
       TimeWithZoneSerializer,
       TimeSerializer,
-      ModuleSerializer
+      ModuleSerializer,
+      RangeSerializer
   end
 end

data/lib/active_job/test_helper.rb

@@ -124,7 +124,7 @@ module ActiveJob
       if block_given?
         original_jobs = enqueued_jobs_with(only: only, except: except, queue: queue)
 
-        assert_nothing_raised(&block)
+        _assert_nothing_raised_or_warn("assert_enqueued_jobs", &block)
 
         new_jobs = enqueued_jobs_with(only: only, except: except, queue: queue)
 
@@ -389,15 +389,15 @@ module ActiveJob
     #       MyJob.set(wait_until: Date.tomorrow.noon).perform_later
     #     end
     #   end
-    def assert_enqueued_with(job: nil, args: nil, at: nil, queue: nil, &block)
-      expected = { job: job, args: args, at: at, queue: queue }.compact
+    def assert_enqueued_with(job: nil, args: nil, at: nil, queue: nil, priority: nil, &block)
+      expected = { job: job, args: args, at: at, queue: queue, priority: priority }.compact
       expected_args = prepare_args_for_assertion(expected)
       potential_matches = []
 
       if block_given?
         original_enqueued_jobs = enqueued_jobs.dup
 
-        assert_nothing_raised(&block)
+        _assert_nothing_raised_or_warn("assert_enqueued_with", &block)
 
         jobs = enqueued_jobs - original_enqueued_jobs
       else
@@ -479,8 +479,8 @@ module ActiveJob
     #       MyJob.set(wait_until: Date.tomorrow.noon).perform_later
     #     end
     #   end
-    def assert_performed_with(job: nil, args: nil, at: nil, queue: nil, &block)
-      expected = { job: job, args: args, at: at, queue: queue }.compact
+    def assert_performed_with(job: nil, args: nil, at: nil, queue: nil, priority: nil, &block)
+      expected = { job: job, args: args, at: at, queue: queue, priority: priority }.compact
       expected_args = prepare_args_for_assertion(expected)
       potential_matches = []
 
@@ -591,7 +591,7 @@ module ActiveJob
         queue_adapter.queue = queue
         queue_adapter.at = at
 
-        assert_nothing_raised(&block)
+        _assert_nothing_raised_or_warn("perform_enqueued_jobs", &block)
       ensure
         queue_adapter.perform_enqueued_jobs = old_perform_enqueued_jobs
         queue_adapter.perform_enqueued_at_jobs = old_perform_enqueued_at_jobs

data/lib/active_job/timezones.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveJob
-  module Timezones #:nodoc:
+  module Timezones # :nodoc:
     extend ActiveSupport::Concern
 
     included do

data/lib/active_job/translation.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveJob
-  module Translation #:nodoc:
+  module Translation # :nodoc:
     extend ActiveSupport::Concern
 
     included do

data/lib/active_job.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #--
-# Copyright (c) 2014-2022 David Heinemeier Hansson
+# Copyright (c) 2014-2021 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -37,4 +37,5 @@ module ActiveJob
   autoload :ConfiguredJob
   autoload :TestCase
   autoload :TestHelper
+  autoload :QueryTags
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activejob
 version: !ruby/object:Gem::Version
-  version: 6.1.6
+  version: 7.0.0.alpha1
 platform: ruby
 authors:
 - David Heinemeier Hansson
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-09 00:00:00.000000000 Z
+date: 2021-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.1.6
+        version: 7.0.0.alpha1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.1.6
+        version: 7.0.0.alpha1
 - !ruby/object:Gem::Dependency
   name: globalid
   requirement: !ruby/object:Gem::Requirement
@@ -60,6 +60,7 @@ files:
 - lib/active_job/instrumentation.rb
 - lib/active_job/log_subscriber.rb
 - lib/active_job/logging.rb
+- lib/active_job/query_tags.rb
 - lib/active_job/queue_adapter.rb
 - lib/active_job/queue_adapters.rb
 - lib/active_job/queue_adapters/async_adapter.rb
@@ -82,6 +83,7 @@ files:
 - lib/active_job/serializers/duration_serializer.rb
 - lib/active_job/serializers/module_serializer.rb
 - lib/active_job/serializers/object_serializer.rb
+- lib/active_job/serializers/range_serializer.rb
 - lib/active_job/serializers/symbol_serializer.rb
 - lib/active_job/serializers/time_object_serializer.rb
 - lib/active_job/serializers/time_serializer.rb
@@ -99,12 +101,11 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/rails/rails/issues
-  changelog_uri: https://github.com/rails/rails/blob/v6.1.6/activejob/CHANGELOG.md
-  documentation_uri: https://api.rubyonrails.org/v6.1.6/
+  changelog_uri: https://github.com/rails/rails/blob/v7.0.0.alpha1/activejob/CHANGELOG.md
+  documentation_uri: https://api.rubyonrails.org/v7.0.0.alpha1/
   mailing_list_uri: https://discuss.rubyonrails.org/c/rubyonrails-talk
-  source_code_uri: https://github.com/rails/rails/tree/v6.1.6/activejob
-  rubygems_mfa_required: 'true'
-post_install_message:
+  source_code_uri: https://github.com/rails/rails/tree/v7.0.0.alpha1/activejob
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -112,15 +113,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 3.1.6
+signing_key: 
 specification_version: 4
 summary: Job framework with pluggable queues.
 test_files: []