good_job 4.23.0 → 4.24.0

data/app/models/good_job/job/lockable.rb

@@ -1,3 +1,4 @@
+# typed: false
 # frozen_string_literal: true
 
 module GoodJob
@@ -8,6 +9,11 @@ module GoodJob
     module Lockable
       extend ActiveSupport::Concern
 
+      # Seconds to wait between attempts to release a claim after a connection failure.
+      RELEASE_CLAIM_RETRY_INTERVAL = 5
+      # Log a warning on the first failed release and then every this many attempts.
+      RELEASE_CLAIM_RETRY_WARNING_EVERY = 10
+
       class_methods do
         # Claims a job by acquiring a session-level advisory lock via the CTE
         # query, and records the lock acquisition for phantom re-entrancy cleanup.
@@ -20,13 +26,17 @@ module GoodJob
         def with_advisory_lock_claim(select_limit: nil, &block)
           raise ArgumentError, "Must provide a block" unless block
 
-          advisory_lock(select_limit: select_limit) do |records|
-            record = records.first
-            begin
+          record = nil
+          begin
+            advisory_lock(select_limit: select_limit) do |records|
+              record = records.first
               yield(record)
-            ensure
-              record&.run_callbacks(:perform_unlocked)
             end
+          ensure
+            # Runs after the advisory lock is released. A failed completion leaves the
+            # row lock in the database and may leave unsaved completion fields on the
+            # record, which batch callbacks would act on.
+            record.run_callbacks(:perform_unlocked) if record && (record.destroyed? || record.locked_by_id_in_database.nil?)
           end
         end
 
@@ -40,30 +50,7 @@ module GoodJob
         # @yield [GoodJob::Job, nil] The claimed record, or nil if none found
         # @return [Object] The return value of the block
         def with_skip_locked_claim(locked_by_id:, locked_at:, lock_type:, &block)
-          raise ArgumentError, "Must provide a block" unless block
-
-          candidate_sql = select(:id).lock("FOR NO KEY UPDATE SKIP LOCKED").to_sql
-          materialized = supports_cte_materialization_specifiers? ? "MATERIALIZED " : ""
-
-          sql = <<~SQL.squish
-            WITH candidate AS #{materialized}(#{candidate_sql})
-            UPDATE #{quoted_table_name}
-            SET locked_by_id = ?,
-                locked_at = ?,
-                lock_type = ?
-            FROM candidate
-            WHERE #{quoted_table_name}.id = candidate.id
-            RETURNING #{quoted_table_name}.*
-          SQL
-
-          record = unscoped.find_by_sql([sql, locked_by_id, locked_at, lock_types[lock_type.to_s]]).first
-
-          begin
-            unscoped { yield(record) }
-          ensure
-            record.update(locked_by_id: nil, locked_at: nil, lock_type: nil) if record && !record.destroyed? && record.locked_by_id.present?
-            record&.run_callbacks(:perform_unlocked)
-          end
+          with_row_lock_claim(locked_by_id: locked_by_id, locked_at: locked_at, lock_type: lock_type, &block)
         end
 
         # Atomically claims a job using SELECT FOR NO KEY UPDATE SKIP LOCKED with an
@@ -77,13 +64,21 @@ module GoodJob
         # @yield [GoodJob::Job, nil] The claimed record, or nil if none found
         # @return [Object] The return value of the block
         def with_hybrid_lock_claim(locked_by_id:, locked_at:, lock_type:, &block)
-          raise ArgumentError, "Must provide a block" unless block
+          with_row_lock_claim(locked_by_id: locked_by_id, locked_at: locked_at, lock_type: lock_type, advisory: true, &block)
+        end
 
-          lease_connection # sticky connection; advisory lock must outlive this statement
+        private
 
+        def with_row_lock_claim(locked_by_id:, locked_at:, lock_type:, advisory: false, &block)
+          raise ArgumentError, "Must provide a block" unless block
+
+          connection = lease_connection if advisory # retain the session holding the advisory lock
           candidate_sql = select(:id).lock("FOR NO KEY UPDATE SKIP LOCKED").to_sql
-          advisory_lock_expr = "('x' || substr(md5(#{_quoted_table_name_string} || '-' || id::text), 1, 16))::bit(64)::bigint"
           materialized = supports_cte_materialization_specifiers? ? "MATERIALIZED " : ""
