good_job 4.2.1 → 4.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f21cb4322491fa83f330857033b5c1c0524509d57a93d795d3e4c7ce064e676c
-  data.tar.gz: '05082cbbd0fd4a26587ac53a58d7042c546390505e68fb978ef675bdfe6a0fa6'
+  metadata.gz: f7e5a7c2df1683ddffde677bddf6bbd9d2d316ec646f571161749e4648ec7da7
+  data.tar.gz: dd2e664a3ada0f89e2a07731ef5d1ebff9c5edd87768ce584622f5ac33a0da12
 SHA512:
-  metadata.gz: 825bed536a7ee957773981cc926f04dad400e0f2a770e5749a18511927b3c09a4130370a5ee0d88e984bf8ed3a09cce53bd0285bc1066c1e4a837835ee44ab21
-  data.tar.gz: 04371b7bb7fb075dc5d11817ff942443609bfd33cd7112ba35c9617447ae520035d7fcfafff127e170b77dba4d258af5ebc54448c9d20c07cd1516d584076fdb
+  metadata.gz: 5faa526ba40039167498cf5c1046251feca2d0255746170de2f153531a5f973fdfc326319b16dcff30d893b38131fbb76d814cf4c4a15f5276b0f371bc05a3be
+  data.tar.gz: a8db86f639120ddc90b5de3245962a4630e006a26fc832b98dbb8892f9131298251780128ce03d7d3a94b59ec9b117d4fd277adc3e34fa96234c85c1378c9f8e

data/CHANGELOG.md

@@ -1,5 +1,50 @@
 # Changelog
 
