good_job 4.1.0 → 4.2.0

data/config/routes.rb

@@ -19,7 +19,11 @@ GoodJob::Engine.routes.draw do
   get 'jobs/metrics/primary_nav', to: 'metrics#primary_nav', as: :metrics_primary_nav
   get 'jobs/metrics/job_status', to: 'metrics#job_status', as: :metrics_job_status
 
-  resources :batches, only: %i[index show]
+  resources :batches, only: %i[index show] do
+    member do
+      put :retry
+    end
+  end
 
   resources :cron_entries, only: %i[index show], param: :cron_key do
     member do
@@ -33,8 +37,8 @@ GoodJob::Engine.routes.draw do
 
   resources :performance, only: %i[index show]
 
-  scope :frontend, controller: :frontends do
-    get "modules/:name", action: :module, as: :frontend_module, constraints: { format: 'js' }
-    get "static/:name", action: :static, as: :frontend_static, constraints: { format: %w[css js] }
+  scope :frontend, controller: :frontends, defaults: { version: GoodJob::VERSION.tr(".", "-") } do
+    get "modules/:version/:id", action: :module, as: :frontend_module, constraints: { format: 'js' }
+    get "static/:version/:id", action: :static, as: :frontend_static
   end
 end

data/lib/good_job/active_job_extensions/concurrency.rb

@@ -28,28 +28,88 @@ module GoodJob
         class_attribute :good_job_concurrency_config, instance_accessor: false, default: {}
         attr_writer :good_job_concurrency_key
 
-        if ActiveJob.gem_version >= Gem::Version.new("6.1.0")
-          before_enqueue do |job|
-            good_job_enqueue_concurrency_check(job, on_abort: -> { throw(:abort) }, on_enqueue: nil)
-          end
-        else
-          around_enqueue do |job, block|
-            good_job_enqueue_concurrency_check(job, on_abort: nil, on_enqueue: block)
-          end
-        end
-
         wait_key = if ActiveJob.gem_version >= Gem::Version.new("7.1.0.a")
                      :polynomially_longer
                    else
                      :exponentially_longer
                    end
-
         retry_on(
           GoodJob::ActiveJobExtensions::Concurrency::ConcurrencyExceededError,
           attempts: Float::INFINITY,
           wait: wait_key
         )
 
+        before_enqueue do |job|
+          # Don't attempt to enforce concurrency limits with other queue adapters.
+          next unless job.class.queue_adapter.is_a?(GoodJob::Adapter)
+
+          # Always allow jobs to be retried because the current job's execution will complete momentarily
+          next if CurrentThread.active_job_id == job.job_id
+
+          # Only generate the concurrency key on the initial enqueue in case it is dynamic
+          job.good_job_concurrency_key ||= job._good_job_concurrency_key
+          key = job.good_job_concurrency_key
+          next if key.blank?
+
+          enqueue_limit = job.class.good_job_concurrency_config[:enqueue_limit]
+          enqueue_limit = instance_exec(&enqueue_limit) if enqueue_limit.respond_to?(:call)
+          enqueue_limit = nil unless enqueue_limit.present? && (0...Float::INFINITY).cover?(enqueue_limit)
+
+          unless enqueue_limit
+            total_limit = job.class.good_job_concurrency_config[:total_limit]
+            total_limit = instance_exec(&total_limit) if total_limit.respond_to?(:call)
+            total_limit = nil unless total_limit.present? && (0...Float::INFINITY).cover?(total_limit)
+          end
+
+          enqueue_throttle = job.class.good_job_concurrency_config[:enqueue_throttle]
+          enqueue_throttle = instance_exec(&enqueue_throttle) if enqueue_throttle.respond_to?(:call)
+          enqueue_throttle = nil unless enqueue_throttle.present? && enqueue_throttle.is_a?(Array) && enqueue_throttle.size == 2
+
+          limit = enqueue_limit || total_limit
+          throttle = enqueue_throttle
+          next unless limit || throttle
+
+          exceeded = nil
+          GoodJob::Job.transaction(requires_new: true, joinable: false) do
+            GoodJob::Job.advisory_lock_key(key, function: "pg_advisory_xact_lock") do
+              if limit
+                enqueue_concurrency = if enqueue_limit
+                                        GoodJob::Job.where(concurrency_key: key).unfinished.advisory_unlocked.count
+                                      else
+                                        GoodJob::Job.where(concurrency_key: key).unfinished.count
+                                      end
+
+                # The job has not yet been enqueued, so check if adding it will go over the limit
+                if (enqueue_concurrency + 1) > limit
+                  logger.info "Aborted enqueue of #{job.class.name} (Job ID: #{job.job_id}) because the concurrency key '#{key}' has reached its enqueue limit of #{limit} #{'job'.pluralize(limit)}"
+                  exceeded = :limit
+                  next
+                end
+              end
+
+              if throttle
+                throttle_limit = throttle[0]
+                throttle_period = throttle[1]
+                enqueued_within_period = GoodJob::Job.where(concurrency_key: key)
+                                                     .where(GoodJob::Job.arel_table[:created_at].gt(throttle_period.ago))
+                                                     .count
+
+                if (enqueued_within_period + 1) > throttle_limit
+                  logger.info "Aborted enqueue of #{job.class.name} (Job ID: #{job.job_id}) because the concurrency key '#{key}' has reached its throttle limit of #{limit} #{'job'.pluralize(limit)}"
+                  exceeded = :throttle
+                  next
+                end
+              end
+            end
+
+            # Rollback the transaction because it's potentially less expensive than committing it
+            # even though nothing has been altered in the transaction.
+            raise ActiveRecord::Rollback
+          end
+
+          throw :abort if exceeded
+        end
+
         before_perform do |job|
           # Don't attempt to enforce concurrency limits with other queue adapters.
           next unless job.class.queue_adapter.is_a?(GoodJob::Adapter)