+          candidate_filter = if advisory
+                               advisory_key = advisory_lock_bigint_sql("#{_quoted_table_name_string} || '-' || id::text")
+                               "WHERE pg_try_advisory_lock(#{advisory_key})"
+                             end
 
           sql = <<~SQL.squish
             WITH candidate AS #{materialized}(#{candidate_sql})
@@ -91,26 +86,57 @@ module GoodJob
             SET locked_by_id = ?,
                 locked_at = ?,
                 lock_type = ?
-            FROM (
-              SELECT id FROM candidate
-              WHERE pg_try_advisory_lock(#{advisory_lock_expr})
-            ) AS locked
+            FROM (SELECT id FROM candidate #{candidate_filter}) AS locked
             WHERE #{quoted_table_name}.id = locked.id
             RETURNING #{quoted_table_name}.*
           SQL
 
           record = unscoped.find_by_sql([sql, locked_by_id, locked_at, lock_types[lock_type.to_s]]).first
-          record_advisory_lock(lease_connection, record.lockable_column_key, cte: true) if record
+          record_advisory_lock(connection, record.lockable_column_key, cte: true) if advisory && record
 
+          completed = false
           begin
-            unscoped { yield(record) }
+            result = unscoped { yield(record) }
+            completed = true
+            result
           ensure
-            if record
-              record.advisory_unlock
-              record.update(locked_by_id: nil, locked_at: nil, lock_type: nil) if !record.destroyed? && record.locked_by_id.present?
+            begin
+              record.advisory_unlock(connection: connection) if advisory && record
+            ensure
+              # A failed completion may have cleared the attributes in memory only.
+              if record && (!completed || (!record.destroyed? && record.locked_by_id_in_database.present?))
+                released = release_lock_claim(record, locked_by_id: locked_by_id, locked_at: locked_at)
+                completed &&= released
+              end
+            end
+            record&.run_callbacks(:perform_unlocked) if completed
+          end
+        end
+
+        def release_lock_claim(record, locked_by_id:, locked_at:)
+          transaction do
+            # Match the original claim, including its time, so a newer execution is untouched.
+            released = unscoped.where(id: record.id, locked_by_id: locked_by_id, locked_at: locked_at)
+                               .update_all(locked_by_id: nil, locked_at: nil, lock_type: nil) # rubocop:disable Rails/SkipsModelValidations
+            if released.positive?
+              GoodJob::ConcurrencyClaim.release_job(record.id) if GoodJob::ConcurrencyClaim.table_exists?
+              record.reload
             end
-            record&.run_callbacks(:perform_unlocked)
+            released.positive?
           end
+        rescue StandardError => e
+          connection_errors = %w[ActiveRecord::ConnectionNotEstablished ActiveRecord::ConnectionFailed PG::ConnectionBad PG::UnableToSend].filter_map(&:safe_constantize)
+          cause = e.is_a?(ActiveRecord::StatementInvalid) ? e.cause : nil # older Rails wraps PG connection errors
+          raise unless connection_errors.any? { |klass| e.is_a?(klass) || cause.is_a?(klass) }
+          # Once the process is exiting, its stale process record lets cleanup release the claim.
+          return false if Thread.current.status == "aborting" || GoodJob.current_thread_shutting_down?
+
+          # Keep the worker registered until its claim can be released. Otherwise a
+          # live process can keep the abandoned job locked indefinitely.
+          attempts = (attempts || 0) + 1
+          GoodJob.logger.warn("GoodJob could not release the claim on job #{record.id} (attempt #{attempts}): #{e.class}: #{e.message}. Retrying every #{RELEASE_CLAIM_RETRY_INTERVAL} seconds.") if attempts == 1 || (attempts % RELEASE_CLAIM_RETRY_WARNING_EVERY).zero?
+          sleep RELEASE_CLAIM_RETRY_INTERVAL
+          retry
         end
       end
     end

data/app/models/good_job/job.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module GoodJob
@@ -72,7 +73,7 @@ module GoodJob
     has_many :executions, class_name: 'GoodJob::Execution', foreign_key: 'active_job_id', primary_key: "id", inverse_of: :job, dependent: :delete_all
     has_many :concurrency_claims, class_name: 'GoodJob::ConcurrencyClaim', primary_key: :id, inverse_of: false, dependent: nil
 
-    before_create -> { self.id = active_job_id }, if: -> { active_job_id.present? }
+    before_create ->(job) { job.id = job.active_job_id }, if: -> { active_job_id.present? }
 
     # Get Jobs finished before the given timestamp.
     # @!method finished_before(timestamp)
@@ -582,7 +583,7 @@ module GoodJob
                            when String
                              klass.constantize
                            when Job
-                             klass.job_class.constantize
+                             klass.job_class&.constantize
                            else
                              klass
                            end
@@ -685,13 +686,14 @@ module GoodJob
           active_job.executions = (active_job.executions || 0) + 1
 
           begin
-            error_class, error_message = error.split(ERROR_MESSAGE_SEPARATOR).map(&:strip)
-            error = error_class.constantize.new(error_message)
+            error_class, error_message = error.to_s.split(ERROR_MESSAGE_SEPARATOR).map(&:strip)
+            error = error_class ? error_class.constantize.new(error_message) : StandardError.new(error)
           rescue StandardError
             error = StandardError.new(error)
           end
 
-          new_active_job = nil
+          # Populated by a block that may be deferred until after the transaction commits
+          new_active_jobs = []
 
           transaction do
             Job.defer_after_commit_maybe(active_job.class) do
@@ -701,7 +703,7 @@ module GoodJob
 
                 # NOTE: I18n.with_locale necessary until fixed in rails https://github.com/rails/rails/pull/52121
                 I18n.with_locale(active_job.locale) do
-                  new_active_job = active_job.retry_job(wait: 0, error: error)
+                  new_active_jobs << active_job.retry_job(wait: 0, error: error)
                 end
               end
             end
@@ -709,7 +711,7 @@ module GoodJob
             save!
           end
 
-          new_active_job
+          new_active_jobs.first
         end
       end
     end
@@ -780,8 +782,7 @@ module GoodJob
 
         job_performed_at = Time.current
         monotonic_start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-        execution = nil
-        result = GoodJob::CurrentThread.within do |current_thread|
+        execution, result = GoodJob::CurrentThread.within do |current_thread|
           current_thread.reset
           current_thread.job = self
 
@@ -794,16 +795,16 @@ module GoodJob
             self.error_event = ErrorEvents::INTERRUPTED
             monotonic_duration = (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - monotonic_start).seconds
 
-            execution_attrs = {
+            interrupted_execution_attrs = {
               error: interrupt_error_string,
               finished_at: job_performed_at,
               error_event: error_event,
               duration: monotonic_duration,
             }
-            executions.where(finished_at: nil).where.not(performed_at: nil).update_all(execution_attrs) # rubocop:disable Rails/SkipsModelValidations
+            executions.where(finished_at: nil).where.not(performed_at: nil).update_all(interrupted_execution_attrs) # rubocop:disable Rails/SkipsModelValidations
           end
 
-          transaction do
+          new_execution = transaction do
             execution_attrs = {
               job_class: job_class,
               queue_name: queue_name,
@@ -822,11 +823,12 @@ module GoodJob
               job_attrs[:lock_type] = :advisory if self.class.lock_type_column_exists?
             end
 
-            execution = executions.create!(execution_attrs)
+            created_execution = executions.create!(execution_attrs)
             update!(job_attrs)
+            created_execution
           end
 
-          ActiveSupport::Notifications.instrument("perform_job.good_job", { job: self, execution: execution, process_id: current_thread.process_id, thread_name: current_thread.thread_name }) do |instrument_payload|
+          execution_result = ActiveSupport::Notifications.instrument("perform_job.good_job", { job: self, execution: new_execution, process_id: current_thread.process_id, thread_name: current_thread.thread_name }) do |instrument_payload|
             value = ActiveJob::Base.execute(active_job_data)
             active_job = current_thread.active_job
 
@@ -872,6 +874,8 @@ module GoodJob
             )
             ExecutionResult.new(value: nil, active_job: active_job, unhandled_error: e, error_event: error_event)
           end
+
+          [new_execution, execution_result]
         end
 
         job_attributes = { locked_by_id: nil, locked_at: nil }
@@ -1019,8 +1023,8 @@ module GoodJob
     end
 
     def continue_discard_or_finish_batch
-      batch._continue_discard_or_finish(self) if batch.present?
-      callback_batch._continue_discard_or_finish if callback_batch.present?
+      batch&._continue_discard_or_finish(self)
+      callback_batch&._continue_discard_or_finish
     end
 
     def active_job_data

data/app/models/good_job/process.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 require 'socket'
@@ -28,7 +29,7 @@ module GoodJob # :nodoc:
                        end
                      when /darwin|bsd/
                        lambda do |pid|
-                         `ps -o pid,rss -p #{pid.to_i}`.lines.last.split.last.to_i
+                         `ps -o pid,rss -p #{pid.to_i}`.lines.last&.split&.last.to_i
                        end
                      else
                        ->(_pid) { 0 }
@@ -92,12 +93,11 @@ module GoodJob # :nodoc:
       }
       attributes[:lock_type] = :advisory if with_advisory_lock
 
-      record = nil
       transaction do
         record = create!(attributes)
         record.advisory_lock!(connection: advisory_lock_connection) if with_advisory_lock
+        record
       end
-      record
     rescue ActiveRecord::RecordNotUnique
       find_by(id: id).tap do |existing_record|
         next unless existing_record
@@ -119,7 +119,7 @@ module GoodJob # :nodoc:
         proctitle: $PROGRAM_NAME,
         preserve_job_records: GoodJob.preserve_job_records,
         retry_on_unhandled_error: GoodJob.retry_on_unhandled_error,
-        schedulers: GoodJob::Scheduler.instances.map(&:stats),
+        schedulers: GoodJob::Scheduler.instances.reject(&:shutdown?).map(&:stats),
         cron_enabled: GoodJob.configuration.enable_cron?,
         total_succeeded_executions_count: GoodJob::Scheduler.instances.sum { |scheduler| scheduler.stats.fetch(:succeeded_executions_count) },
         total_errored_executions_count: GoodJob::Scheduler.instances.sum { |scheduler| scheduler.stats.fetch(:errored_executions_count) },
@@ -136,7 +136,7 @@ module GoodJob # :nodoc:
       update(state: state, updated_at: Time.current)
     rescue ActiveRecord::RecordNotFound
       @new_record = true
-      self.created_at = self.updated_at = nil
+      assign_attributes(created_at: nil, updated_at: nil)
       id_will_change!
       state_will_change!
       save

data/app/models/good_job/setting.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module GoodJob
@@ -38,7 +39,8 @@ module GoodJob
       enabled_setting.save!
 
       disabled_setting = GoodJob::Setting.find_by(key: CRON_KEYS_DISABLED)
-      return unless disabled_setting&.value&.include?(key_string)
+      return unless disabled_setting
+      return unless disabled_setting.value&.include?(key_string)
 
       disabled_setting.value.delete(key_string)
       disabled_setting.save!
@@ -47,7 +49,8 @@ module GoodJob
     def self.cron_key_disable(key)
       enabled_setting = GoodJob::Setting.find_by(key: CRON_KEYS_ENABLED)
       key_string = key.to_s
-      if enabled_setting&.value&.include?(key_string)
+      enabled_keys = enabled_setting&.value
+      if enabled_setting && enabled_keys&.include?(key_string)
         enabled_setting.value.delete(key_string)
         enabled_setting.save!
       end

data/config/brakeman.ignore

@@ -49,13 +49,13 @@
     {
       "warning_type": "Dangerous Eval",
       "warning_code": 13,
-      "fingerprint": "f7e62770ef61ea7bb2b3a0a8c19b3fa6f869fbaa51322cb56eb86f21b384ba5a",
+      "fingerprint": "7697b92be7ba0f505bd3a1b3aa7b555812687cab2008a005e94b6755e6061362",
       "check_name": "Evaluation",
       "message": "Dynamic string evaluated as code",
       "file": "lib/good_job/log_subscriber.rb",
-      "line": 365,
+      "line": 366,
       "link": "https://brakemanscanner.org/docs/warning_types/dangerous_eval/",
-      "code": "class_eval(\"        def #{level}(progname = nil, tags: [], &block)   # def info(progname = nil, tags: [], &block)\\n          return unless logger                           #   return unless logger\\n                                                         #\\n          tag_logger(*tags) do                           #   tag_logger(*tags) do\\n            logger.#{level}(progname, &block)            #     logger.info(progname, &block)\\n          end                                            #   end\\n        end                                              #\\n\", \"lib/good_job/log_subscriber.rb\", (365 + 1))",
+      "code": "class_eval(\"        def #{level}(progname = nil, tags: [], &block)   # def info(progname = nil, tags: [], &block)\\n          return unless logger                           #   return unless logger\\n                                                         #\\n          tag_logger(*tags) do                           #   tag_logger(*tags) do\\n            logger.#{level}(progname, &block)            #     logger.info(progname, &block)\\n          end                                            #   end\\n        end                                              #\\n\", \"lib/good_job/log_subscriber.rb\", (366 + 1))",
       "render_path": null,
       "location": {
         "type": "method",
@@ -119,25 +119,25 @@
     {
       "warning_type": "SQL Injection",
       "warning_code": 0,
-      "fingerprint": "e3cc5489d3e3e81f35347b7530d5743fbac8491ab612ceec0d034e22656269ed",
+      "fingerprint": "3f2f0feed3442f5946899d5884a014ecb86894269ac9685db90eeeb6f3a06f48",
       "check_name": "SQL",
       "message": "Possible SQL injection",
       "file": "app/models/good_job/job/lockable.rb",
-      "line": 102,
+      "line": 80,
       "link": "https://brakemanscanner.org/docs/warning_types/sql_injection/",
-      "code": "unscoped.find_by_sql([\"WITH candidate AS #{(\"MATERIALIZED \" or \"\")}(#{select(:id).lock(\"FOR NO KEY UPDATE SKIP LOCKED\").to_sql})\\nUPDATE #{quoted_table_name}\\nSET locked_by_id = ?,\\n    locked_at = ?,\\n    lock_type = ?\\nFROM (\\n  SELECT id FROM candidate\\n  WHERE pg_try_advisory_lock(#{\"('x' || substr(md5(#{_quoted_table_name_string} || '-' || id::text), 1, 16))::bit(64)::bigint\"})\\n) AS locked\\nWHERE #{quoted_table_name}.id = locked.id\\nRETURNING #{quoted_table_name}.*\\n\".squish, locked_by_id, locked_at, lock_types[lock_type.to_s]])",
+      "code": "unscoped.find_by_sql([\"WITH candidate AS #{(\"MATERIALIZED \" or \"\")}(#{select(:id).lock(\"FOR NO KEY UPDATE SKIP LOCKED\").to_sql})\\nUPDATE #{quoted_table_name}\\nSET locked_by_id = ?,\\n    locked_at = ?,\\n    lock_type = ?\\nFROM (SELECT id FROM candidate #{if advisory then\n  advisory_key = advisory_lock_bigint_sql(\"#{_quoted_table_name_string} || '-' || id::text\")\n  \"WHERE pg_try_advisory_lock(#{advisory_lock_bigint_sql(\"#{_quoted_table_name_string} || '-' || id::text\")})\"\nend}) AS locked\\nWHERE #{quoted_table_name}.id = locked.id\\nRETURNING #{quoted_table_name}.*\\n\".squish, locked_by_id, locked_at, lock_types[lock_type.to_s]])",
       "render_path": null,
       "location": {
         "type": "method",
         "class": "GoodJob::Job",
-        "method": "with_hybrid_lock_claim"
+        "method": "with_row_lock_claim"
       },
-      "user_input": "_quoted_table_name_string",
+      "user_input": "if advisory then\n  advisory_key = advisory_lock_bigint_sql(\"#{_quoted_table_name_string} || '-' || id::text\")\n  \"WHERE pg_try_advisory_lock(#{advisory_lock_bigint_sql(\"#{_quoted_table_name_string} || '-' || id::text\")})\"\nend",
       "confidence": "Weak",
       "cwe_id": [
         89
       ],
-      "note": "Table name is quoted via quoted_table_name (Rails); advisory lock expression uses _quoted_table_name_string (escaped); candidate SQL is Rails-generated; values are parameterized bindings."
+      "note": "Claim query refactored into with_row_lock_claim. Table names are Rails-quoted; candidate SQL is Rails-generated; the optional advisory predicate uses only the configured hash and an escaped table name. All varying claim values are bound. No untrusted SQL input."
     }
   ],
   "brakeman_version": "8.0.4"

data/lib/active_job/queue_adapters/good_job_adapter.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module ActiveJob # :nodoc:

data/lib/generators/good_job/install_generator.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 require 'rails/generators'

data/lib/generators/good_job/update_generator.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 require 'rails/generators'

data/lib/good_job/active_job_extensions/batches.rb

@@ -1,3 +1,4 @@
+# typed: false
 # frozen_string_literal: true
 
 module GoodJob

data/lib/good_job/active_job_extensions/concurrency.rb

@@ -1,3 +1,4 @@
+# typed: false
 # frozen_string_literal: true
 
 module GoodJob

data/lib/good_job/active_job_extensions/interrupt_errors.rb

@@ -1,3 +1,4 @@
+# typed: false
 # frozen_string_literal: true
 
 module GoodJob

data/lib/good_job/active_job_extensions/labels.rb

@@ -1,3 +1,4 @@
+# typed: false
 # frozen_string_literal: true
 
 module GoodJob

data/lib/good_job/active_job_extensions/notify_options.rb

@@ -1,3 +1,4 @@
+# typed: false
 # frozen_string_literal: true
 
 module GoodJob

data/lib/good_job/adapter/inline_buffer.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 require 'active_support/core_ext/module/attribute_accessors_per_thread'

data/lib/good_job/adapter.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module GoodJob
@@ -67,7 +68,6 @@ module GoodJob
           end
         end
 
-        inline_jobs = []
         lock_strategy = GoodJob::Job.effective_lock_strategy
         tracker_registered = false
         lock_id = nil
@@ -78,7 +78,7 @@ module GoodJob
         end
 
         begin
-          GoodJob::Job.transaction(requires_new: true, joinable: false) do
+          inline_jobs = GoodJob::Job.transaction(requires_new: true, joinable: false) do
             results = if GoodJob::Ractors.main?
                         column_names = GoodJob::Job.column_names
                         job_attributes = jobs.map { |job| job.attributes.slice(*column_names) }
@@ -96,20 +96,20 @@ module GoodJob
               job.instance_variable_set(:@new_record, false) if job_id_to_provider_job_id[job.active_job_id]
             end
             jobs = jobs.select(&:persisted?) # prune unpersisted jobs
-
-            if execute_inline?
-              inline_jobs = jobs.select { |job| job.scheduled_at.nil? || job.scheduled_at <= Time.current }
-              if lock_strategy != :advisory && lock_id && inline_jobs.any?
-                GoodJob::Job.where(id: inline_jobs.map(&:id)).update_all( # rubocop:disable Rails/SkipsModelValidations
-                  locked_by_id: lock_id, locked_at: current_time, lock_type: GoodJob::Job.lock_types[lock_strategy.to_s]
-                )
-                inline_jobs.each { |j| j.assign_attributes(locked_by_id: lock_id, locked_at: current_time, lock_type: lock_strategy) }
-              end
-              case lock_strategy
-              when :advisory, :hybrid
-                inline_jobs.each(&:advisory_lock!)
-              end
+            next [] unless execute_inline?
+
+            jobs_to_inline = jobs.select { |job| job.scheduled_at.nil? || job.scheduled_at <= Time.current }
+            if lock_strategy != :advisory && lock_id && jobs_to_inline.any?
+              GoodJob::Job.where(id: jobs_to_inline.map(&:id)).update_all( # rubocop:disable Rails/SkipsModelValidations
+                locked_by_id: lock_id, locked_at: current_time, lock_type: GoodJob::Job.lock_types[lock_strategy.to_s]
+              )
+              jobs_to_inline.each { |j| j.assign_attributes(locked_by_id: lock_id, locked_at: current_time, lock_type: lock_strategy) }
+            end
+            case lock_strategy
+            when :advisory, :hybrid
+              jobs_to_inline.each(&:advisory_lock!)
             end
+            jobs_to_inline
           end
 
           if inline_jobs.any?
@@ -150,7 +150,7 @@ module GoodJob
 
               executed_locally = execute_async? && create_capsule_thread(state)
               unless executed_locally
-                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) }
+                state[:count] = jobs_by_queue_and_scheduled_at.count { |job| send_notify?(job_id_to_active_jobs[job.active_job_id]) }
                 Notifier.notify(state) unless state[:count].zero?
               end
             end
@@ -185,7 +185,8 @@ module GoodJob
         elsif will_execute_inline
           lock_strategy = GoodJob::Job.effective_lock_strategy
           lock_id = register_tracker
-          tracker_registered = true
+          # Unregistered by whichever of the deferred block or the rescue runs first
+          tracker_registered = Concurrent::AtomicBoolean.new(true)
           begin
             job = case lock_strategy
                   when :skiplocked
@@ -198,14 +199,10 @@ module GoodJob
             InlineBuffer.perform_now_or_defer do
               perform_inline(job, notify: send_notify?(active_job), already_claimed: lock_strategy != :advisory, advisory_unlock: lock_strategy != :skiplocked)
             ensure
-              unregister_tracker if tracker_registered
-              tracker_registered = false
+              unregister_tracker if tracker_registered.make_false
             end
           rescue StandardError
-            if tracker_registered
-              unregister_tracker
-              tracker_registered = false
-            end
+            unregister_tracker if tracker_registered.make_false
             raise
           end
         else
@@ -348,16 +345,12 @@ module GoodJob
     # @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, already_claimed: false, advisory_unlock: true)
-      result = nil
-      retried_job = nil
-
-      loop do
-        result = job.perform(lock_id: tracker_id_for_lock, already_claimed: already_claimed)
-        already_claimed = false # only skip lock-write on first iteration
-        retried_job = result.retried_job
-        break if retried_job.nil? || retried_job.scheduled_at.nil? || retried_job.scheduled_at > Time.current
-
+      result = job.perform(lock_id: tracker_id_for_lock, already_claimed: already_claimed)
+      retried_job = result.retried_job
+      while retried_job&.scheduled_at && retried_job.scheduled_at <= Time.current
         job = retried_job
+        result = job.perform(lock_id: tracker_id_for_lock) # only skip lock-write on first iteration
+        retried_job = result.retried_job
       end
 
       Notifier.notify(retried_job.job_state) if notify && retried_job&.scheduled_at && retried_job.scheduled_at > Time.current

data/lib/good_job/bulk.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 require 'active_support/core_ext/module/attribute_accessors_per_thread'

data/lib/good_job/callable.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module GoodJob

data/lib/good_job/capsule.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module GoodJob
@@ -69,7 +70,10 @@ module GoodJob
     def restart(timeout: NONE)
       raise ArgumentError, "Capsule#restart cannot be called with a timeout of nil" if timeout.nil?
 
+      replaced_instances = [@notifier, @poller, @cron_manager, *@multi_scheduler&.schedulers].compact
       shutdown(timeout: timeout)
+      # Start creates new components, so unregister the replaced ones to let them be garbage collected
+      replaced_instances.each { |instance| instance.class.prune(instance) }
       start(force: true)
     end
 

data/lib/good_job/capsule_tracker.rb

@@ -1,5 +1,7 @@
+# typed: true
 # frozen_string_literal: true
 
+require "concurrent/atomic/atomic_boolean"
 require "concurrent/errors"
 require "concurrent/scheduled_task"
 
@@ -40,7 +42,6 @@ module GoodJob # :nodoc:
     # If UUID has not yet been persisted to the database, this method will make a query to insert or update it.
     # @return [String, nil]
     def id_for_lock
-      value = nil
       synchronize(with_connection: true) do
         next if @locks.zero?
 
@@ -50,9 +51,8 @@ module GoodJob # :nodoc:
           @record = GoodJob::Process.find_or_create_record(id: @record_id)
           create_refresh_task
         end
-        value = @record&.id
+        @record&.id
       end
-      value
     end
 
     # Whether the tracker has no active registrations and can be removed from {.instances}.
@@ -188,15 +188,15 @@ module GoodJob # :nodoc:
       delay ||= task_interval
       refresh_task = Concurrent::ScheduledTask.new(delay.to_f, executor: @executor) do
         Rails.application.executor.wrap do
-          acquired = false
+          acquired = Concurrent::AtomicBoolean.new(false)
           begin
             # Match notifier/job lock ordering: acquire a connection before the mutex.
             GoodJob::Process.connection_pool.with_connection do
-              acquired = true
+              acquired.make_true
               synchronize { renew(silent: true) if @locks.positive? }
             end
           rescue ActiveRecord::ConnectionTimeoutError
-            raise if acquired
+            raise if acquired.true?
           ensure
             synchronize do
               if @refresh_task.equal?(refresh_task)

data/lib/good_job/cleanup_tracker.rb

@@ -1,3 +1,4 @@
+# typed: true
 # frozen_string_literal: true
 
 module GoodJob # :nodoc: