good_job 4.14.2 → 4.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f0f62c12c0c19a4afd8f71d3dae19479ac4a7df6342ac399bf8e447fbbe8f5b
-  data.tar.gz: 75a2a8a282b0c28e370230397dfc5f1de470681b1d53cbb0dd6ee46384e87fe4
+  metadata.gz: d07cdaddabbb6f1966833ae6f79df8a61aef3959c3209ad64ed80e8896d7d56c
+  data.tar.gz: 555fdb53f3ba29885d46ac62bc2ab59a0f9cd13186a729c188e13101e7567634
 SHA512:
-  metadata.gz: ba1a959622762c21e723f6d406d30d8fda81d736560f3c710a7c363d8206697d0eb856dbe9ee865a340ad4f3d8db5354a707f78d695d0221fe1779ba07709c7b
-  data.tar.gz: 0bb8d09ca31aefe0e6da18096da53f5fdfc7e7be820afb54791b051f7ea29464c730aefb9eaeffaeaaa5fa3a6f5e029d158651fde41bd8876fd280e3fcd4269a
+  metadata.gz: f4a64d532756884282a5b5ff76b5fb4bc31ceb346f104cab837ef9c946f9a8b6373ae47bfff22d4cdf7785022711b4a2c9a632eb4f8a877fd19dfd674b62a495
+  data.tar.gz: 1310d23b3386534c4c5c11f14b2bc521e877a3856371a7b7fb8700f7d03b3a23ecfcc7fa63d4e667628057e2ac6d2c9364f8688788cee8e7538a4ac7216ef1d0

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [v4.15.0](https://github.com/bensheldon/good_job/tree/v4.15.0) (2026-04-09)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v4.14.2...v4.15.0)
+
+**Implemented enhancements:**
+
+- Add opt-in "FOR NO KEY UPDATE SKIP LOCKED" job lock strategy and hybrid strategy for online migration [\#1731](https://github.com/bensheldon/good_job/pull/1731) ([bensheldon](https://github.com/bensheldon))
+- Allow ordering by scheduled\_at instead of created\_at when dequeueing job [\#1645](https://github.com/bensheldon/good_job/pull/1645) ([lsylvester](https://github.com/lsylvester))
+- Allow `GoodJob.preserve_job_records` to take a lambda that is callable after each job executes [\#1640](https://github.com/bensheldon/good_job/pull/1640) ([bensheldon](https://github.com/bensheldon))
+
+**Merged pull requests:**
+
+- Fix JRuby in development lockfile, with test [\#1734](https://github.com/bensheldon/good_job/pull/1734) ([bensheldon](https://github.com/bensheldon))
+- Add herb to linter [\#1732](https://github.com/bensheldon/good_job/pull/1732) ([bensheldon](https://github.com/bensheldon))
+- Update development dependencies; apply Rubocop to\_h lints [\#1728](https://github.com/bensheldon/good_job/pull/1728) ([bensheldon](https://github.com/bensheldon))
+
 ## [v4.14.2](https://github.com/bensheldon/good_job/tree/v4.14.2) (2026-04-06)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v4.14.1...v4.14.2)

data/README.md

@@ -303,13 +303,13 @@ Available configuration options are:
 - `cron_graceful_restart_period` (integer) when restarting cron, attempt to re-enqueue jobs that would have been enqueued by cron within this time period (e.g. `1.minute`). This should match the expected downtime during deploys.
 - `enable_listen_notify` (boolean) whether to enqueue and read jobs with Postgres LISTEN/NOTIFY. Defaults to `true`. You can also set this with the environment variable `GOOD_JOB_ENABLE_LISTEN_NOTIFY`.
 - `cron` (hash) cron configuration. Defaults to `{}`. You can also set this as a JSON string with the environment variable `GOOD_JOB_CRON`
-- `cleanup_discarded_jobs` (boolean) whether to destroy discarded jobs when cleaning up preserved jobs using the `$ good_job cleanup_preserved_jobs` CLI command or calling `GoodJob.cleanup_preserved_jobs`. Defaults to `true`. Can also be set with  the environment variable `GOOD_JOB_CLEANUP_DISCARDED_JOBS`. _This configuration is only used when {GoodJob.preserve_job_records} is `true`._
-- `cleanup_preserved_jobs_before_seconds_ago` (integer) number of seconds to preserve jobs when using the `$ good_job cleanup_preserved_jobs` CLI command or calling `GoodJob.cleanup_preserved_jobs`. Defaults to `1209600` (14 days). Can also be set with  the environment variable `GOOD_JOB_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO`.  _This configuration is only used when {GoodJob.preserve_job_records} is `true`._
+- `cleanup_discarded_jobs` (boolean) whether to destroy discarded jobs when cleaning up preserved jobs using the `$ good_job cleanup_preserved_jobs` CLI command or calling `GoodJob.cleanup_preserved_jobs`. Defaults to `true`. Can also be set with the environment variable `GOOD_JOB_CLEANUP_DISCARDED_JOBS`.
+- `cleanup_preserved_jobs_before_seconds_ago` (integer) number of seconds to preserve jobs when using the `$ good_job cleanup_preserved_jobs` CLI command or calling `GoodJob.cleanup_preserved_jobs`. Defaults to `1209600` (14 days). Can also be set with  the environment variable `GOOD_JOB_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO`.
 - `cleanup_interval_jobs` (integer) Number of jobs a Scheduler will execute before cleaning up preserved jobs. Defaults to `1000`. Disable with `false`. Can also be set with  the environment variable `GOOD_JOB_CLEANUP_INTERVAL_JOBS` and disabled with `0`).
 - `cleanup_interval_seconds` (integer) Number of seconds a Scheduler will wait before cleaning up preserved jobs. Defaults to `600` (10 minutes). Disable with `false`. Can also be set with  the environment variable `GOOD_JOB_CLEANUP_INTERVAL_SECONDS` and disabled with `0`).
 - `inline_execution_respects_schedule` (boolean) Opt-in to future behavior of inline execution respecting scheduled jobs. Defaults to `false`.
 - `logger` ([Rails Logger](https://api.rubyonrails.org/classes/ActiveSupport/Logger.html)) lets you set a custom logger for GoodJob. It should be an instance of a Rails `Logger` (Default: `Rails.logger`).
-- `preserve_job_records` (boolean) keeps job records in your database even after jobs are completed. (Default: `true`)
+- `preserve_job_records` (boolean, symbol, or lambda) keeps job records in your database even after jobs are completed. If set to `true`, all job records are preserved. If set to `:on_unhandled_error`, only jobs that finished with an unhandled error are preserved. If set to a lambda, the lambda will be called with the error_event (e.g., `:discarded`, `:retry_stopped`, or `:unhandled`) and should return a boolean indicating whether to preserve the job. (Default: `true`)
 - `advisory_lock_heartbeat` (boolean) whether to use an advisory lock for the purpose of determining whether an execeution process is active. (Default `true` in Development; `false` in other environments)
 - `retry_on_unhandled_error` (boolean) causes jobs to be re-queued and retried if they raise an instance of `StandardError`. Be advised this may lead to jobs being repeated infinitely ([see below for more on retries](#retries)). Instances of `Exception`, like SIGINT, will *always* be retried, regardless of this attribute’s value. (Default: `false`)
 - `on_thread_error` (proc, lambda, or callable) will be called when there is an Exception. It can be useful for logging errors to bug tracking services, like Sentry or Airbrake. Example:
@@ -375,7 +375,7 @@ GoodJob.active_record_parent_class = "ApplicationRecord"
 The following options are also configurable via accessors, but you are encouraged to use the configuration attributes instead because these may be deprecated and removed in the future:
 
 - **`GoodJob.logger`** ([Rails Logger](https://api.rubyonrails.org/classes/ActiveSupport/Logger.html)) lets you set a custom logger for GoodJob. It should be an instance of a Rails `Logger`.
-- **`GoodJob.preserve_job_records`** (boolean) keeps job records in your database even after jobs are completed. (Default: `true`)
+- **`GoodJob.preserve_job_records`** (boolean, symbol, or lambda) keeps job records in your database even after jobs are completed. If set to `true`, all job records are preserved. If set to `:on_unhandled_error`, only jobs that finished with an unhandled error are preserved. If set to a lambda, the lambda will be called with Active Job instance, and if it exists, the exception the error_event (e.g., `:discarded`, `:retry_stopped`, or `:unhandled`) and should return a boolean indicating whether to preserve the job (e.g. `-> (active_job, error, error_event) { !(active_job.is_a(Turbo::Streams::BroadcastStreamJob) || error_event == :retry_stopped`). (Default: `true`)
 - **`GoodJob.retry_on_unhandled_error`** (boolean) causes jobs to be re-queued and retried if they raise an instance of `StandardError`. Be advised this may lead to jobs being repeated infinitely ([see below for more on retries](#retries)). Instances of `Exception`, like SIGINT, will *always* be retried, regardless of this attribute’s value. (Default: `false`)
 - **`GoodJob.on_thread_error`** (proc, lambda, or callable) will be called when there is an Exception. It can be useful for logging errors to bug tracking services, like Sentry or Airbrake.
 
@@ -1390,7 +1390,11 @@ To instead delete job records immediately after they are finished:
 
 ```ruby
 # config/initializers/good_job.rb
-config.good_job.preserve_job_records = false # defaults to true; can also be `false` or `:on_unhandled_error`
+config.good_job.preserve_job_records = false # defaults to true; can also be `false`, `:on_unhandled_error`, or a lambda that takes error_event argument
+
+# Example of using a lambda to preserve only discarded jobs
+config.good_job.preserve_job_records = ->(error_event) { error_event == :discarded }
+
 ```
 
 GoodJob will automatically delete preserved job records after 14 days. The retention period, as well as the frequency GoodJob checks for deletable records can be configured:
@@ -1433,6 +1437,53 @@ travel_to(15.minutes.from_now) { GoodJob.perform_inline }
 
 _Note: Rails `travel`/`travel_to` time helpers do not have millisecond precision, so you must leave at least 1 second between the schedule and time traveling for the job to be executed. This [behavior may change in Rails 7.1](https://github.com/rails/rails/pull/44088)._
 
+### SKIP LOCKED experimental mode
+
+By default, GoodJob claims jobs using PostgreSQL advisory locks. As an alternative, GoodJob can use `SELECT FOR UPDATE SKIP LOCKED` to claim jobs, which writes the lock state directly to the `good_jobs` table rather than relying on session-level advisory locks.
+
+Two strategies are available:
+
+- **`:skiplocked`** — Claims jobs using `SELECT FOR UPDATE SKIP LOCKED` only. No advisory locks are held. Compatible with PgBouncer in transaction mode.
+- **`:hybrid`** — Claims jobs using `SELECT FOR UPDATE SKIP LOCKED` and _also_ acquires a session-level advisory lock on the job. Intended for rolling deploys where some workers are still using the default `:advisory` strategy.
+
+Configure the lock strategy in an initializer or via environment variable:
+
+```ruby
+# config/initializers/good_job.rb
+GoodJob.configure do |config|
+  config.lock_strategy = :skiplocked
+end
+```
+
+```bash
+GOOD_JOB_LOCK_STRATEGY=skiplocked
+```
+
+All three strategies (`:advisory`, `:skiplocked`, `:hybrid`) can coexist safely during a rolling deploy — each strategy excludes jobs that are already locked by another worker regardless of which strategy that worker uses.
+
+#### PgBouncer configuration
+
+GoodJob's `:skiplocked` mode makes it compatible with PgBouncer in _transaction_ mode. In addition to setting the lock strategy, you must also disable the `LISTEN/NOTIFY` notifier (which requires a persistent connection) and rely on polling instead:
+
+```ruby
+# config/initializers/good_job.rb
+GoodJob.configure do |config|
+  config.lock_strategy = :skiplocked
+  config.enable_listen_notify = false
+  config.advisory_lock_heartbeat = false
+  config.poll_interval = 5 # seconds; tune based on your latency tolerance
+end
+```
+
+```bash
+GOOD_JOB_LOCK_STRATEGY=skiplocked
+GOOD_JOB_ENABLE_LISTEN_NOTIFY=false
+GOOD_JOB_ADVISORY_LOCK_HEARTBEAT=false
+GOOD_JOB_POLL_INTERVAL=5
+```
+
+With these four settings, GoodJob will not hold any session-level state between queries and is safe to use behind PgBouncer in transaction mode.
+
 ### PgBouncer compatibility
 
 GoodJob is not compatible with PgBouncer in _transaction_ mode, but is compatible with PgBouncer's _connection_ mode. GoodJob uses connection-based advisory locks and LISTEN/NOTIFY, both of which require full database connections.

data/app/controllers/good_job/cleaner_controller.rb

@@ -7,7 +7,7 @@ module GoodJob
 
       @discarded_jobs_grouped_by_exception =
         GoodJob::Job.discarded
-                    .select(<<-SQL.squish)
+                    .select(<<~SQL.squish)
                       SPLIT_PART(error, ': ', 1) AS exception_class,
                       count(id) AS failed,
                       COUNT(id) FILTER (WHERE "finished_at" > NOW() - INTERVAL '1 HOUR') AS last_1_hour,
@@ -21,7 +21,7 @@ module GoodJob
 
       @discarded_jobs_grouped_by_class =
         GoodJob::Job.discarded
-                    .select(<<-SQL.squish)
+                    .select(<<~SQL.squish)
                       job_class,
                       count(id) AS failed,
                       COUNT(*) FILTER (WHERE "finished_at" > NOW() - INTERVAL '1 HOUR') AS last_1_hour,

data/app/models/concerns/good_job/error_events.rb

@@ -5,14 +5,21 @@ module GoodJob
   module ErrorEvents
     extend ActiveSupport::Concern
 
+    INTERRUPTED = :interrupted
+    UNHANDLED = :unhandled
+    HANDLED = :handled
+    RETRIED = :retried
+    RETRY_STOPPED = :retry_stopped
+    DISCARDED = :discarded
+
     included do
       error_event_enum = {
-        interrupted: 0,
-        unhandled: 1,
-        handled: 2,
-        retried: 3,
-        retry_stopped: 4,
-        discarded: 5,
+        INTERRUPTED => 0,
+        UNHANDLED => 1,
+        HANDLED => 2,
+        RETRIED => 3,
+        RETRY_STOPPED => 4,
+        DISCARDED => 5,
       }
       if Gem::Version.new(Rails.version) >= Gem::Version.new('7.1.0.a')
         enum :error_event, error_event_enum, validate: { allow_nil: true }, scopes: false

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module GoodJob
+  # Adds row-level locking capabilities (SKIP LOCKED) to ActiveRecord models.
+  # These methods provide strategy-agnostic job claiming via CTE UPDATE statements.
+  module Lockable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Claims a job by acquiring a session-level advisory lock.
+      # Returns the claimed record or nil if no eligible record was found.
+      # The caller is responsible for releasing the advisory lock after use.
+      # @param select_limit [Integer, nil] Number of candidates to attempt locking
+      # @return [ActiveRecord::Base, nil]
+      def with_advisory_lock_claim(select_limit: nil)
+        advisory_lock(select_limit: select_limit).first
+      end
+
+      # Atomically claims a job using SELECT FOR NO KEY UPDATE SKIP LOCKED in a CTE UPDATE.
+      # Returns the claimed record or nil if no eligible record was found.
+      # @param locked_by_id [String] The process UUID claiming the job
+      # @param locked_at [Time] When the job was claimed
+      # @param lock_type [String, Symbol] Lock type identifier
+      # @return [ActiveRecord::Base, nil]
+      def with_skip_locked_claim(locked_by_id:, locked_at:, lock_type:)
+        candidate_sql = select(:id).lock("FOR NO KEY UPDATE SKIP LOCKED").to_sql
+        quoted_table = adapter_class.quote_table_name(table_name)
+        materialized = supports_cte_materialization_specifiers? ? "MATERIALIZED " : ""
+
+        sql = <<~SQL.squish
+          WITH candidate AS #{materialized}(#{candidate_sql})
+          UPDATE #{quoted_table}
+          SET locked_by_id = ?,
+              locked_at = ?,
+              lock_type = ?
+          FROM candidate
+          WHERE #{quoted_table}.id = candidate.id
+          RETURNING #{quoted_table}.*
+        SQL
+
+        unscoped.find_by_sql([sql, locked_by_id, locked_at, lock_types[lock_type.to_s]]).first
+      end
+
+      # Atomically claims a job using SELECT FOR NO KEY UPDATE SKIP LOCKED with an
+      # additional session-level advisory lock acquired within the same statement.
+      # Returns the claimed record or nil if no eligible record was found.
+      # @param locked_by_id [String] The process UUID claiming the job
+      # @param locked_at [Time] When the job was claimed
+      # @param lock_type [String, Symbol] Lock type identifier
+      # @return [ActiveRecord::Base, nil]
+      def with_hybrid_lock_claim(locked_by_id:, locked_at:, lock_type:)
+        candidate_sql = select(:id).lock("FOR NO KEY UPDATE SKIP LOCKED").to_sql
+        quoted_table = adapter_class.quote_table_name(table_name)
+        advisory_lock_expr = "('x' || substr(md5(#{_quoted_table_name_string} || '-' || id::text), 1, 16))::bit(64)::bigint"
+        materialized = supports_cte_materialization_specifiers? ? "MATERIALIZED " : ""
+
+        sql = <<~SQL.squish
+          WITH candidate AS #{materialized}(#{candidate_sql})
+          UPDATE #{quoted_table}
+          SET locked_by_id = ?,
+              locked_at = ?,
+              lock_type = ?
+          FROM (
+            SELECT id FROM candidate
+            WHERE pg_try_advisory_lock(#{advisory_lock_expr})
+          ) AS locked
+          WHERE #{quoted_table}.id = locked.id
+          RETURNING #{quoted_table}.*
+        SQL
+
+        unscoped.find_by_sql([sql, locked_by_id, locked_at, lock_types[lock_type.to_s]]).first
+      end
+    end
+  end
+end

data/app/models/good_job/batch.rb

@@ -94,60 +94,90 @@ module GoodJob
         # Phase 2: Build and partition jobs by concurrency limits
         build_result = _build_and_partition_jobs(batch_job_pairs, current_time)
 
-        # Phase 3: Insert bulkable jobs
+        # Phase 3–6: Insert, claim, and execute inline jobs
+        lock_strategy = Job.effective_lock_strategy
+        tracker_registered = false
+        lock_id = nil
         persisted_jobs = []
         inline_jobs = []
 
-        if build_result[:bulkable].any?
-          Job.transaction(requires_new: true, joinable: false) do
-            persisted_jobs = _insert_jobs(build_result[:bulkable], build_result[:active_jobs_by_job_id])
+        if execute_inline
+          GoodJob.capsule.tracker.register
+          tracker_registered = true
+          lock_id = GoodJob.capsule.tracker.id_for_lock
+        end
 
-            if execute_inline
-              inline_jobs = persisted_jobs.select { |job| job.scheduled_at.nil? || job.scheduled_at <= Time.current }
-              inline_jobs.each(&:advisory_lock!)
+        begin
+          if build_result[:bulkable].any?
+            Job.transaction(requires_new: true, joinable: false) do
+              persisted_jobs = _insert_jobs(build_result[:bulkable], build_result[:active_jobs_by_job_id])
+
+              if execute_inline
+                inline_jobs = persisted_jobs.select { |job| job.scheduled_at.nil? || job.scheduled_at <= current_time }
+                if lock_strategy != :advisory && lock_id && inline_jobs.any?
+                  Job.where(id: inline_jobs.map(&:id)).update_all( # rubocop:disable Rails/SkipsModelValidations
+                    locked_by_id: lock_id, locked_at: current_time, lock_type: 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
+              end
             end
           end
-        end
 
-        # Phase 4: Handle empty batches — they need _continue_discard_or_finish
-        # to trigger on_success/on_finish callbacks (batch_record.rb:77).
-        batches_with_jobs = Set.new
-        build_result[:bulkable].each { |entry| batches_with_jobs.add(entry[:batch]) }
-        build_result[:unbulkable].each { |entry| batches_with_jobs.add(entry[:batch]) }
-
-        empty_batches = batch_job_pairs.map(&:first).reject { |batch| batches_with_jobs.include?(batch) }
-        if empty_batches.any?
-          buffer = GoodJob::Adapter::InlineBuffer.capture do
-            empty_batches.each do |batch|
-              batch._record.reload
-              batch._record._continue_discard_or_finish(lock: true)
+          # Phase 4: Handle empty batches — they need _continue_discard_or_finish
+          # to trigger on_success/on_finish callbacks (batch_record.rb:77).
+          batches_with_jobs = Set.new
+          build_result[:bulkable].each { |entry| batches_with_jobs.add(entry[:batch]) }
+          build_result[:unbulkable].each { |entry| batches_with_jobs.add(entry[:batch]) }
+
+          empty_batches = batch_job_pairs.map(&:first).reject { |batch| batches_with_jobs.include?(batch) }
+          if empty_batches.any?
+            buffer = GoodJob::Adapter::InlineBuffer.capture do
+              empty_batches.each do |batch|
+                batch._record.reload
+                batch._record._continue_discard_or_finish(lock: true)
+              end
             end
+            buffer.call
           end
-          buffer.call
-        end
 
-        # Phase 5: Enqueue concurrency-limited jobs individually
-        build_result[:unbulkable].each do |entry|
-          within_thread(batch_id: entry[:batch].id) do
-            entry[:active_job].enqueue
+          # Phase 5: Enqueue concurrency-limited jobs individually
+          build_result[:unbulkable].each do |entry|
+            within_thread(batch_id: entry[:batch].id) do
+              entry[:active_job].enqueue
+            end
+          rescue GoodJob::ActiveJobExtensions::Concurrency::ConcurrencyExceededError
+            # ignore — matches Bulk::Buffer behavior (bulk.rb:107-109)
           end
-        rescue GoodJob::ActiveJobExtensions::Concurrency::ConcurrencyExceededError
-          # ignore — matches Bulk::Buffer behavior (bulk.rb:107-109)
-        end
 
-        # Phase 6: Execute inline jobs
-        if inline_jobs.any?
-          GoodJob::Adapter::InlineBuffer.perform_now_or_defer do
-            GoodJob.capsule.tracker.register do
+          # Phase 6: Execute inline jobs
+          if inline_jobs.any?
+            deferred = GoodJob::Adapter::InlineBuffer.defer?
+            GoodJob::Adapter::InlineBuffer.perform_now_or_defer do
               until inline_jobs.empty?
                 inline_job = inline_jobs.shift
                 active_job = build_result[:active_jobs_by_job_id][inline_job.active_job_id]
-                adapter.send(:perform_inline, inline_job, notify: adapter.send(:send_notify?, active_job))
+                adapter.send(:perform_inline, inline_job, notify: deferred ? adapter.send(:send_notify?, active_job) : false, already_claimed: lock_strategy != :advisory, advisory_unlock: lock_strategy != :skiplocked)
               end
             ensure
               inline_jobs.each(&:advisory_unlock)
+              GoodJob.capsule.tracker.unregister if tracker_registered
+              tracker_registered = false
             end
+          elsif tracker_registered
+            GoodJob.capsule.tracker.unregister
+            tracker_registered = false
+          end
+        rescue StandardError
+          if tracker_registered
+            GoodJob.capsule.tracker.unregister
+            tracker_registered = false
           end
+          raise
         end
 
         # Phase 7: Send NOTIFY for non-inline jobs
@@ -360,10 +390,11 @@ module GoodJob
 
     # @!visibility private
     def self._insert_jobs(bulkable_entries, active_jobs_by_job_id)
-      job_attributes = bulkable_entries.map { |entry| entry[:good_job].attributes }
+      column_names = Job.column_names
+      job_attributes = bulkable_entries.map { |entry| entry[:good_job].attributes.slice(*column_names) }
       results = Job.insert_all(job_attributes, returning: %w[id active_job_id]) # rubocop:disable Rails/SkipsModelValidations
 
-      job_id_map = results.each_with_object({}) { |row, hash| hash[row['active_job_id']] = row['id'] }
+      job_id_map = results.to_h { |row| [row['active_job_id'], row['id']] }
 
       # Set provider_job_id on ActiveJob instances (mirrors adapter.rb:74-76)
       active_jobs_by_job_id.each_value do |active_job|

data/app/models/good_job/execution_result.rb

@@ -3,6 +3,8 @@
 module GoodJob
   # Stores the results of job execution
   class ExecutionResult
+    # @return [ActiveJob::Base, nil]
+    attr_reader :active_job
     # @return [Object, nil]
     attr_reader :value
     # @return [Exception, nil]
@@ -22,8 +24,9 @@ module GoodJob
     # @param error_event [String, nil]
     # @param unexecutable [Boolean, nil]
     # @param retried_job [GoodJob::Job, nil]
-    def initialize(value:, handled_error: nil, unhandled_error: nil, error_event: nil, unexecutable: nil, retried_job: nil)
+    def initialize(value:, active_job: nil, handled_error: nil, unhandled_error: nil, error_event: nil, unexecutable: nil, retried_job: nil)
       @value = value
+      @active_job = active_job
       @handled_error = handled_error
       @unhandled_error = unhandled_error
       @error_event = error_event