@@ -80,30 +140,47 @@ module GoodJob
             next
           end
 
-          GoodJob::Job.advisory_lock_key(key, function: "pg_advisory_lock") do
-            if limit
-              allowed_active_job_ids = GoodJob::Job.unfinished.where(concurrency_key: key)
-                                                   .advisory_locked
-                                                   .order(Arel.sql("COALESCE(performed_at, scheduled_at, created_at) ASC"))
-                                                   .limit(limit).pluck(:active_job_id)
-              # The current job has already been locked and will appear in the previous query
-              raise GoodJob::ActiveJobExtensions::Concurrency::ConcurrencyExceededError unless allowed_active_job_ids.include?(job.job_id)
+          exceeded = nil
+          GoodJob::Job.transaction(requires_new: true, joinable: false) do
+            GoodJob::Job.advisory_lock_key(key, function: "pg_advisory_xact_lock") do
+              if limit
+                allowed_active_job_ids = GoodJob::Job.unfinished.where(concurrency_key: key)
+                                                     .advisory_locked
+                                                     .order(Arel.sql("COALESCE(performed_at, scheduled_at, created_at) ASC"))
+                                                     .limit(limit).pluck(:active_job_id)
+                # The current job has already been locked and will appear in the previous query
+                unless allowed_active_job_ids.include?(job.job_id)
+                  exceeded = :limit
+                  next
+                end
+              end
+
+              if throttle
+                throttle_limit = throttle[0]
+                throttle_period = throttle[1]
+
+                query = Execution.joins(:job)
+                                 .where(GoodJob::Job.table_name => { concurrency_key: key })
+                                 .where(Execution.arel_table[:created_at].gt(Execution.bind_value('created_at', throttle_period.ago, ActiveRecord::Type::DateTime)))
+                allowed_active_job_ids = query.where(error: nil).or(query.where.not(error: "GoodJob::ActiveJobExtensions::Concurrency::ThrottleExceededError: GoodJob::ActiveJobExtensions::Concurrency::ThrottleExceededError"))
+                                              .order(created_at: :asc)
+                                              .limit(throttle_limit)
+                                              .pluck(:active_job_id)
+
+                unless allowed_active_job_ids.include?(job.job_id)
+                  exceeded = :throttle
+                  next
+                end
+              end
             end
 
