activejob 6.1.4 → 7.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9a769fe2768c9eb83ad494a3df8b26563d79e227c2090aec92f3a72f219b6f5
-  data.tar.gz: 74a40ff51687bf8fb48e2393e754f2ac8fb17ef38bf1bd0d3e8cadf4e2b46be8
+  metadata.gz: 4ae9afbd809eb16b45a08dd01c5a4b380bc0ce41055e074c0156ca1f0fae2650
+  data.tar.gz: 87653df366fcb02cead16d16a256fb99292cdce5f5a5504ceb2efe205378ca4a
 SHA512:
-  metadata.gz: 943a0e1dcf505ccb814efb03ca3bed692aef6dc6adf5aacb228316d561cabe53fc1c211d6d659645797467b0adae1d639ce0e913973c0244bdd98f4a30203a56
-  data.tar.gz: '0495568dfc65ca2ea01a2c11f087f0066b28dd103f2c948e76a13fc5d6ff2b853505c36b5a854a0b274b310968a499b9de824cbb7093a2a309f3490d48bc77b6'
+  metadata.gz: 07b924bedc982b2c43b7f0a75bdb3a9f0770730a17cb4c26a1dd553923ac2bcf5f9b186279e0d11d36975d3d128df27caaa1e3ca8d225a472c70b7fccbbfd219
+  data.tar.gz: 3bff03b822d41e5a88bf1e73273e09fa06f2ac311e508d1c99bfb72d852980beffed30e24b0cfdd1fa8fce9a05dd04b0ef108fb9ef9c66fe67fbfe0dda206475

data/CHANGELOG.md

@@ -1,171 +1,84 @@
-## 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.
+*   Remove deprecated `:return_false_on_aborted_enqueue` option.
 
     *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`.
+*   Deprecated `Rails.config.active_job.skip_after_callbacks_if_terminated`.
 
     *Rafael Mendonça França*
 
-*   Return `false` when enqueuing a job is aborted.
+*   Removed deprecated behavior that was not halting `after_enqueue`/`after_perform` callbacks when a
+    previous callback was halted with `throw :abort`.
 
     *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`.
+*   Raise an `SerializationError` in `Serializer::ModuleSerializer`
+    if the module name is not present.
 
-    *Dmitry Polushkin*
+    *Veerpal Brar*
 
-*   `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.
+## Rails 7.0.0.alpha2 (September 15, 2021) ##
 
-    ```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.
+*   No changes.
 
-    This change only affects `perform_enqueued_jobs` when no block is given.
 
-    *Edouard Chin*
+## Rails 7.0.0.alpha1 (September 15, 2021) ##
 
-*   Add queue name support to Que adapter.
+*   Allow a job to retry indefinitely
 
-    *Brad Nauta*, *Wojciech Wnętrzak*
+    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.
 
-*   Don't run `after_enqueue` and `after_perform` callbacks if the callback chain is halted.
+        class MyJob < ActiveJob::Base
+          retry_on(AlwaysRetryException, attempts: :unlimited)
 
-        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 6.2.
-    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-2020 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

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/callbacks.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "active_support/callbacks"
-require "active_support/core_ext/object/with_options"
 require "active_support/core_ext/module/attribute_accessors"
 
 module ActiveJob
@@ -30,24 +29,16 @@ module ActiveJob
 
     included do
       class_attribute :return_false_on_aborted_enqueue, instance_accessor: false, instance_predicate: false, default: false
-      singleton_class.deprecate :return_false_on_aborted_enqueue, :return_false_on_aborted_enqueue=
       cattr_accessor :skip_after_callbacks_if_terminated, instance_accessor: false, default: false
+      singleton_class.deprecate :skip_after_callbacks_if_terminated, :skip_after_callbacks_if_terminated=
 
-      with_options(skip_after_callbacks_if_terminated: skip_after_callbacks_if_terminated) do
-        define_callbacks :perform
-        define_callbacks :enqueue
-      end
+      define_callbacks :perform, skip_after_callbacks_if_terminated: true
+      define_callbacks :enqueue, skip_after_callbacks_if_terminated: true
     end
 
     # These methods will be included into any Active Job object, adding
     # callbacks for +perform+ and +enqueue+ methods.
     module ClassMethods
-      def inherited(klass)
-        klass.get_callbacks(:enqueue).config[:skip_after_callbacks_if_terminated] = skip_after_callbacks_if_terminated
-        klass.get_callbacks(:perform).config[:skip_after_callbacks_if_terminated] = skip_after_callbacks_if_terminated
-        super
-      end
-
       # Defines a callback that will get called right before the
       # job's perform method is executed.
       #
@@ -178,21 +169,5 @@ module ActiveJob
         set_callback(:enqueue, :around, *filters, &blk)
       end
     end
-
-    private
-      def halted_callback_hook(_filter, name) # :nodoc:
-        return super unless %i(enqueue perform).include?(name.to_sym)
-        callbacks = public_send("_#{name}_callbacks")
-
-        if !self.class.skip_after_callbacks_if_terminated && callbacks.any? { |c| c.kind == :after }
-          ActiveSupport::Deprecation.warn(<<~EOM)
-            In Rails 6.2, `after_enqueue`/`after_perform` callbacks no longer run if `before_enqueue`/`before_perform` respectively halts with `throw :abort`.
-            To enable this behavior, uncomment the `config.active_job.skip_after_callbacks_if_terminated` config
-            in the new 6.1 framework defaults initializer.
-          EOM
-        end
-
-        super
-      end
   end
 end

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(...).set(@options).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.
@@ -146,6 +156,16 @@ module ActiveJob
       self.enqueued_at          = job_data["enqueued_at"]
     end
 
+    # Configures the job with the given options.
+    def set(options = {}) # :nodoc:
+      self.scheduled_at = options[:wait].seconds.from_now.to_f if options[:wait]
+      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]
+
+      self
+    end
+
     private
       def serialize_arguments_if_needed(arguments)
         if arguments_serialized?

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.
@@ -46,11 +57,8 @@ module ActiveJob
     #    my_job_instance.enqueue wait_until: Date.tomorrow.midnight
     #    my_job_instance.enqueue priority: 10
     def enqueue(options = {})
-      self.scheduled_at = options[:wait].seconds.from_now.to_f if options[:wait]
-      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
+      set(options)
+      self.successfully_enqueued = false
 
       run_callbacks :enqueue do
         if scheduled_at
@@ -59,10 +67,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,21 @@ 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
+        ActiveSupport::ExecutionContext[:job] = self
+        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  = 4
-    PRE   = nil
+    MAJOR = 7
+    MINOR = 0
+    TINY  = 0
+    PRE   = "rc1"
 
     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]