good_job 4.13.1 → 4.13.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3407384b57488071d4631ea643e46bd06c1d7a01d2edb9655a1e65be8d59a62d
-  data.tar.gz: 322a40ebccd3081455d7ebefa16811b0a5a745dc3c49090fff422b1fa91593c0
+  metadata.gz: 3274686b09e03b2ec9b5d58f3b8bf70472e30c739b907697e7ad1f2ad7ce6b50
+  data.tar.gz: 0f2ee28df948382eb23cffd0535545462490737c62c3d9133be5afb7ef3cfc52
 SHA512:
-  metadata.gz: a77366c7a3fa599505a8d25b1bf56c43633bcec29c68ce58d7bd787dee71813ffa51ff784d6f1ad46e9d8bb5d79029e4ca321e238e8e1b468b29aabbb89f3392
-  data.tar.gz: af3dd4540b43b8fb47c8eb7c686e9d67e0942d17a6299dac06887c3b65072844654cdaeaae30d873c1b1c6ecde39a52b25d31a9eb1898c92fee51521e08d064c
+  metadata.gz: bea1412da3fc1d276688733cd2d5aa622939211b8cc4cbdaa52a0bc5543ded93f5350be14d0cdbed987b988cc9b205dd0dc144b209d7ecc5ced25dad26221ec7
+  data.tar.gz: 61240a584b06c7871f815d123a78a9c3066a8a739a49f2a9f403bdfcf255f97e691ad5fd5754a301f7b7e5c66a3cb09161d312348c68a022a958d5e5cbba27e1

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [v4.13.2](https://github.com/bensheldon/good_job/tree/v4.13.2) (2026-01-29)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v4.13.1...v4.13.2)
+
+**Fixed bugs:**
+
+- Check for graceful shutdown inside job cleanup loops [\#1711](https://github.com/bensheldon/good_job/pull/1711) ([bdewater-thatch](https://github.com/bdewater-thatch))
+- Add title to Good Job Dashboard layout [\#1701](https://github.com/bensheldon/good_job/pull/1701) ([mockdeep](https://github.com/mockdeep))
+
+**Closed issues:**
+
+- Test failures against rails-head [\#1704](https://github.com/bensheldon/good_job/issues/1704)
+
+**Merged pull requests:**
+
+- Add test for Migration generator with custom migration path [\#1709](https://github.com/bensheldon/good_job/pull/1709) ([bensheldon](https://github.com/bensheldon))
+- Support Rails 8.2-dev `enqueue\_after\_transaction\_commit by deferring framework enqueuing preemptively [\#1707](https://github.com/bensheldon/good_job/pull/1707) ([bensheldon](https://github.com/bensheldon))
+- Add Ruby 4.0 to CI [\#1705](https://github.com/bensheldon/good_job/pull/1705) ([Earlopain](https://github.com/Earlopain))
+- Bump actions/upload-artifact from 5 to 6 [\#1703](https://github.com/bensheldon/good_job/pull/1703) ([dependabot[bot]](https://github.com/apps/dependabot))
+
 ## [v4.13.1](https://github.com/bensheldon/good_job/tree/v4.13.1) (2025-12-16)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v4.13.0...v4.13.1)

data/app/models/good_job/batch.rb

@@ -151,8 +151,12 @@ module GoodJob
               update_attributes = { discarded_at: nil, finished_at: nil }
               update_attributes[:jobs_finished_at] = nil if GoodJob::BatchRecord.jobs_finished_at_migrated?
               record.update!(update_attributes)
-              record.jobs.discarded.each(&:retry_job)
-              record._continue_discard_or_finish(lock: false)
+
+              discarded_jobs = record.jobs.discarded
+              Job.defer_after_commit_maybe(discarded_jobs) do
+                discarded_jobs.each(&:retry_job)
+                record._continue_discard_or_finish(lock: false)
+              end
             end
           end
         end

data/app/models/good_job/batch_record.rb

@@ -59,25 +59,47 @@ module GoodJob
       job_discarded = job && job.finished_at.present? && job.error.present?
       buffer = GoodJob::Adapter::InlineBuffer.capture do
         advisory_lock_maybe(lock) do
-          Batch.within_thread(batch_id: nil, batch_callback_id: id) do
-            reload
-
-            if job_discarded && !discarded_at
-              update(discarded_at: Time.current)
-              on_discard.constantize.set(priority: callback_priority, queue: callback_queue_name).perform_later(to_batch, { event: :discard }) if on_discard.present?
+          reload
+
+          if job_discarded && !discarded_at
+            update(discarded_at: Time.current)
+
+            if on_discard.present?
+              discard_job_class = on_discard.constantize
+              Job.defer_after_commit_maybe(discard_job_class) do
+                Batch.within_thread(batch_id: nil, batch_callback_id: id) do
+                  discard_job_class.set(priority: callback_priority, queue: callback_queue_name).perform_later(to_batch, { event: :discard })
+                end
+              end
             end
+          end
 
-            if enqueued_at && !(self.class.jobs_finished_at_migrated? ? jobs_finished_at : finished_at) && jobs.where(finished_at: nil).none?
-              self.class.jobs_finished_at_migrated? ? update(jobs_finished_at: Time.current) : update(finished_at: Time.current)
+          if enqueued_at && !(self.class.jobs_finished_at_migrated? ? jobs_finished_at : finished_at) && jobs.where(finished_at: nil).none?
+            self.class.jobs_finished_at_migrated? ? update(jobs_finished_at: Time.current) : update(finished_at: Time.current)
 
-              on_success.constantize.set(priority: callback_priority, queue: callback_queue_name).perform_later(to_batch, { event: :success }) if !discarded_at && on_success.present?
-              on_finish.constantize.set(priority: callback_priority, queue: callback_queue_name).perform_later(to_batch, { event: :finish }) if on_finish.present?
+            if !discarded_at && on_success.present?
+              success_job_class = on_success.constantize
+              Job.defer_after_commit_maybe(success_job_class) do
+                Batch.within_thread(batch_id: nil, batch_callback_id: id) do
+                  success_job_class.set(priority: callback_priority, queue: callback_queue_name).perform_later(to_batch, { event: :success })
+                end
+              end
             end
 
-            update(finished_at: Time.current) if !finished_at && self.class.jobs_finished_at_migrated? && jobs_finished? && callback_jobs.where(finished_at: nil).none?
+            if on_finish.present?
+              finish_job_class = on_finish.constantize
+              Job.defer_after_commit_maybe(finish_job_class) do
+                Batch.within_thread(batch_id: nil, batch_callback_id: id) do
+                  on_finish.constantize.set(priority: callback_priority, queue: callback_queue_name).perform_later(to_batch, { event: :finish })
+                end
+              end
+            end
           end
+
+          update(finished_at: Time.current) if !finished_at && self.class.jobs_finished_at_migrated? && jobs_finished? && callback_jobs.where(finished_at: nil).none?
         end
       end
+
       buffer.call
     end
 

data/app/models/good_job/job.rb

@@ -420,6 +420,33 @@ module GoodJob
       [error.class.to_s, ERROR_MESSAGE_SEPARATOR, error.message].join
     end
 
+    # When code needs to optionally handle enqueue_after_transaction_commit
+    def self.defer_after_commit_maybe(good_job_or_active_job_classes)
+      if enqueue_after_commit?(good_job_or_active_job_classes)
+        ActiveRecord.after_all_transactions_commit { yield(true) }
+      else
+        yield(false)
+      end
+    end
+
+    def self.enqueue_after_commit?(good_job_or_active_job_classes)
+      good_job_or_active_job_classes = Array(good_job_or_active_job_classes)
+
+      feature_exists = ActiveRecord.respond_to?(:after_all_transactions_commit)
+      feature_exists && good_job_or_active_job_classes.any? do |klass|
+        active_job_class = case klass
+                           when String
+                             klass.constantize
+                           when Job
+                             klass.job_class.constantize
+                           else
+                             klass
+                           end
+
+        active_job_class.respond_to?(:enqueue_after_transaction_commit)
+      end
+    end
+
     # TODO: it would be nice to enforce these values at the model
     # validates :active_job_id, presence: true
     # validates :scheduled_at, presence: true
@@ -499,41 +526,46 @@ module GoodJob
     # This action will create a new {Execution} record for the job.
     # @return [ActiveJob::Base]
     def retry_job
-      with_advisory_lock do
-        reload
-        active_job = self.active_job(ignore_deserialization_errors: true)
-
-        raise ActiveJobDeserializationError if active_job.nil?
-        raise AdapterNotGoodJobError unless active_job.class.queue_adapter.is_a? GoodJob::Adapter
-        raise ActionForStateMismatchError if finished_at.blank? || error.blank?
-
-        # Update the executions count because the previous execution will not have been preserved
-        # Do not update `exception_executions` because that comes from rescue_from's arguments
-        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)
-        rescue StandardError
-          error = StandardError.new(error)
-        end
+      Rails.application.executor.wrap do
+        with_advisory_lock do
+          reload
+          active_job = self.active_job(ignore_deserialization_errors: true)
+
+          raise ActiveJobDeserializationError if active_job.nil?
+          raise AdapterNotGoodJobError unless active_job.class.queue_adapter.is_a? GoodJob::Adapter
+          raise ActionForStateMismatchError if finished_at.blank? || error.blank?
+
+          # Update the executions count because the previous execution will not have been preserved
+          # Do not update `exception_executions` because that comes from rescue_from's arguments
+          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)
+          rescue StandardError
+            error = StandardError.new(error)
+          end
 
-        new_active_job = nil
-        GoodJob::CurrentThread.within do |current_thread|
-          current_thread.job = self
-          current_thread.retry_now = true
+          new_active_job = nil
 
           transaction do
-            # NOTE: Required 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)
+            Job.defer_after_commit_maybe(active_job.class) do
+              GoodJob::CurrentThread.within do |current_thread|
+                current_thread.job = self
+                current_thread.retry_now = true
+
+                # 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)
+                end
+              end
             end
             self.error_event = :retried if error
             save!
           end
-        end
 
-        new_active_job
+          new_active_job
+        end
       end
     end
 

data/app/views/layouts/good_job/application.html.erb

@@ -32,6 +32,8 @@
 
     <%= tag.script "import \"application\";".html_safe, type: "module", nonce: content_security_policy_nonce %>
 
+    <title>Good Job Dashboard</title>
+    <%= tag.link rel: "icon", href: 'data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" viewBox="10 0 100 100"><text y=".90em" font-size="90">👍</text></svg>' %>
     <%= csrf_meta_tags %>
     <%= csp_meta_tag %>
 

data/lib/good_job/version.rb

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

data/lib/good_job.rb

@@ -217,6 +217,8 @@ module GoodJob
       jobs_query = GoodJob::Job.finished_before(timestamp).order(finished_at: :asc).limit(in_batches_of)
       jobs_query = jobs_query.succeeded unless include_discarded
       loop do
+        break if GoodJob.current_thread_shutting_down?
+
         active_job_ids = jobs_query.pluck(:active_job_id)
         break if active_job_ids.empty?
 
@@ -230,6 +232,8 @@ module GoodJob
       batches_query = GoodJob::BatchRecord.finished_before(timestamp).limit(in_batches_of)
       batches_query = batches_query.succeeded unless include_discarded
       loop do
+        break if GoodJob.current_thread_shutting_down?
+
         deleted = batches_query.delete_all
         break if deleted.zero?
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 4.13.1
+  version: 4.13.2
 platform: ruby
 authors:
 - Ben Sheldon
@@ -426,7 +426,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.2
 specification_version: 4
 summary: A multithreaded, Postgres-based ActiveJob backend for Ruby on Rails
 test_files: []