-            if throttle
-              throttle_limit = throttle[0]
-              throttle_period = throttle[1]
-
-              query = DiscreteExecution.joins(:job)
-                                       .where(GoodJob::Job.table_name => { concurrency_key: key })
-                                       .where(DiscreteExecution.arel_table[:created_at].gt(DiscreteExecution.bind_value('created_at', throttle_period.ago, ActiveRecord::Type::DateTime)))
-              allowed_active_job_ids = query.where(error: nil).or(query.where.not(error: "GoodJob::ActiveJobExtensions::Concurrency::ThrottleExceededError: GoodJob::ActiveJobExtensions::Concurrency::ThrottleExceededError"))
-                                            .order(created_at: :asc)
-                                            .limit(throttle_limit)
-                                            .pluck(:active_job_id)
+            raise ActiveRecord::Rollback
+          end
 
-              raise ThrottleExceededError unless allowed_active_job_ids.include?(job.job_id)
-            end
+          if exceeded == :limit
+            raise GoodJob::ActiveJobExtensions::Concurrency::ConcurrencyExceededError
+          elsif exceeded == :throttle
+            raise GoodJob::ActiveJobExtensions::Concurrency::ThrottleExceededError
           end
         end
       end
@@ -139,72 +216,6 @@ module GoodJob
       def _good_job_default_concurrency_key
         self.class.name.to_s
       end
-
-      private
-
-      def good_job_enqueue_concurrency_check(job, on_abort:, on_enqueue:)
-        # Don't attempt to enforce concurrency limits with other queue adapters.
-        return on_enqueue&.call unless job.class.queue_adapter.is_a?(GoodJob::Adapter)
-
-        # Always allow jobs to be retried because the current job's execution will complete momentarily
-        return on_enqueue&.call if CurrentThread.active_job_id == job.job_id
-
-        # Only generate the concurrency key on the initial enqueue in case it is dynamic
-        job.good_job_concurrency_key ||= job._good_job_concurrency_key
-        key = job.good_job_concurrency_key
-        return on_enqueue&.call if key.blank?
-
-        enqueue_limit = job.class.good_job_concurrency_config[:enqueue_limit]
-        enqueue_limit = instance_exec(&enqueue_limit) if enqueue_limit.respond_to?(:call)
-        enqueue_limit = nil unless enqueue_limit.present? && (0...Float::INFINITY).cover?(enqueue_limit)
-
-        unless enqueue_limit
-          total_limit = job.class.good_job_concurrency_config[:total_limit]
-          total_limit = instance_exec(&total_limit) if total_limit.respond_to?(:call)
-          total_limit = nil unless total_limit.present? && (0...Float::INFINITY).cover?(total_limit)
-        end
-
-        enqueue_throttle = job.class.good_job_concurrency_config[:enqueue_throttle]
-        enqueue_throttle = instance_exec(&enqueue_throttle) if enqueue_throttle.respond_to?(:call)
-        enqueue_throttle = nil unless enqueue_throttle.present? && enqueue_throttle.is_a?(Array) && enqueue_throttle.size == 2
-
-        limit = enqueue_limit || total_limit
-        throttle = enqueue_throttle
-        return on_enqueue&.call unless limit || throttle
-
-        GoodJob::Job.advisory_lock_key(key, function: "pg_advisory_lock") do
-          if limit
-            enqueue_concurrency = if enqueue_limit
-                                    GoodJob::Job.where(concurrency_key: key).unfinished.advisory_unlocked.count
-                                  else
-                                    GoodJob::Job.where(concurrency_key: key).unfinished.count
-                                  end
-
-            # The job has not yet been enqueued, so check if adding it will go over the limit
-            if (enqueue_concurrency + 1) > limit
-              logger.info "Aborted enqueue of #{job.class.name} (Job ID: #{job.job_id}) because the concurrency key '#{key}' has reached its enqueue limit of #{limit} #{'job'.pluralize(limit)}"
-              on_abort&.call
-              break
-            end
-          end
-
-          if throttle
-            throttle_limit = throttle[0]
-            throttle_period = throttle[1]
-            enqueued_within_period = GoodJob::Job.where(concurrency_key: key)
-                                                 .where(GoodJob::Job.arel_table[:created_at].gt(throttle_period.ago))
-                                                 .count
-
-            if (enqueued_within_period + 1) > throttle_limit
-              logger.info "Aborted enqueue of #{job.class.name} (Job ID: #{job.job_id}) because the concurrency key '#{key}' has reached its throttle limit of #{limit} #{'job'.pluralize(limit)}"
-              on_abort&.call
-              break
-            end
-          end
-
-          on_enqueue&.call
-        end
-      end
     end
   end
 end