+## [v4.4.0](https://github.com/bensheldon/good_job/tree/v4.4.0) (2024-10-08)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v4.3.0...v4.4.0)
+
+**Fixed bugs:**
+
+- fix: unable to use keyword args when including the `Labels` extension [\#1500](https://github.com/bensheldon/good_job/pull/1500) ([ElMassimo](https://github.com/ElMassimo))
+- Fix GoodJob::Setting duplicate keys [\#1498](https://github.com/bensheldon/good_job/pull/1498) ([mohammednasser-32](https://github.com/mohammednasser-32))
+- Allow `GoodJob::Job#retry_job`'s transaction to be joinable \(fix CI for current `rails-head`\) [\#1496](https://github.com/bensheldon/good_job/pull/1496) ([Earlopain](https://github.com/Earlopain))
+
+**Closed issues:**
+
+- Inline adapter doesn't retry jobs that throw a retryable error [\#1497](https://github.com/bensheldon/good_job/issues/1497)
+- scheduled\_at not respecting given timezone [\#1491](https://github.com/bensheldon/good_job/issues/1491)
+- Multiple same values in cron\_keys\_disabled, cron\_keys\_enabled in good\_job\_settings table [\#1490](https://github.com/bensheldon/good_job/issues/1490)
+- Cron jobs can be missed if deploys are timed just right [\#1484](https://github.com/bensheldon/good_job/issues/1484)
+- Configuring connection pool in external mode [\#1483](https://github.com/bensheldon/good_job/issues/1483)
+- GoodJob Timezone Day Light Savings [\#1480](https://github.com/bensheldon/good_job/issues/1480)
+- Unable to use labels with kwargs in job initializer  [\#1350](https://github.com/bensheldon/good_job/issues/1350)
+
+**Merged pull requests:**
+
+- Bump puma from 6.4.2 to 6.4.3 [\#1492](https://github.com/bensheldon/good_job/pull/1492) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Add `cron_graceful_restart_period` to avoid missing recurring jobs that occurred during deployment downtime [\#1488](https://github.com/bensheldon/good_job/pull/1488) ([bensheldon](https://github.com/bensheldon))
+
+## [v4.3.0](https://github.com/bensheldon/good_job/tree/v4.3.0) (2024-09-14)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v4.2.1...v4.3.0)
+
+**Fixed bugs:**
+
+- Don't shadow gem loading errors during autoloading with the inline adapter [\#1486](https://github.com/bensheldon/good_job/pull/1486) ([Earlopain](https://github.com/Earlopain))
+- Ensure before actions run on root route [\#1482](https://github.com/bensheldon/good_job/pull/1482) ([ebiven](https://github.com/ebiven))
+
+**Closed issues:**
+
+- Undefined method `unhandled_error` for nil [\#1485](https://github.com/bensheldon/good_job/issues/1485)
+- bin/rails g good\_job:install fails [\#1481](https://github.com/bensheldon/good_job/issues/1481)
+- Rails 7.2.1 breaks enqueuing without enqueue\_after\_transaction\_commit? method on queue adapter [\#1477](https://github.com/bensheldon/good_job/issues/1477)
+
+**Merged pull requests:**
+
+- Fix documentation for 2nd Batch callback parameter: consistently call it `context` [\#1476](https://github.com/bensheldon/good_job/pull/1476) ([martijnversluis](https://github.com/martijnversluis))
+- Redefine `Batch#finished_at` to mean all callback jobs have finished too; add `Batch#jobs_finished_at` to allow not deleting batches until all their callback jobs complete [\#1454](https://github.com/bensheldon/good_job/pull/1454) ([bensheldon](https://github.com/bensheldon))
+
 ## [v4.2.1](https://github.com/bensheldon/good_job/tree/v4.2.1) (2024-08-29)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v4.2.0...v4.2.1)

data/README.md

@@ -257,6 +257,7 @@ Rails.application.configure do
   config.good_job.shutdown_timeout = 25 # seconds
   config.good_job.enable_cron = true
   config.good_job.cron = { example: { cron: '0 * * * *', class: 'ExampleJob'  } }
+  config.good_job.cron_graceful_restart_period = 5.minutes
   config.good_job.dashboard_default_locale = :en
 
   # ...or all at once.
@@ -298,6 +299,7 @@ Available configuration options are:
 - `max_cache` (integer) sets the maximum number of scheduled jobs that will be stored in memory to reduce execution latency when also polling for scheduled jobs. Caching 10,000 scheduled jobs uses approximately 20MB of memory. You can also set this with the environment variable `GOOD_JOB_MAX_CACHE`.
 - `shutdown_timeout` (integer) number of seconds to wait for jobs to finish when shutting down before stopping the thread. Defaults to forever: `-1`. You can also set this with the environment variable `GOOD_JOB_SHUTDOWN_TIMEOUT`.
 - `enable_cron` (boolean) whether to run cron process. Defaults to `false`. You can also set this with the environment variable `GOOD_JOB_ENABLE_CRON`.
+- `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`._
@@ -625,6 +627,9 @@ If you use the [Dashboard](#dashboard) the scheduled tasks can be viewed in the
 # Enable cron enqueuing in this process
 config.good_job.enable_cron = true
 
+# Without zero-downtime deploys, re-attempt previous schedules after a deploy
+config.good_job.cron_graceful_restart_period = 1.minute
+
 # Configure cron with a hash that has a unique key for each recurring job
 config.good_job.cron = {
   # Every 15 minutes, enqueue `ExampleJob.set(priority: -10).perform_later(42, "life", name: "Alice")`
@@ -681,15 +686,15 @@ Batches track a set of jobs, and enqueue an optional callback job when all of th
       OtherJob.perform_later
     end
 
-    # When these jobs have finished, it will enqueue your `MyBatchCallbackJob.perform_later(batch, options)`
+    # When these jobs have finished, it will enqueue your `MyBatchCallbackJob.perform_later(batch, context)`
     class MyBatchCallbackJob < ApplicationJob
-      # Callback jobs must accept a `batch` and `options` argument
-      def perform(batch, params)
+      # Callback jobs must accept a `batch` and `context` argument
+      def perform(batch, context)
         # The batch object will contain the Batch's properties, which are mutable
         batch.properties[:user] # => <User id: 1, ...>
 
-        # Params is a hash containing additional context (more may be added in the future)
-        params[:event] # => :finish, :success, :discard
+        # Context is a hash containing additional context (more may be added in the future)
+        context[:event] # => :finish, :success, :discard
       end
     end
     ```
@@ -757,19 +762,19 @@ Batch callbacks are Active Job jobs that are enqueued at certain events during t
 - `:success` - Enqueued only when all jobs in the batch have finished and succeeded.
 - `:discard` - Enqueued immediately the first time a job in the batch is discarded.
 
-Callback jobs must accept a `batch` and `params` argument in their `perform` method:
+Callback jobs must accept a `batch` and `context` argument in their `perform` method:
 
 ```ruby
 class MyBatchCallbackJob < ApplicationJob
-  def perform(batch, params)
+  def perform(batch, context)
     # The batch object will contain the Batch's properties
     batch.properties[:user] # => <User id: 1, ...>
     # Batches are mutable
     batch.properties[:user] = User.find(2)
     batch.save
 
-    # Params is a hash containing additional context (more may be added in the future)
-    params[:event] # => :finish, :success, :discard
+    # Context is a hash containing additional context (more may be added in the future)
+    context[:event] # => :finish, :success, :discard
   end
 end
 ```
@@ -811,7 +816,7 @@ class WorkJob < ApplicationJob
 end
 
 class BatchJob < ApplicationJob
-  def perform(batch, options)
+  def perform(batch, context)
     if batch.properties[:stage].nil?
       batch.enqueue(stage: 1) do
         WorkJob.perform_later('a')

data/app/controllers/good_job/jobs_controller.rb

@@ -94,6 +94,12 @@ module GoodJob
       redirect_to jobs_path, notice: t(".notice")
     end
 
+    def redirect_to_index
+      # Redirect to the jobs page, maintaining query parameters. This is
+      # necessary to support the `?poll=1` parameter that enables live polling.
+      redirect_to jobs_path(request.query_parameters)
+    end
+
     private
 
     def redirect_on_error(exception)

data/app/models/good_job/batch.rb

@@ -26,10 +26,12 @@ module GoodJob
       :enqueued_at,
       :finished_at,
       :discarded_at,
+      :jobs_finished_at,
       :enqueued?,
       :finished?,
       :succeeded?,
       :discarded?,
+      :jobs_finished?,
       :description,
       :description=,
       :on_finish,
@@ -95,8 +97,12 @@ module GoodJob
         record.transaction do
           record.with_advisory_lock(function: "pg_advisory_xact_lock") do
             record.enqueued_at_will_change!
+            record.jobs_finished_at_will_change! if GoodJob::BatchRecord.jobs_finished_at_migrated?
             record.finished_at_will_change!
-            record.update!(enqueued_at: nil, finished_at: nil)
+
+            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)
           end
         end
       end
@@ -142,7 +148,9 @@ module GoodJob
         buffer = GoodJob::Adapter::InlineBuffer.capture do
           record.transaction do
             record.with_advisory_lock(function: "pg_advisory_xact_lock") do
-              record.update!(discarded_at: nil, finished_at: nil)
+              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)
             end

data/app/models/good_job/batch_record.rb

@@ -38,6 +38,10 @@ module GoodJob
       query
     end)
 
+    def self.jobs_finished_at_migrated?
+      column_names.include?('jobs_finished_at')
+    end
+
     # Whether the batch has finished and no jobs were discarded
     # @return [Boolean]
     def succeeded?
@@ -52,22 +56,26 @@ module GoodJob
       attributes.except('serialized_properties').merge(properties: properties)
     end
 
-    def _continue_discard_or_finish(execution = nil, lock: true)
-      execution_discarded = execution && execution.finished_at.present? && execution.error.present?
+    def _continue_discard_or_finish(job = nil, lock: true)
+      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 execution_discarded && !discarded_at
+
+            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?
             end
 
-            if enqueued_at && !finished_at && jobs.where(finished_at: nil).count.zero?
-              update(finished_at: Time.current)
+            if enqueued_at && !(self.class.jobs_finished_at_migrated? ? jobs_finished_at : finished_at) && jobs.where(finished_at: nil).count.zero?
+              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?
             end
+
+            update(finished_at: Time.current) if !finished_at && self.class.jobs_finished_at_migrated? && jobs_finished? && callback_jobs.where(finished_at: nil).count.zero?
           end
         end
       end
@@ -97,6 +105,14 @@ module GoodJob
       self.serialized_properties = value
     end
 
+    def jobs_finished?
+      self.class.jobs_finished_at_migrated? ? jobs_finished_at : finished_at
+    end
+
+    def jobs_finished_at
+      self.class.jobs_finished_at_migrated? ? self[:jobs_finished_at] : self[:finished_at]
+    end
+
     private
 
     def advisory_lock_maybe(value, &block)

data/app/models/good_job/cron_entry.rb

@@ -71,6 +71,19 @@ module GoodJob # :nodoc:
       end
     end
 
+    def within(period, previously_at: nil)
+      if cron_proc?
+        result = Rails.application.executor.wrap { cron.call(previously_at || last_job_at) }
+        if result.is_a?(String)
+          Fugit.parse(result).within(period).map(&:to_t)
+        else
+          result
+        end
+      else
+        fugit.within(period).map(&:to_t)
+      end
+    end
+
     def enabled?
       GoodJob::Setting.cron_key_enabled?(key, default: enabled_by_default?)
     end

data/app/models/good_job/job.rb

@@ -40,6 +40,7 @@ module GoodJob
     set_callback :perform_unlocked, :after, :continue_discard_or_finish_batch
 
     belongs_to :batch, class_name: 'GoodJob::BatchRecord', inverse_of: :jobs, optional: true
+    belongs_to :callback_batch, class_name: 'GoodJob::BatchRecord', foreign_key: :batch_callback_id, inverse_of: :callback_jobs, optional: true
     belongs_to :locked_by_process, class_name: "GoodJob::Process", foreign_key: :locked_by_id, inverse_of: :locked_jobs, optional: true
     has_many :executions, class_name: 'GoodJob::Execution', foreign_key: 'active_job_id', primary_key: "id", inverse_of: :job, dependent: :delete_all
 
@@ -477,7 +478,7 @@ module GoodJob
           current_thread.job = self
           current_thread.retry_now = true
 
-          self.class.transaction(joinable: false, requires_new: true) do
+          transaction do
             new_active_job = active_job.retry_job(wait: 0, error: error)
             self.error_event = :retried if error
             save!
@@ -743,6 +744,7 @@ module GoodJob
 
     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?
     end
 
     def active_job_data

data/app/models/good_job/setting.rb

@@ -19,30 +19,32 @@ module GoodJob
     end
 
     def self.cron_key_enable(key)
+      key_string = key.to_s
       enabled_setting = find_or_initialize_by(key: CRON_KEYS_ENABLED) do |record|
         record.value = []
       end
-      enabled_setting.value << key unless enabled_setting.value.include?(key)
+      enabled_setting.value << key unless enabled_setting.value.include?(key_string)
       enabled_setting.save!
 
       disabled_setting = GoodJob::Setting.find_by(key: CRON_KEYS_DISABLED)
-      return unless disabled_setting&.value&.include?(key.to_s)
+      return unless disabled_setting&.value&.include?(key_string)
 
-      disabled_setting.value.delete(key.to_s)
+      disabled_setting.value.delete(key_string)
       disabled_setting.save!
     end
 
     def self.cron_key_disable(key)
       enabled_setting = GoodJob::Setting.find_by(key: CRON_KEYS_ENABLED)
-      if enabled_setting&.value&.include?(key.to_s)
-        enabled_setting.value.delete(key.to_s)
+      key_string = key.to_s
+      if enabled_setting&.value&.include?(key_string)
+        enabled_setting.value.delete(key_string)
         enabled_setting.save!
       end
 
       disabled_setting = find_or_initialize_by(key: CRON_KEYS_DISABLED) do |record|
         record.value = []
       end
-      disabled_setting.value << key unless disabled_setting.value.include?(key)
+      disabled_setting.value << key unless disabled_setting.value.include?(key_string)
       disabled_setting.save!
     end
   end

data/config/routes.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 GoodJob::Engine.routes.draw do
-  root to: redirect(path: 'jobs')
+  root 'jobs#redirect_to_index'
 
   resources :jobs, only: %i[index show destroy] do
     collection do

data/lib/generators/good_job/templates/install/migrations/create_good_jobs.rb.erb

@@ -46,6 +46,7 @@ class CreateGoodJobs < ActiveRecord::Migration<%= migration_version %>
       t.datetime :enqueued_at
       t.datetime :discarded_at
       t.datetime :finished_at
+      t.datetime :jobs_finished_at
     end
 
     create_table :good_job_executions, id: :uuid do |t|

data/lib/generators/good_job/templates/update/migrations/02_add_jobs_finished_at_to_good_job_batches.rb.erb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class AddJobsFinishedAtToGoodJobBatches < ActiveRecord::Migration<%= migration_version %>
+  def change
+    reversible do |dir|
+      dir.up do
+        # Ensure this incremental update migration is idempotent
+        # with monolithic install migration.
+        return if connection.column_exists?(:good_job_batches, :jobs_finished_at)
+      end
+    end
+
+    change_table :good_job_batches do |t|
+      t.datetime :jobs_finished_at
+    end
+  end
+end

data/lib/good_job/active_job_extensions/labels.rb

@@ -6,7 +6,7 @@ module GoodJob
       extend ActiveSupport::Concern
 
       module Prepends
-        def initialize(*arguments)
+        def initialize(...)
           super
           self.good_job_labels = Array(self.class.good_job_labels.dup)
         end

data/lib/good_job/adapter.rb

@@ -254,7 +254,7 @@ module GoodJob
       job.advisory_unlock
       job.run_callbacks(:perform_unlocked)
 
-      raise result.unhandled_error if result.unhandled_error
+      raise result.unhandled_error if result&.unhandled_error
     end
   end
 end

data/lib/good_job/configuration.rb

@@ -219,6 +219,12 @@ module GoodJob
       cron.map { |cron_key, params| GoodJob::CronEntry.new(params.merge(key: cron_key)) }
     end
 
+    def cron_graceful_restart_period
+      options[:cron_graceful_restart_period] ||
+        rails_config[:cron_graceful_restart_period] ||
+        env['GOOD_JOB_CRON_GRACEFUL_RESTART_PERIOD']
+    end
+
     # The number of queued jobs to select when polling for a job to run.
     # This limit is intended to avoid locking a large number of rows when selecting eligible jobs
     # from the queue. This value should be higher than the total number of threads across all good_job

data/lib/good_job/cron_manager.rb

@@ -31,11 +31,12 @@ module GoodJob # :nodoc:
 
     # @param cron_entries [Array<CronEntry>]
     # @param start_on_initialize [Boolean]
-    def initialize(cron_entries = [], start_on_initialize: false, executor: Concurrent.global_io_executor)
+    def initialize(cron_entries = [], start_on_initialize: false, graceful_restart_period: nil, executor: Concurrent.global_io_executor)
       @executor = executor
       @running = false
       @cron_entries = cron_entries
       @tasks = Concurrent::Hash.new
+      @graceful_restart_period = graceful_restart_period
 
       start if start_on_initialize
       self.class.instances << self
@@ -47,6 +48,7 @@ module GoodJob # :nodoc:
         @running = true
         cron_entries.each do |cron_entry|
           create_task(cron_entry)
+          create_graceful_tasks(cron_entry) if @graceful_restart_period
         end
       end
     end
@@ -97,5 +99,24 @@ module GoodJob # :nodoc:
       future.add_observer(self.class, :task_observer)
       future.execute
     end
+
+    # Uses the graceful restart period to re-enqueue jobs that were scheduled to run during the period.
+    # The existing uniqueness logic should ensure this does not create duplicate jobs.
+    # @param cron_entry [CronEntry] the CronEntry object to schedule
+    def create_graceful_tasks(cron_entry)
+      return unless @graceful_restart_period
+
+      time_period = @graceful_restart_period.ago..Time.current
+      cron_entry.within(time_period).each do |cron_at|
+        future = Concurrent::Future.new(args: [self, cron_entry, cron_at], executor: @executor) do |_thr_scheduler, thr_cron_entry, thr_cron_at|
+          Rails.application.executor.wrap do
+            cron_entry.enqueue(thr_cron_at) if thr_cron_entry.enabled?
+          end
+        end
+
+        future.add_observer(self.class, :task_observer)
+        future.execute
+      end
+    end
   end
 end

data/lib/good_job/version.rb

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

data/lib/good_job.rb

@@ -171,10 +171,10 @@ module GoodJob
     _shutdown_all(Capsule.instances, :restart, timeout: timeout)
   end
 
-  # Sends +#shutdown+ or +#restart+ to executable objects ({GoodJob::Notifier}, {GoodJob::Poller}, {GoodJob::Scheduler}, {GoodJob::MultiScheduler}, {GoodJob::CronManager})
+  # Sends +#shutdown+ or +#restart+ to executable objects ({GoodJob::Notifier}, {GoodJob::Poller}, {GoodJob::Scheduler}, {GoodJob::MultiScheduler}, {GoodJob::CronManager}, {GoodJob::SharedExecutor})
   # @param executables [Array<Notifier, Poller, Scheduler, MultiScheduler, CronManager, SharedExecutor>] Objects to shut down.
-  # @param method_name [:symbol] Method to call, e.g. +:shutdown+ or +:restart+.
-  # @param timeout [nil,Numeric]
+  # @param method_name [Symbol] Method to call, e.g. +:shutdown+ or +:restart+.
+  # @param timeout [nil, Numeric] Seconds to wait for actively executing jobs to finish.
   # @param after [Array<Notifier, Poller, Scheduler, MultiScheduler, CronManager, SharedExecutor>] Objects to shut down after initial executables shut down.
   # @return [void]
   def self._shutdown_all(executables, method_name = :shutdown, timeout: -1, after: [])
@@ -290,7 +290,7 @@ module GoodJob
   # For use in tests/CI to validate GoodJob is up-to-date.
   # @return [Boolean]
   def self.migrated?
-    true
+    GoodJob::BatchRecord.jobs_finished_at_migrated?
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 4.2.1
+  version: 4.4.0
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-29 00:00:00.000000000 Z
+date: 2024-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -340,6 +340,7 @@ files:
 - lib/generators/good_job/install_generator.rb
 - lib/generators/good_job/templates/install/migrations/create_good_jobs.rb.erb
 - lib/generators/good_job/templates/update/migrations/01_create_good_jobs.rb.erb
+- lib/generators/good_job/templates/update/migrations/02_add_jobs_finished_at_to_good_job_batches.rb.erb
 - lib/generators/good_job/update_generator.rb
 - lib/good_job.rb
 - lib/good_job/active_job_extensions/batches.rb