good_job 2.99.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a19a18e7245448f7f44c99a492f4ca08f311cc96da9a50f4ba4d7b704685017
-  data.tar.gz: 07330c1a31b873b172066d9e7946b0184b250f7276fe041617c378b35ce8beca
+  metadata.gz: a4f4e14bae83760bdeb35557a727116d053e47a9b7dbf501914606dbc45c2ef7
+  data.tar.gz: c06e9165b7ac5d87af0ab75291fedd0194018752f34332c1a16930ddca53e3dd
 SHA512:
-  metadata.gz: 7a38a4a1bc73cf7378f24850b1e58b9b7cf6fbf83ef7aff8fcdba7d2c77ce782e273a3bc946efcf21d98157523b68183bb36efcbd570d253eab73cc7e8542c99
-  data.tar.gz: c97a8235d5b0041237909d6bb551bcccf2de5a4e2fa07bbbb12496a245aa6c4408896baa2a752b0a9f3eb6a1eb037189baa68e6d9979b57ef640e08750609d27
+  metadata.gz: 949cfcf1506ff658666113e035a875ed4ab44fa3e2c674e4d5d1440bf484d39793a1ee595ae0cb6f719136ce5541aae09a7fc2d66a049ea1bcf973b0165dc8a4
+  data.tar.gz: 9c9ff56251e01d60823a50f4edcea74034a36ef93929cf59adc588273da86d1e04f67c1b25d7d35efecda9309acf7f49f81d29fbc7f94249be0e3732087f9081

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [v3.0.0](https://github.com/bensheldon/good_job/tree/v3.0.0) (2022-06-26)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v2.99.0...v3.0.0)
+
+**Implemented enhancements:**
+
+- By default, preserve job records and automatically them clean up [\#545](https://github.com/bensheldon/good_job/pull/545) ([bensheldon](https://github.com/bensheldon))
+
+**Merged pull requests:**
+
+- Update tests to reflect default of `GoodJob.preserve_job_records = true`; update appraisal Gemfiles too [\#643](https://github.com/bensheldon/good_job/pull/643) ([bensheldon](https://github.com/bensheldon))
+- Remove database migration shims and old migrations [\#642](https://github.com/bensheldon/good_job/pull/642) ([bensheldon](https://github.com/bensheldon))
+- Remove support for EOL Rails 5.2 [\#637](https://github.com/bensheldon/good_job/pull/637) ([bensheldon](https://github.com/bensheldon))
+- Remove/rename deprecated behavior and constants for GoodJob v3  [\#633](https://github.com/bensheldon/good_job/pull/633) ([bensheldon](https://github.com/bensheldon))
+
 ## [v2.99.0](https://github.com/bensheldon/good_job/tree/v2.99.0) (2022-06-26)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v2.17.1...v2.99.0)

data/README.md

@@ -144,9 +144,9 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
 
 ## Compatibility
 
-- **Ruby on Rails:** 5.2+
-- **Ruby:** MRI 2.5+. JRuby 9.2.13+
-- **Postgres:** 9.6+
+- **Ruby on Rails:** 6.0+
+- **Ruby:** Ruby 2.5+. JRuby 9.2.13+
+- **Postgres:** 10.0+
 
 ## Configuration
 
@@ -280,7 +280,7 @@ Available configuration options are:
 - `cleanup_interval_seconds` (integer) Number of seconds a Scheduler will wait before cleaning up preserved jobs. Defaults to `nil`. Can also be set with  the environment variable `GOOD_JOB_CLEANUP_INTERVAL_SECONDS`.
 - `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: `false`)
+- `preserve_job_records` (boolean) keeps job records in your database even after jobs are completed. (Default: `true`)
 - `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: `true`)
 - `on_thread_error` (proc, lambda, or callable) will be called when an Exception. It can be useful for logging errors to bug tracking services, like Sentry or Airbrake. Example:
 
@@ -311,8 +311,8 @@ Good Job’s general behavior can also be configured via attributes directly on
 
 - **`GoodJob.active_record_parent_class`** (string) The ActiveRecord parent class inherited by GoodJob's ActiveRecord model `GoodJob::Job` (defaults to `"ActiveRecord::Base"`). Configure this when using [multiple databases with ActiveRecord](https://guides.rubyonrails.org/active_record_multiple_databases.html) or when other custom configuration is necessary for the ActiveRecord model to connect to the Postgres database. _The value must be a String to avoid premature initialization of ActiveRecord._
 - **`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: `false`)
-- **`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: `true`)
+- **`GoodJob.preserve_job_records`** (boolean) keeps job records in your database even after jobs are completed. (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 an Exception. It can be useful for logging errors to bug tracking services, like Sentry or Airbrake.
 
 You’ll generally want to configure these in `config/initializers/good_job.rb`, like so:
@@ -395,8 +395,6 @@ The Dashboard can be set to automatically refresh by checking "Live Poll" in the
 
 GoodJob can extend ActiveJob to provide limits on concurrently running jobs, either at time of _enqueue_ or at _perform_. Limiting concurrency can help prevent duplicate, double or unecessary jobs from being enqueued, or race conditions when performing, for example when interacting with 3rd-party APIs.
 
-**Note:** Limiting concurrency at _enqueue_ requires Rails 6.0+ because Rails 5.2 cannot halt ActiveJob callbacks.
-
 ```ruby
 class MyJob < ApplicationJob
   include GoodJob::ActiveJobExtensions::Concurrency
@@ -564,9 +562,9 @@ GoodJob.on_thread_error = -> (exception) { Raven.capture_exception(exception) }
 
 #### Retries
 
-By default, GoodJob will automatically and immediately retry a job when an exception is raised to GoodJob.
+By default, GoodJob relies on ActiveJob's retry functionality.
 
-However, ActiveJob can be configured to retry an infinite number of times, with an exponential backoff. Using ActiveJob's `retry_on` prevents exceptions from reaching GoodJob:
+ActiveJob can be configured to retry an infinite number of times, with an exponential backoff. Using ActiveJob's `retry_on` prevents exceptions from reaching GoodJob:
 
 ```ruby
 class ApplicationJob < ActiveJob::Base
@@ -575,14 +573,7 @@ class ApplicationJob < ActiveJob::Base
 end
 ```
 
-When using `retry_on` with _a limited number of retries_, the final exception will not be rescued and will raise to GoodJob. GoodJob can be configured to discard un-handled exceptions instead of retrying them. Be aware that if NOT setting `retry_on_unhandled_error` to `false` good_job will by default retry the failing job and may do this infinitely without pause thereby at least causing high load. In most cases `retry_on_unhandled_error` should be set as following:
-
-```ruby
-# config/initializers/good_job.rb
-GoodJob.retry_on_unhandled_error = false
-```
-
-Alternatively, pass a block to `retry_on` to handle the final exception instead of raising it to GoodJob:
+When using `retry_on` with _a limited number of retries_, the final exception will not be rescued and will raise to GoodJob's error handler. To avoid this, pass a block to `retry_on` to handle the final exception instead of raising it to GoodJob:
 
 ```ruby
 class ApplicationJob < ActiveJob::Base
@@ -613,9 +604,11 @@ class ApplicationJob < ActiveJob::Base
 end
 ```
 
+By default, jobs will not be retried unless `retry_on` is configured. This can be overridden by setting `GoodJob.retry_on_unhandled_error` to `true`; GoodJob will then retry the failing job immediately and infinitely, potentially causing high load.
+
 #### ActionMailer retries
 
-Any configuration in `ApplicationJob` will have to be duplicated on `ActionMailer::MailDeliveryJob` (`ActionMailer::DeliveryJob` in Rails 5.2 or earlier) because ActionMailer uses a custom class, `ActionMailer::MailDeliveryJob`, which inherits from `ActiveJob::Base`,  rather than your applications `ApplicationJob`.
+Any configuration in `ApplicationJob` will have to be duplicated on `ActionMailer::MailDeliveryJob` because ActionMailer uses that custom class which inherits from `ActiveJob::Base`,  rather than your application's `ApplicationJob`.
 
 You can use an initializer to configure `ActionMailer::MailDeliveryJob`, for example:
 
@@ -869,22 +862,31 @@ If your application is already using an ActiveJob backend, you will need to inst
 
 GoodJob is fully instrumented with [`ActiveSupport::Notifications`](https://edgeguides.rubyonrails.org/active_support_instrumentation.html#introduction-to-instrumentation).
 
-By default, GoodJob will destroy job records after they are run, regardless of whether they succeed or not (raising a kind of `StandardError`), unless they are interrupted (raising a kind of `Exception`).
+By default, GoodJob will preserve job records for 14 days after they are run, regardless of whether they succeed or not (raising a kind of `StandardError`), unless they are interrupted (raising a kind of `Exception`).
 
-To preserve job records for later inspection, set an initializer:
+To not preserve job records for later inspection, set an initializer:
 
 ```ruby
 # config/initializers/good_job.rb
-GoodJob.preserve_job_records = true
+GoodJob.preserve_job_records = false # defaults to true, or `false` or `:on_unhandled_error`
+```
+
+GoodJob will automatically delete these job records after 14 days. The retention period, as well as the frequency GoodJob checks for deletable records can be configured:
+
+```ruby
+
+config.cleanup_preserved_jobs_before_seconds_ago = 14.days.to_i
+config.cleanup_interval_jobs = 1_000 # Number of executed jobs between deletion sweeps.
+config.cleanup_interval_seconds = 10.minutes.to_i # Number of seconds between deletion sweeps.
 ```
 
-It is also necessary to destroy these preserved jobs from the database after a certain time period:
+It is also possible to manually trigger a cleanup:
 
 - For example, in a Rake task:
 
     ```ruby
-    GoodJob.cleanup_preserved_jobs # Will keep 1 day of job records by default.
-    GoodJob.cleanup_preserved_jobs(older_than: 7.days) # It also takes custom arguments.
+    GoodJob.cleanup_preserved_jobs # Will use default retention period
+    GoodJob.cleanup_preserved_jobs(older_than: 7.days) # custom retention period
     ```
 
 - For example, using the `good_job` command-line utility:

data/app/charts/good_job/scheduled_by_queue_chart.rb

@@ -9,7 +9,7 @@ module GoodJob
     def data
       end_time = Time.current
       start_time = end_time - 1.day
-      table_name = GoodJob::ActiveJobJob.table_name
+      table_name = GoodJob::Job.table_name
 
       count_query = Arel.sql(GoodJob::Execution.pg_or_jdbc_query(<<~SQL.squish))
         SELECT *

data/app/controllers/good_job/jobs_controller.rb

@@ -10,8 +10,8 @@ module GoodJob
       destroy: "destroyed",
     }.freeze
 
-    rescue_from GoodJob::ActiveJobJob::AdapterNotGoodJobError,
-                GoodJob::ActiveJobJob::ActionForStateMismatchError,
+    rescue_from GoodJob::Job::AdapterNotGoodJobError,
+                GoodJob::Job::ActionForStateMismatchError,
                 with: :redirect_on_error
 
     def index
@@ -26,7 +26,7 @@ module GoodJob
                JobsFilter.new(params).filtered_query
              else
                job_ids = params.fetch(:job_ids, [])
-               ActiveJobJob.where(active_job_id: job_ids)
+               Job.where(active_job_id: job_ids)
              end
 
       processed_jobs = jobs.map do |job|
@@ -42,7 +42,7 @@ module GoodJob
         end
 
         job
-      rescue GoodJob::ActiveJobJob::ActionForStateMismatchError
+      rescue GoodJob::Job::ActionForStateMismatchError
         nil
       end.compact
 
@@ -56,29 +56,29 @@ module GoodJob
     end
 
     def show
-      @job = ActiveJobJob.find(params[:id])
+      @job = Job.find(params[:id])
     end
 
     def discard
-      @job = ActiveJobJob.find(params[:id])
+      @job = Job.find(params[:id])
       @job.discard_job(DISCARD_MESSAGE)
       redirect_back(fallback_location: jobs_path, notice: "Job has been discarded")
     end
 
     def reschedule
-      @job = ActiveJobJob.find(params[:id])
+      @job = Job.find(params[:id])
       @job.reschedule_job
       redirect_back(fallback_location: jobs_path, notice: "Job has been rescheduled")
     end
 
     def retry
-      @job = ActiveJobJob.find(params[:id])
+      @job = Job.find(params[:id])
       @job.retry_job
       redirect_back(fallback_location: jobs_path, notice: "Job has been retried")
     end
 
     def destroy
-      @job = ActiveJobJob.find(params[:id])
+      @job = Job.find(params[:id])
       @job.destroy_job
       redirect_back(fallback_location: jobs_path, notice: "Job has been destroyed")
     end
@@ -87,9 +87,9 @@ module GoodJob
 
     def redirect_on_error(exception)
       alert = case exception
-              when GoodJob::ActiveJobJob::AdapterNotGoodJobError
+              when GoodJob::Job::AdapterNotGoodJobError
                 "ActiveJob Queue Adapter must be GoodJob."
-              when GoodJob::ActiveJobJob::ActionForStateMismatchError
+              when GoodJob::Job::ActionForStateMismatchError
                 "Job is not in an appropriate state for this action."
               else
                 exception.to_s

data/app/controllers/good_job/processes_controller.rb

@@ -2,7 +2,7 @@
 module GoodJob
   class ProcessesController < GoodJob::ApplicationController
     def index
-      @processes = GoodJob::Process.active.order(created_at: :desc) if GoodJob::Process.migrated?
+      @processes = GoodJob::Process.active.order(created_at: :desc)
     end
   end
 end

data/app/filters/good_job/jobs_filter.rb

@@ -31,7 +31,7 @@ module GoodJob
         when 'scheduled'
           query = query.scheduled
         when 'running'
-          query = query.running.select("#{GoodJob::ActiveJobJob.table_name}.*", 'pg_locks.locktype')
+          query = query.running.select("#{GoodJob::Job.table_name}.*", 'pg_locks.locktype')
         when 'queued'
           query = query.queued
         end
@@ -47,7 +47,7 @@ module GoodJob
     private
 
     def default_base_query
-      GoodJob::ActiveJobJob.all
+      GoodJob::Job.all
     end
   end
 end

data/app/views/good_job/processes/index.html.erb

@@ -3,15 +3,7 @@
 </div>
 
 <div data-live-poll-region="processes">
-  <% if !GoodJob::Process.migrated? %>
-    <div class="card my-3">
-      <div class="card-body">
-        <p class="card-text">
-          <em>Feature unavailable because of pending database migration.</em>
-        </p>
-      </div>
-    </div>
-  <% elsif @processes.present? %>
+  <% if @processes.present? %>
     <div class="card my-3">
       <div class="table-responsive">
         <table class="table card-table table-bordered table-hover table-sm mb-0">

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

@@ -16,7 +16,7 @@
   <%= tag.script "", src: rails_ujs_path(format: :js, v: GoodJob::VERSION, locale: nil), nonce: content_security_policy_nonce %>
 
   <%= tag.script "", src: es_module_shims_path(format: :js, v: GoodJob::VERSION, locale: nil), async: true, nonce: content_security_policy_nonce %>
-  <% importmaps = { imports: GoodJob::AssetsController.js_modules.keys.each_with_object({}) { |module_name, imports| imports[module_name] = modules_path(module_name, format: :js, locale: nil, v: GoodJob::VERSION) } } %>
+  <% importmaps = { imports: GoodJob::AssetsController.js_modules.keys.index_with { |module_name| modules_path(module_name, format: :js, locale: nil, v: GoodJob::VERSION) } } %>
   <%= tag.script importmaps.to_json.html_safe, type: "importmap", nonce: content_security_policy_nonce %>
   <%= tag.script "", src: scripts_path(format: :js, v: GoodJob::VERSION, locale: nil), type: "module", nonce: content_security_policy_nonce %>
 </head>

data/lib/generators/good_job/templates/update/migrations/01_create_good_jobs.rb.erb

@@ -18,6 +18,12 @@ class CreateGoodJobs < ActiveRecord::Migration<%= migration_version %>
       t.text :concurrency_key
       t.text :cron_key
       t.uuid :retried_good_job_id
+      t.timestamp :cron_at
+    end
+
+    create_table :good_job_processes, id: :uuid do |t|
+      t.timestamps
+      t.jsonb :state
     end
 
     add_index :good_jobs, :scheduled_at, where: "(finished_at IS NULL)", name: "index_good_jobs_on_scheduled_at"
@@ -25,5 +31,8 @@ class CreateGoodJobs < ActiveRecord::Migration<%= migration_version %>
     add_index :good_jobs, [:active_job_id, :created_at], name: :index_good_jobs_on_active_job_id_and_created_at
     add_index :good_jobs, :concurrency_key, where: "(finished_at IS NULL)", name: :index_good_jobs_on_concurrency_key_when_unfinished
     add_index :good_jobs, [:cron_key, :created_at], name: :index_good_jobs_on_cron_key_and_created_at
+    add_index :good_jobs, [:cron_key, :cron_at], name: :index_good_jobs_on_cron_key_and_cron_at, unique: true
+    add_index :good_jobs, [:active_job_id], name: :index_good_jobs_on_active_job_id
+    add_index :good_jobs, [:finished_at], where: "retried_good_job_id IS NULL AND finished_at IS NOT NULL", name: :index_good_jobs_jobs_on_finished_at
   end
 end

data/lib/good_job/adapter.rb

@@ -20,32 +20,16 @@ module GoodJob
     #
     #  The default value depends on the Rails environment:
     #
-    #  - +development+ and +test+: +:inline+
+    #  - +development+: +:async:+
+    #   -+test+: +:inline+
     #  - +production+ and all other environments: +:external+
     #
-    # @param max_threads [Integer, nil] sets the number of threads per scheduler to use when +execution_mode+ is set to +:async+. The +queues+ parameter can specify a number of threads for each group of queues which will override this value. You can also set this with the environment variable +GOOD_JOB_MAX_THREADS+. Defaults to +5+.
-    # @param queues [String, nil] determines which queues to execute jobs from when +execution_mode+ is set to +:async+. See {file:README.md#optimize-queues-threads-and-processes} for more details on the format of this string. You can also set this with the environment variable +GOOD_JOB_QUEUES+. Defaults to +"*"+.
-    # @param poll_interval [Integer, nil] sets the number of seconds between polls for jobs when +execution_mode+ is set to +:async+. You can also set this with the environment variable +GOOD_JOB_POLL_INTERVAL+. Defaults to +1+.
-    # @param start_async_on_initialize [Boolean] whether to start the async scheduler when the adapter is initialized.
-    def initialize(execution_mode: nil, queues: nil, max_threads: nil, poll_interval: nil, start_async_on_initialize: nil)
-      if queues || max_threads || poll_interval || start_async_on_initialize
-        ActiveSupport::Deprecation.warn(
-          "GoodJob::Adapter's execution-related arguments (queues, max_threads, poll_interval, start_async_on_initialize) have been deprecated and will be removed in GoodJob v3. These options should be configured through GoodJob global configuration instead."
-        )
-      end
-
-      @configuration = GoodJob::Configuration.new(
-        {
-          execution_mode: execution_mode,
-          queues: queues,
-          max_threads: max_threads,
-          poll_interval: poll_interval,
-        }
-      )
+    def initialize(execution_mode: nil)
+      @configuration = GoodJob::Configuration.new({ execution_mode: execution_mode })
       @configuration.validate!
       self.class.instances << self
 
-      start_async if start_async_on_initialize || GoodJob.async_ready?
+      start_async if GoodJob.async_ready?
     end
 
     # Enqueues the ActiveJob job to be performed.
@@ -63,11 +47,7 @@ module GoodJob
     # @return [GoodJob::Execution]
     def enqueue_at(active_job, timestamp)
       scheduled_at = timestamp ? Time.zone.at(timestamp) : nil
-
-      if execute_inline?
-        future_scheduled = scheduled_at && scheduled_at > Time.current
-        will_execute_inline = !future_scheduled || (future_scheduled && !@configuration.inline_execution_respects_schedule?)
-      end
+      will_execute_inline = execute_inline? && (scheduled_at.nil? || scheduled_at <= Time.current)
 
       execution = GoodJob::Execution.enqueue(
         active_job,
@@ -76,29 +56,6 @@ module GoodJob
       )
 
       if will_execute_inline
-        if future_scheduled && !@configuration.inline_execution_respects_schedule?
-          ActiveSupport::Deprecation.warn(<<~DEPRECATION)
-            In the next major release, GoodJob will not *inline* execute
-            future-scheduled jobs.
-
-            To opt into this behavior immediately set:
-            `config.good_job.inline_execution_respects_schedule = true`
-
-            To perform jobs inline at any time, use `GoodJob.perform_inline`.
-
-            For example, using time helpers within an integration test:
-
-            ```
-            MyJob.set(wait: 10.minutes).perform_later
-            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.
-          DEPRECATION
-        end
-
         begin
           result = execution.perform
         ensure

data/lib/good_job/configuration.rb

@@ -15,13 +15,13 @@ module GoodJob
     # Default poll interval for async in development environment
     DEFAULT_DEVELOPMENT_ASYNC_POLL_INTERVAL = -1
     # Default number of threads to use per {Scheduler}
-    DEFAULT_MAX_CACHE = 10000
+    DEFAULT_MAX_CACHE = 10_000
     # Default number of seconds to preserve jobs for {CLI#cleanup_preserved_jobs} and {GoodJob.cleanup_preserved_jobs}
-    DEFAULT_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO = 24 * 60 * 60
+    DEFAULT_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO = 14.days.to_i
     # Default number of jobs to execute between preserved job cleanup runs
-    DEFAULT_CLEANUP_INTERVAL_JOBS = nil
+    DEFAULT_CLEANUP_INTERVAL_JOBS = 1_000
     # Default number of seconds to wait between preserved job cleanup runs
-    DEFAULT_CLEANUP_INTERVAL_SECONDS = nil
+    DEFAULT_CLEANUP_INTERVAL_SECONDS = 10.minutes.to_i
     # Default to always wait for jobs to finish for {Adapter#shutdown}
     DEFAULT_SHUTDOWN_TIMEOUT = -1
     # Default to not running cron

data/lib/good_job/current_thread.rb

@@ -56,8 +56,8 @@ module GoodJob
     # Exports values to hash
     # @return [Hash]
     def self.to_h
-      ACCESSORS.each_with_object({}) do |accessor, hash|
-        hash[accessor] = send(accessor)
+      ACCESSORS.index_with do |accessor|
+        send(accessor)
       end
     end
 

data/lib/good_job/notifier/process_registration.rb

@@ -14,8 +14,6 @@ module GoodJob # :nodoc:
       # Registers the current process.
       def register_process
         GoodJob::Process.with_connection(connection) do
-          next unless Process.migrated?
-
           GoodJob::Process.cleanup
           @process = GoodJob::Process.register
         end
@@ -24,8 +22,6 @@ module GoodJob # :nodoc:
       # Deregisters the current process.
       def deregister_process
         GoodJob::Process.with_connection(connection) do
-          next unless Process.migrated?
-
           @process&.deregister
         end
       end

data/lib/good_job/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module GoodJob
   # GoodJob gem version.
-  VERSION = '2.99.0'
+  VERSION = '3.0.0'
 end

data/lib/good_job.rb

@@ -43,23 +43,21 @@ module GoodJob
 
   # @!attribute [rw] preserve_job_records
   #   @!scope class
-  #   Whether to preserve job records in the database after they have finished (default: +false+).
-  #   By default, GoodJob destroys job records after the job is completed successfully.
+  #   Whether to preserve job records in the database after they have finished (default: +true+).
+  #   By default, GoodJob deletes job records after the job is completed successfully.
   #   If you want to preserve jobs for latter inspection, set this to +true+.
   #   If you want to preserve only jobs that finished with error for latter inspection, set this to +:on_unhandled_error+.
-  #   If +true+, you will need to clean out jobs using the +good_job cleanup_preserved_jobs+ CLI command or
-  #   by using +Goodjob.cleanup_preserved_jobs+.
   #   @return [Boolean, nil]
-  mattr_accessor :preserve_job_records, default: false
+  mattr_accessor :preserve_job_records, default: true
 
   # @!attribute [rw] retry_on_unhandled_error
   #   @!scope class
-  #   Whether to re-perform a job when a type of +StandardError+ is raised to GoodJob (default: +true+).
+  #   Whether to re-perform a job when a type of +StandardError+ is raised to GoodJob (default: +false+).
   #   If +true+, causes jobs to be re-queued and retried if they raise an instance of +StandardError+.
   #   If +false+, jobs will be discarded or marked as finished if they raise an instance of +StandardError+.
   #   Instances of +Exception+, like +SIGINT+, will *always* be retried, regardless of this attribute's value.
   #   @return [Boolean, nil]
-  mattr_accessor :retry_on_unhandled_error, default: true
+  mattr_accessor :retry_on_unhandled_error, default: false
 
   # @!attribute [rw] on_thread_error
   #   @!scope class
@@ -143,7 +141,7 @@ module GoodJob
     include_discarded = configuration.cleanup_discarded_jobs?
 
     ActiveSupport::Notifications.instrument("cleanup_preserved_jobs.good_job", { older_than: older_than, timestamp: timestamp }) do |payload|
-      old_jobs = GoodJob::ActiveJobJob.where('finished_at <= ?', timestamp)
+      old_jobs = GoodJob::Job.where('finished_at <= ?', timestamp)
       old_jobs = old_jobs.not_discarded unless include_discarded
       old_jobs_count = old_jobs.count
 

data/lib/models/good_job/active_job_job.rb

@@ -1,224 +1,11 @@
 # frozen_string_literal: true
 module GoodJob
-  # ActiveRecord model that represents an +ActiveJob+ job.
-  # There is not a table in the database whose discrete rows represents "Jobs".
-  # The +good_jobs+ table is a table of individual {GoodJob::Execution}s that share the same +active_job_id+.
-  # A single row from the +good_jobs+ table of executions is fetched to represent an ActiveJobJob
-  class ActiveJobJob < BaseRecord
-    include Filterable
-    include Lockable
-
-    # Raised when an inappropriate action is applied to a Job based on its state.
-    ActionForStateMismatchError = Class.new(StandardError)
-    # Raised when an action requires GoodJob to be the ActiveJob Queue Adapter but GoodJob is not.
-    AdapterNotGoodJobError = Class.new(StandardError)
-    # Attached to a Job's Execution when the Job is discarded.
-    DiscardJobError = Class.new(StandardError)
-
-    class << self
-      delegate :table_name, to: GoodJob::Execution
-
-      def table_name=(_value)
-        raise NotImplementedError, 'Assign GoodJob::Execution.table_name directly'
-      end
-    end
-
-    self.primary_key = 'active_job_id'
-    self.advisory_lockable_column = 'active_job_id'
-
-    has_many :executions, -> { order(created_at: :asc) }, class_name: 'GoodJob::Execution', foreign_key: 'active_job_id', inverse_of: :job
-
-    # Only the most-recent unretried execution represents a "Job"
-    default_scope { where(retried_good_job_id: nil) }
-
-    # Get Jobs with given class name
-    # @!method job_class
-    # @!scope class
-    # @param string [String] Execution class name
-    # @return [ActiveRecord::Relation]
-    scope :job_class, ->(job_class) { where("serialized_params->>'job_class' = ?", job_class) }
-
-    # Get Jobs finished before the given timestamp.
-    # @!method finished_before(timestamp)
-    # @!scope class
-    # @param timestamp (DateTime, Time)
-    # @return [ActiveRecord::Relation]
-    scope :finished_before, ->(timestamp) { where(arel_table['finished_at'].lteq(timestamp)) }
-
-    # First execution will run in the future
-    scope :scheduled, -> { where(finished_at: nil).where('COALESCE(scheduled_at, created_at) > ?', DateTime.current).where("(serialized_params->>'executions')::integer < 2") }
-    # Execution errored, will run in the future
-    scope :retried, -> { where(finished_at: nil).where('COALESCE(scheduled_at, created_at) > ?', DateTime.current).where("(serialized_params->>'executions')::integer > 1") }
-    # Immediate/Scheduled time to run has passed, waiting for an available thread run
-    scope :queued, -> { where(finished_at: nil).where('COALESCE(scheduled_at, created_at) <= ?', DateTime.current).joins_advisory_locks.where(pg_locks: { locktype: nil }) }
-    # Advisory locked and executing
-    scope :running, -> { where(finished_at: nil).joins_advisory_locks.where.not(pg_locks: { locktype: nil }) }
-    # Completed executing successfully
-    scope :finished, -> { not_discarded.where.not(finished_at: nil) }
-    # Errored but will not be retried
-    scope :discarded, -> { where.not(finished_at: nil).where.not(error: nil) }
-    # Not errored
-    scope :not_discarded, -> { where(error: nil) }
-
-    # The job's ActiveJob UUID
-    # @return [String]
-    def id
-      active_job_id
-    end
-
-    # The ActiveJob job class, as a string
-    # @return [String]
-    def job_class
-      serialized_params['job_class']
-    end
-
-    # The status of the Job, based on the state of its most recent execution.
-    # @return [Symbol]
-    delegate :status, :last_status_at, to: :head_execution
-
-    # This job's most recent {Execution}
-    # @param reload [Booelan] whether to reload executions
-    # @return [Execution]
-    def head_execution(reload: false)
-      executions.reload if reload
-      executions.load # memoize the results
-      executions.last
-    end
-
-    # This job's initial/oldest {Execution}
-    # @return [Execution]
-    def tail_execution
-      executions.first
-    end
-
-    # The number of times this job has been executed, according to ActiveJob's serialized state.
-    # @return [Numeric]
-    def executions_count
-      aj_count = head_execution.serialized_params.fetch('executions', 0)
-      # The execution count within serialized_params is not updated
-      # once the underlying execution has been executed.
-      if status.in? [:discarded, :finished, :running]
-        aj_count + 1
-      else
-        aj_count
-      end
-    end
-
-    # The number of times this job has been executed, according to the number of GoodJob {Execution} records.
-    # @return [Numeric]
-    def preserved_executions_count
-      executions.size
-    end
-
-    # The most recent error message.
-    # If the job has been retried, the error will be fetched from the previous {Execution} record.
-    # @return [String]
-    def recent_error
-      head_execution.error || executions[-2]&.error
-    end
-
-    # Tests whether the job is being executed right now.
-    # @return [Boolean]
-    def running?
-      # Avoid N+1 Query: `.includes_advisory_locks`
-      if has_attribute?(:locktype)
-        self['locktype'].present?
-      else
-        advisory_locked?
-      end
-    end
-
-    # Retry a job that has errored and been discarded.
-    # This action will create a new {Execution} record for the job.
-    # @return [ActiveJob::Base]
-    def retry_job
-      with_advisory_lock do
-        execution = head_execution(reload: true)
-        active_job = execution.active_job
-
-        raise AdapterNotGoodJobError unless active_job.class.queue_adapter.is_a? GoodJob::Adapter
-        raise ActionForStateMismatchError if execution.finished_at.blank? || execution.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
-
-        new_active_job = nil
-        GoodJob::CurrentThread.within do |current_thread|
-          current_thread.execution = execution
-
-          execution.class.transaction(joinable: false, requires_new: true) do
-            new_active_job = active_job.retry_job(wait: 0, error: execution.error)
-            execution.save
-          end
-        end
-        new_active_job
-      end
-    end
-
-    # Discard a job so that it will not be executed further.
-    # This action will add a {DiscardJobError} to the job's {Execution} and mark it as finished.
-    # @return [void]
-    def discard_job(message)
-      with_advisory_lock do
-        execution = head_execution(reload: true)
-        active_job = execution.active_job
-
-        raise ActionForStateMismatchError if execution.finished_at.present?
-
-        job_error = GoodJob::ActiveJobJob::DiscardJobError.new(message)
-
-        update_execution = proc do
-          execution.update(
-            finished_at: Time.current,
-            error: [job_error.class, GoodJob::Execution::ERROR_MESSAGE_SEPARATOR, job_error.message].join
-          )
-        end
-
-        if active_job.respond_to?(:instrument)
-          active_job.send :instrument, :discard, error: job_error, &update_execution
-        else
-          update_execution.call
-        end
-      end
-    end
-
-    # Reschedule a scheduled job so that it executes immediately (or later) by the next available execution thread.
-    # @param scheduled_at [DateTime, Time] When to reschedule the job
-    # @return [void]
-    def reschedule_job(scheduled_at = Time.current)
-      with_advisory_lock do
-        execution = head_execution(reload: true)
-
-        raise ActionForStateMismatchError if execution.finished_at.present?
-
-        execution = head_execution(reload: true)
-        execution.update(scheduled_at: scheduled_at)
-      end
-    end
-
-    # Destroy all of a discarded or finished job's executions from the database so that it will no longer appear on the dashboard.
-    # @return [void]
-    def destroy_job
-      with_advisory_lock do
-        execution = head_execution(reload: true)
-
-        raise ActionForStateMismatchError if execution.finished_at.blank?
-
-        destroy
-      end
-    end
-
-    # Utility method to determine which execution record is used to represent this job
-    # @return [String]
-    def _execution_id
-      attributes['id']
-    end
-
-    # Utility method to test whether this job's underlying attributes represents its most recent execution.
-    # @return [Boolean]
-    def _head?
-      _execution_id == head_execution(reload: true).id
+  # @deprecated Use {GoodJob::Job} instead.
+  class ActiveJobJob < Execution
+    after_initialize do |_job|
+      ActiveSupport::Deprecation.warn(
+        "The `GoodJob::ActiveJobJob` class name is deprecated. Replace with `GoodJob::Job`."
+      )
     end
   end
 end

data/lib/models/good_job/cron_entry.rb

@@ -73,13 +73,13 @@ module GoodJob # :nodoc:
     end
 
     def jobs
-      GoodJob::ActiveJobJob.where(cron_key: key)
+      GoodJob::Job.where(cron_key: key)
     end
 
     def last_at
       return if last_job.blank?
 
-      if GoodJob::ActiveJobJob.column_names.include?('cron_at')
+      if GoodJob::Job.column_names.include?('cron_at')
         (last_job.cron_at || last_job.created_at).localtime
       else
         last_job.created_at
@@ -99,7 +99,7 @@ module GoodJob # :nodoc:
     end
 
     def last_job
-      if GoodJob::ActiveJobJob.column_names.include?('cron_at')
+      if GoodJob::Job.column_names.include?('cron_at')
         jobs.order("cron_at DESC NULLS LAST").first
       else
         jobs.order(created_at: :asc).last

data/lib/models/good_job/execution.rb

@@ -51,7 +51,7 @@ module GoodJob
       end
     end
 
-    belongs_to :job, class_name: 'GoodJob::ActiveJobJob', foreign_key: 'active_job_id', primary_key: 'active_job_id', optional: true, inverse_of: :executions
+    belongs_to :job, class_name: 'GoodJob::Job', foreign_key: 'active_job_id', primary_key: 'active_job_id', optional: true, inverse_of: :executions
 
     # Get Jobs with given ActiveJob ID
     # @!method active_job_id
@@ -207,14 +207,7 @@ module GoodJob
 
         if CurrentThread.cron_key
           execution_args[:cron_key] = CurrentThread.cron_key
-
-          @cron_at_index = column_names.include?('cron_at') && connection.index_name_exists?(:good_jobs, :index_good_jobs_on_cron_key_and_cron_at) unless instance_variable_defined?(:@cron_at_index)
-
-          if @cron_at_index
-            execution_args[:cron_at] = CurrentThread.cron_at
-          else
-            migration_pending_warning!
-          end
+          execution_args[:cron_at] = CurrentThread.cron_at
         elsif CurrentThread.active_job_id && CurrentThread.active_job_id == active_job.job_id
           execution_args[:cron_key] = CurrentThread.execution.cron_key
         end
@@ -346,8 +339,7 @@ module GoodJob
         current_thread.reset
         current_thread.execution = self
 
-        # DEPRECATION: Remove deprecated `good_job:` parameter in GoodJob v3
-        ActiveSupport::Notifications.instrument("perform_job.good_job", { good_job: self, execution: self, process_id: current_thread.process_id, thread_name: current_thread.thread_name }) do
+        ActiveSupport::Notifications.instrument("perform_job.good_job", { execution: self, process_id: current_thread.process_id, thread_name: current_thread.thread_name }) do
           value = ActiveJob::Base.execute(active_job_data)
 
           if value.is_a?(Exception)

data/lib/models/good_job/job.rb

@@ -1,11 +1,224 @@
 # frozen_string_literal: true
 module GoodJob
-  # @deprecated Use {GoodJob::Execution} instead.
-  class Job < Execution
-    after_initialize do |_job|
-      ActiveSupport::Deprecation.warn(
-        "The `GoodJob::Job` class name is deprecated. Replace with `GoodJob::Execution`."
-      )
+  # ActiveRecord model that represents an +ActiveJob+ job.
+  # There is not a table in the database whose discrete rows represents "Jobs".
+  # The +good_jobs+ table is a table of individual {GoodJob::Execution}s that share the same +active_job_id+.
+  # A single row from the +good_jobs+ table of executions is fetched to represent an Job
+  class Job < BaseRecord
+    include Filterable
+    include Lockable
+
+    # Raised when an inappropriate action is applied to a Job based on its state.
+    ActionForStateMismatchError = Class.new(StandardError)
+    # Raised when an action requires GoodJob to be the ActiveJob Queue Adapter but GoodJob is not.
+    AdapterNotGoodJobError = Class.new(StandardError)
+    # Attached to a Job's Execution when the Job is discarded.
+    DiscardJobError = Class.new(StandardError)
+
+    class << self
+      delegate :table_name, to: GoodJob::Execution
+
+      def table_name=(_value)
+        raise NotImplementedError, 'Assign GoodJob::Execution.table_name directly'
+      end
+    end
+
+    self.primary_key = 'active_job_id'
+    self.advisory_lockable_column = 'active_job_id'
+
+    has_many :executions, -> { order(created_at: :asc) }, class_name: 'GoodJob::Execution', foreign_key: 'active_job_id', inverse_of: :job
+
+    # Only the most-recent unretried execution represents a "Job"
+    default_scope { where(retried_good_job_id: nil) }
+
+    # Get Jobs with given class name
+    # @!method job_class
+    # @!scope class
+    # @param string [String] Execution class name
+    # @return [ActiveRecord::Relation]
+    scope :job_class, ->(job_class) { where("serialized_params->>'job_class' = ?", job_class) }
+
+    # Get Jobs finished before the given timestamp.
+    # @!method finished_before(timestamp)
+    # @!scope class
+    # @param timestamp (DateTime, Time)
+    # @return [ActiveRecord::Relation]
+    scope :finished_before, ->(timestamp) { where(arel_table['finished_at'].lteq(timestamp)) }
+
+    # First execution will run in the future
+    scope :scheduled, -> { where(finished_at: nil).where('COALESCE(scheduled_at, created_at) > ?', DateTime.current).where("(serialized_params->>'executions')::integer < 2") }
+    # Execution errored, will run in the future
+    scope :retried, -> { where(finished_at: nil).where('COALESCE(scheduled_at, created_at) > ?', DateTime.current).where("(serialized_params->>'executions')::integer > 1") }
+    # Immediate/Scheduled time to run has passed, waiting for an available thread run
+    scope :queued, -> { where(finished_at: nil).where('COALESCE(scheduled_at, created_at) <= ?', DateTime.current).joins_advisory_locks.where(pg_locks: { locktype: nil }) }
+    # Advisory locked and executing
+    scope :running, -> { where(finished_at: nil).joins_advisory_locks.where.not(pg_locks: { locktype: nil }) }
+    # Completed executing successfully
+    scope :finished, -> { not_discarded.where.not(finished_at: nil) }
+    # Errored but will not be retried
+    scope :discarded, -> { where.not(finished_at: nil).where.not(error: nil) }
+    # Not errored
+    scope :not_discarded, -> { where(error: nil) }
+
+    # The job's ActiveJob UUID
+    # @return [String]
+    def id
+      active_job_id
+    end
+
+    # The ActiveJob job class, as a string
+    # @return [String]
+    def job_class
+      serialized_params['job_class']
+    end
+
+    # The status of the Job, based on the state of its most recent execution.
+    # @return [Symbol]
+    delegate :status, :last_status_at, to: :head_execution
+
+    # This job's most recent {Execution}
+    # @param reload [Booelan] whether to reload executions
+    # @return [Execution]
+    def head_execution(reload: false)
+      executions.reload if reload
+      executions.load # memoize the results
+      executions.last
+    end
+
+    # This job's initial/oldest {Execution}
+    # @return [Execution]
+    def tail_execution
+      executions.first
+    end
+
+    # The number of times this job has been executed, according to ActiveJob's serialized state.
+    # @return [Numeric]
+    def executions_count
+      aj_count = head_execution.serialized_params.fetch('executions', 0)
+      # The execution count within serialized_params is not updated
+      # once the underlying execution has been executed.
+      if status.in? [:discarded, :finished, :running]
+        aj_count + 1
+      else
+        aj_count
+      end
+    end
+
+    # The number of times this job has been executed, according to the number of GoodJob {Execution} records.
+    # @return [Numeric]
+    def preserved_executions_count
+      executions.size
+    end
+
+    # The most recent error message.
+    # If the job has been retried, the error will be fetched from the previous {Execution} record.
+    # @return [String]
+    def recent_error
+      head_execution.error || executions[-2]&.error
+    end
+
+    # Tests whether the job is being executed right now.
+    # @return [Boolean]
+    def running?
+      # Avoid N+1 Query: `.includes_advisory_locks`
+      if has_attribute?(:locktype)
+        self['locktype'].present?
+      else
+        advisory_locked?
+      end
+    end
+
+    # Retry a job that has errored and been discarded.
+    # This action will create a new {Execution} record for the job.
+    # @return [ActiveJob::Base]
+    def retry_job
+      with_advisory_lock do
+        execution = head_execution(reload: true)
+        active_job = execution.active_job
+
+        raise AdapterNotGoodJobError unless active_job.class.queue_adapter.is_a? GoodJob::Adapter
+        raise ActionForStateMismatchError if execution.finished_at.blank? || execution.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
+
+        new_active_job = nil
+        GoodJob::CurrentThread.within do |current_thread|
+          current_thread.execution = execution
+
+          execution.class.transaction(joinable: false, requires_new: true) do
+            new_active_job = active_job.retry_job(wait: 0, error: execution.error)
+            execution.save
+          end
+        end
+        new_active_job
+      end
+    end
+
+    # Discard a job so that it will not be executed further.
+    # This action will add a {DiscardJobError} to the job's {Execution} and mark it as finished.
+    # @return [void]
+    def discard_job(message)
+      with_advisory_lock do
+        execution = head_execution(reload: true)
+        active_job = execution.active_job
+
+        raise ActionForStateMismatchError if execution.finished_at.present?
+
+        job_error = GoodJob::Job::DiscardJobError.new(message)
+
+        update_execution = proc do
+          execution.update(
+            finished_at: Time.current,
+            error: [job_error.class, GoodJob::Execution::ERROR_MESSAGE_SEPARATOR, job_error.message].join
+          )
+        end
+
+        if active_job.respond_to?(:instrument)
+          active_job.send :instrument, :discard, error: job_error, &update_execution
+        else
+          update_execution.call
+        end
+      end
+    end
+
+    # Reschedule a scheduled job so that it executes immediately (or later) by the next available execution thread.
+    # @param scheduled_at [DateTime, Time] When to reschedule the job
+    # @return [void]
+    def reschedule_job(scheduled_at = Time.current)
+      with_advisory_lock do
+        execution = head_execution(reload: true)
+
+        raise ActionForStateMismatchError if execution.finished_at.present?
+
+        execution = head_execution(reload: true)
+        execution.update(scheduled_at: scheduled_at)
+      end
+    end
+
+    # Destroy all of a discarded or finished job's executions from the database so that it will no longer appear on the dashboard.
+    # @return [void]
+    def destroy_job
+      with_advisory_lock do
+        execution = head_execution(reload: true)
+
+        raise ActionForStateMismatchError if execution.finished_at.blank?
+
+        destroy
+      end
+    end
+
+    # Utility method to determine which execution record is used to represent this job
+    # @return [String]
+    def _execution_id
+      attributes['id']
+    end
+
+    # Utility method to test whether this job's underlying attributes represents its most recent execution.
+    # @return [Boolean]
+    def _head?
+      _execution_id == head_execution(reload: true).id
     end
   end
 end

data/lib/models/good_job/process.rb

@@ -25,15 +25,6 @@ module GoodJob # :nodoc:
     # @return [ActiveRecord::Relation]
     scope :inactive, -> { advisory_unlocked }
 
-    # Whether the +good_job_processes+ table exsists.
-    # @return [Boolean]
-    def self.migrated?
-      return true if connection.table_exists?(table_name)
-
-      migration_pending_warning!
-      false
-    end
-
     # UUID that is unique to the current process and changes when forked.
     # @return [String]
     def self.current_id

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 2.99.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Ben Sheldon
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.2.0
+        version: 6.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.2.0
+        version: 6.0.0
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.2.0
+        version: 6.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.2.0
+        version: 6.0.0
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.2.0
+        version: 6.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.2.0
+        version: 6.0.0
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -414,10 +414,6 @@ 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_cron_at_to_good_jobs.rb.erb
-- lib/generators/good_job/templates/update/migrations/03_add_cron_key_cron_at_index_to_good_jobs.rb.erb
-- lib/generators/good_job/templates/update/migrations/04_create_good_job_processes.rb.erb
-- lib/generators/good_job/templates/update/migrations/04_index_good_job_jobs_on_finished_at.rb.erb
 - lib/generators/good_job/update_generator.rb
 - lib/good_job.rb
 - lib/good_job/active_job_extensions.rb

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

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-class AddCronAtToGoodJobs < 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_jobs, :cron_at)
-      end
-    end
-
-    add_column :good_jobs, :cron_at, :timestamp
-  end
-end

data/lib/generators/good_job/templates/update/migrations/03_add_cron_key_cron_at_index_to_good_jobs.rb.erb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-class AddCronKeyCronAtIndexToGoodJobs < ActiveRecord::Migration<%= migration_version %>
-  disable_ddl_transaction!
-
-  def change
-    reversible do |dir|
-      dir.up do
-        # Ensure this incremental update migration is idempotent
-        # with monolithic install migration.
-        return if connection.index_name_exists?(:good_jobs, :index_good_jobs_on_cron_key_and_cron_at)
-      end
-    end
-
-    add_index :good_jobs,
-              [:cron_key, :cron_at],
-              algorithm: :concurrently,
-              name: :index_good_jobs_on_cron_key_and_cron_at,
-              unique: true
-  end
-end

data/lib/generators/good_job/templates/update/migrations/04_create_good_job_processes.rb.erb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-class CreateGoodJobProcesses < 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.table_exists?(:good_job_processes)
-      end
-    end
-
-    create_table :good_job_processes, id: :uuid do |t|
-      t.timestamps
-      t.jsonb :state
-    end
-  end
-end

data/lib/generators/good_job/templates/update/migrations/04_index_good_job_jobs_on_finished_at.rb.erb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-class IndexGoodJobJobsOnFinishedAt < ActiveRecord::Migration<%= migration_version %>
-  disable_ddl_transaction!
-
-  def change
-    reversible do |dir|
-      dir.up do
-        # Ensure this incremental update migration is idempotent
-        # with monolithic install migration.
-        return if connection.index_name_exists?(:good_jobs, :index_good_jobs_on_active_job_id)
-      end
-    end
-
-    add_index :good_jobs,
-              [:active_job_id],
-              name: :index_good_jobs_on_active_job_id,
-              algorithm: :concurrently
-
-    add_index :good_jobs,
-              [:finished_at],
-              where: "retried_good_job_id IS NULL AND finished_at IS NOT NULL",
-              name: :index_good_jobs_jobs_on_finished_at,
-              algorithm: :concurrently
-  end
-end