data/lib/good_job/adapter/inline_buffer.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/attribute_accessors_per_thread'
+
+module GoodJob
+  class Adapter
+    # The InlineBuffer is integrated into the Adapter and captures jobs that have been enqueued inline.
+    # The purpose is allow job records to be persisted, in a locked state, while within a transaction,
+    # and then execute the jobs after the transaction has been committed to ensure that the jobs
+    # do not run within a transaction.
+    #
+    # @private This is intended for internal GoodJob usage only.
+    class InlineBuffer
+      # @!attribute [rw] current_buffer
+      #   @!scope class
+      #   Current buffer of jobs to be enqueued.
+      #   @return [GoodJob::Adapter::InlineBuffer, nil]
+      thread_mattr_accessor :current_buffer
+
+      # This block should be used to wrap the transaction that could enqueue jobs.
+      # @yield The block that may enqueue jobs.
+      # @return [Proc] A proc that will execute enqueued jobs after the transaction has been committed.
+      # @example Wrapping a transaction
+      #   buffer = GoodJob::Adapter::InlineBuffer.capture do
+      #     ActiveRecord::Base.transaction do
+      #       MyJob.perform_later
+      #     end
+      #   end
+      #   buffer.call
+      def self.capture
+        if current_buffer
+          yield
+          return proc {}
+        end
+
+        begin
+          self.current_buffer = new
+          yield
+          current_buffer.to_proc
+        ensure
+          self.current_buffer = nil
+        end
+      end
+
+      # Used within the adapter to wrap inline job execution
+      def self.perform_now_or_defer(&block)
+        if defer?
+          current_buffer.defer(block)
+        else
+          yield
+        end
+      end
+
+      def self.defer?
+        current_buffer.present?
+      end
+
+      def initialize
+        @callables = []
+      end
+
+      def defer(callable)
+        @callables << callable
+      end
+
+      def to_proc
+        proc do
+          @callables.map(&:call)
+        end
+      end
+    end
+  end
+end

data/lib/good_job/adapter.rb

@@ -57,7 +57,7 @@ module GoodJob
 
       Rails.application.executor.wrap do
         current_time = Time.current
-        executions = active_jobs.map do |active_job|
+        jobs = active_jobs.map do |active_job|
           GoodJob::Job.build_for_enqueue(active_job).tap do |job|
             job.scheduled_at = current_time if job.scheduled_at == job.created_at
             job.created_at = current_time
@@ -65,62 +65,56 @@ module GoodJob
           end
         end
 
-        inline_executions = []
+        inline_jobs = []
         GoodJob::Job.transaction(requires_new: true, joinable: false) do
-          execution_attributes = executions.map(&:attributes)
-          results = GoodJob::Job.insert_all(execution_attributes, returning: %w[id active_job_id]) # rubocop:disable Rails/SkipsModelValidations
+          job_attributes = jobs.map(&:attributes)
+          results = GoodJob::Job.insert_all(job_attributes, returning: %w[id active_job_id]) # rubocop:disable Rails/SkipsModelValidations
 
           job_id_to_provider_job_id = results.each_with_object({}) { |result, hash| hash[result['active_job_id']] = result['id'] }
           active_jobs.each do |active_job|
             active_job.provider_job_id = job_id_to_provider_job_id[active_job.job_id]
             active_job.successfully_enqueued = active_job.provider_job_id.present? if active_job.respond_to?(:successfully_enqueued=)
           end
-          executions.each do |execution|
-            execution.instance_variable_set(:@new_record, false) if job_id_to_provider_job_id[execution.active_job_id]
+          jobs.each do |job|
+            job.instance_variable_set(:@new_record, false) if job_id_to_provider_job_id[job.active_job_id]
           end
-          executions = executions.select(&:persisted?) # prune unpersisted executions
+          jobs = jobs.select(&:persisted?) # prune unpersisted jobs
 
           if execute_inline?
-            inline_executions = executions.select { |execution| (execution.scheduled_at.nil? || execution.scheduled_at <= Time.current) }
-            inline_executions.each(&:advisory_lock!)
+            inline_jobs = jobs.select { |job| job.scheduled_at.nil? || job.scheduled_at <= Time.current }
+            inline_jobs.each(&:advisory_lock!)
           end
         end
 
-        @capsule.tracker.register
-        begin
-          until inline_executions.empty?
-            begin
-              inline_execution = inline_executions.shift
-              inline_result = inline_execution.perform(lock_id: @capsule.tracker.id_for_lock)
-
-              retried_execution = inline_result.retried
-              while retried_execution && retried_execution.scheduled_at <= Time.current
-                inline_execution = retried_execution
-                inline_result = inline_execution.perform(lock_id: @capsule.tracker.id_for_lock)
-                retried_execution = inline_result.retried
+        if inline_jobs.any?
+          deferred = InlineBuffer.defer?
+          InlineBuffer.perform_now_or_defer do
+            @capsule.tracker.register do
+              until inline_jobs.empty?
+                inline_job = inline_jobs.shift
+                perform_inline(inline_job, notify: deferred ? send_notify?(inline_job) : false)
               end
             ensure
-              inline_execution.advisory_unlock
-              inline_execution.run_callbacks(:perform_unlocked)
+              inline_jobs.each(&:advisory_unlock)
             end
-            raise inline_result.unhandled_error if inline_result.unhandled_error
           end
-        ensure
-          @capsule.tracker.unregister
-          inline_executions.each(&:advisory_unlock)
         end
 
-        non_inline_executions = executions.reject(&:finished_at)
-        if non_inline_executions.any?
+        non_inline_jobs = if InlineBuffer.defer?
+                            jobs - inline_jobs
+                          else
+                            jobs.reject(&:finished_at)
+                          end
+        if non_inline_jobs.any?
           job_id_to_active_jobs = active_jobs.index_by(&:job_id)
-          non_inline_executions.group_by(&:queue_name).each do |queue_name, executions_by_queue|
-            executions_by_queue.group_by(&:scheduled_at).each do |scheduled_at, executions_by_queue_and_scheduled_at|
-              state = { queue_name: queue_name, count: executions_by_queue_and_scheduled_at.size }
+          non_inline_jobs.group_by(&:queue_name).each do |queue_name, jobs_by_queue|
+            jobs_by_queue.group_by(&:scheduled_at).each do |scheduled_at, jobs_by_queue_and_scheduled_at|
+              state = { queue_name: queue_name, count: jobs_by_queue_and_scheduled_at.size }
               state[:scheduled_at] = scheduled_at if scheduled_at
 
               executed_locally = execute_async? && @capsule&.create_thread(state)
               unless executed_locally
-                state[:count] = job_id_to_active_jobs.values_at(*executions_by_queue_and_scheduled_at.map(&:active_job_id)).count { |active_job| send_notify?(active_job) }
+                state[:count] = job_id_to_active_jobs.values_at(*jobs_by_queue_and_scheduled_at.map(&:active_job_id)).count { |active_job| send_notify?(active_job) }
                 Notifier.notify(state) unless state[:count].zero?
               end
             end
@@ -148,43 +142,32 @@ module GoodJob
         will_retry_inline = will_execute_inline && CurrentThread.job&.active_job_id == active_job.job_id && !CurrentThread.retry_now
 
         if will_retry_inline
-          execution = GoodJob::Job.enqueue(
+          job = GoodJob::Job.enqueue(
             active_job,
             scheduled_at: scheduled_at
           )
         elsif will_execute_inline
-          execution = GoodJob::Job.enqueue(
+          job = GoodJob::Job.enqueue(
             active_job,
             scheduled_at: scheduled_at,
             create_with_advisory_lock: true
           )
-          begin
-            result = @capsule.tracker.register { execution.perform(lock_id: @capsule.tracker.id_for_lock) }
-
-            retried_execution = result.retried
-            while retried_execution && (retried_execution.scheduled_at.nil? || retried_execution.scheduled_at <= Time.current)
-              execution = retried_execution
-              result = @capsule.tracker.register { execution.perform(lock_id: @capsule.tracker.id_for_lock) }
-              retried_execution = result.retried
+          InlineBuffer.perform_now_or_defer do
+            @capsule.tracker.register do
+              perform_inline(job, notify: send_notify?(active_job))
             end
-
-            Notifier.notify(retried_execution.job_state) if retried_execution&.scheduled_at && retried_execution.scheduled_at > Time.current && send_notify?(active_job)
-          ensure
-            execution.advisory_unlock
-            execution.run_callbacks(:perform_unlocked)
           end
-          raise result.unhandled_error if result.unhandled_error
         else
-          execution = GoodJob::Job.enqueue(
+          job = GoodJob::Job.enqueue(
             active_job,
             scheduled_at: scheduled_at
           )
 
-          executed_locally = execute_async? && @capsule&.create_thread(execution.job_state)
-          Notifier.notify(execution.job_state) if !executed_locally && send_notify?(active_job)
+          executed_locally = execute_async? && @capsule&.create_thread(job.job_state)
+          Notifier.notify(job.job_state) if !executed_locally && send_notify?(active_job)
         end
 
-        execution
+        job
       end
     end
 
@@ -250,5 +233,28 @@ module GoodJob
 
       !(active_job.good_job_notify == false || (active_job.class.good_job_notify == false && active_job.good_job_notify.nil?))
     end
+
+    # @param job [GoodJob::Job] the job to perform, which must be enqueued and advisory locked already
+    # @param notify [Boolean] whether to send a NOTIFY event for a retried job
+    def perform_inline(job, notify: true)
+      result = nil
+      retried_job = nil
+
+      loop do
+        result = job.perform(lock_id: @capsule.tracker.id_for_lock)
+        retried_job = result.retried_job
+        break if retried_job.nil? || retried_job.scheduled_at.nil? || retried_job.scheduled_at > Time.current
+
+        job = retried_job
+      end
+
+      Notifier.notify(retried_job.job_state) if notify && retried_job&.scheduled_at && retried_job.scheduled_at > Time.current
+      result
+    ensure
+      job.advisory_unlock
+      job.run_callbacks(:perform_unlocked)
+
+      raise result.unhandled_error if result.unhandled_error
+    end
   end
 end

data/lib/good_job/capsule_tracker.rb

@@ -57,7 +57,7 @@ module GoodJob # :nodoc:
         if @record
           @record.refresh_if_stale
         else
-          @record = GoodJob::Process.create_record(id: @record_id)
+          @record = GoodJob::Process.find_or_create_record(id: @record_id)
           create_refresh_task
         end
         value = @record&.id
@@ -89,7 +89,7 @@ module GoodJob # :nodoc:
               @advisory_locked_connection = WeakRef.new(@record.class.connection)
             end
           else
-            @record = GoodJob::Process.create_record(id: @record_id, with_advisory_lock: true)
+            @record = GoodJob::Process.find_or_create_record(id: @record_id, with_advisory_lock: true)
             @advisory_locked_connection = WeakRef.new(@record.class.connection)
             create_refresh_task
           end

data/lib/good_job/configuration.rb

@@ -35,8 +35,6 @@ module GoodJob
     DEFAULT_DASHBOARD_LIVE_POLL_ENABLED = true
     # Default enqueue_after_transaction_commit
     DEFAULT_ENQUEUE_AFTER_TRANSACTION_COMMIT = false
-    # Default smaller_number_is_higher_priority
-    DEFAULT_SMALLER_NUMBER_IS_HIGHER_PRIORITY = true
 
     def self.validate_execution_mode(execution_mode)
       raise ArgumentError, "GoodJob execution mode must be one of #{EXECUTION_MODES.join(', ')}. It was '#{execution_mode}' which is not valid." unless execution_mode.in?(EXECUTION_MODES)
@@ -150,11 +148,10 @@ module GoodJob
     # poll (using this interval) for new queued jobs to execute.
     # @return [Integer]
     def poll_interval
-      interval = (
+      interval =
         options[:poll_interval] ||
-          rails_config[:poll_interval] ||
-          env['GOOD_JOB_POLL_INTERVAL']
-      )
+        rails_config[:poll_interval] ||
+        env['GOOD_JOB_POLL_INTERVAL']
 
       if interval
         interval.to_i
@@ -348,12 +345,6 @@ module GoodJob
       DEFAULT_ENABLE_LISTEN_NOTIFY
     end
 
-    def smaller_number_is_higher_priority
-      return rails_config[:smaller_number_is_higher_priority] unless rails_config[:smaller_number_is_higher_priority].nil?
-
-      DEFAULT_SMALLER_NUMBER_IS_HIGHER_PRIORITY
-    end
-
     def dashboard_default_locale
       rails_config[:dashboard_default_locale] || DEFAULT_DASHBOARD_DEFAULT_LOCALE
     end
@@ -386,6 +377,16 @@ module GoodJob
       end || false
     end
 
+    # Whether to take an advisory lock on the process record in the notifier reactor.
+    # @return [Boolean]
+    def advisory_lock_heartbeat
+      return options[:advisory_lock_heartbeat] unless options[:advisory_lock_heartbeat].nil?
+      return rails_config[:advisory_lock_heartbeat] unless rails_config[:advisory_lock_heartbeat].nil?
+      return ActiveModel::Type::Boolean.new.cast(env['GOOD_JOB_ADVISORY_LOCK_HEARTBEAT']) unless env['GOOD_JOB_ADVISORY_LOCK_HEARTBEAT'].nil?
+
+      Rails.env.development?
+    end
+
     private
 
     def rails_config

data/lib/good_job/cron_manager.rb

@@ -55,9 +55,7 @@ module GoodJob # :nodoc:
     # @param timeout [Numeric, nil] Unused but retained for compatibility
     def shutdown(timeout: nil) # rubocop:disable Lint/UnusedMethodArgument
       @running = false
-      @tasks.each do |_cron_key, task|
-        task.cancel
-      end
+      @tasks.each_value(&:cancel)
       @tasks.clear
     end
 

data/lib/good_job/current_thread.rb

@@ -15,7 +15,7 @@ module GoodJob
       error_on_retry_stopped
       job
       execution_interrupted
-      execution_retried
+      retried_job
       retry_now
     ].freeze
 
@@ -61,11 +61,11 @@ module GoodJob
     #   @return [Boolean, nil]
     thread_mattr_accessor :execution_interrupted
 
-    # @!attribute [rw] execution_retried
+    # @!attribute [rw] retried_job
     #   @!scope class
     #   Execution Retried
-    #   @return [Boolean, nil]
-    thread_mattr_accessor :execution_retried
+    #   @return [GoodJob::Job, nil]
+    thread_mattr_accessor :retried_job
 
     # @!attribute [rw] retry_now
     #   @!scope class

data/lib/good_job/notifier/process_heartbeat.rb

@@ -14,9 +14,10 @@ module GoodJob # :nodoc:
 
       # Registers the current process.
       def register_process
+        @advisory_lock_heartbeat = GoodJob.configuration.advisory_lock_heartbeat
         GoodJob::Process.override_connection(connection) do
           GoodJob::Process.cleanup
-          @capsule.tracker.register(with_advisory_lock: true)
+          @capsule.tracker.register(with_advisory_lock: @advisory_lock_heartbeat)
         end
       end
 
@@ -33,7 +34,7 @@ module GoodJob # :nodoc:
       # Deregisters the current process.
       def deregister_process
         GoodJob::Process.override_connection(connection) do
-          @capsule.tracker.unregister(with_advisory_lock: true)
+          @capsule.tracker.unregister(with_advisory_lock: @advisory_lock_heartbeat)
         end
       end
     end

data/lib/good_job/version.rb

@@ -2,7 +2,7 @@
 
 module GoodJob
   # GoodJob gem version.
-  VERSION = '4.1.0'
+  VERSION = '4.2.0'
 
   # GoodJob version as Gem::Version object
   GEM_VERSION = Gem::Version.new(VERSION)