good_job 3.30.1 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ca44ad0fbf6d55478287f58fb49c9295ebcbbb5875ec8c3c2e94859dec23393
-  data.tar.gz: ded000fbd60a45e9028a97bda6f1dc0240310a7b9281708d15543331a8a19706
+  metadata.gz: 3a4006c920a731f763e36a964e7eb161a292e8a4b34bffa4b60b95b75145c28c
+  data.tar.gz: f54b107db6ac1e2304a4ee9e2d34fa65032dc2b1ab0425e0be5ea42d39e5590b
 SHA512:
-  metadata.gz: 4d09ea0dcb8801f3ca577b349e9f671bdf70c4df38ace8b96e9b5bda8f22bc2bc4791a261c4816e2beca82aa17f188c9521f89be4460f4097d5e8a03a4f2c281
-  data.tar.gz: 73ab002472752c47682c508b4828dfd359e9aebebc997b76f69c91f6cf5dd0ab12a4bc171fbc6f3d967e17b2a4b26a52f6afe311d43dbc90331c565a79443e25
+  metadata.gz: 4474aaa0540dc5ff1bba65e8807a6fa69a9901f2e68051c57cf954e30270e9e6d7eaf52a3ce8ec7de6f48b16fc60fa05e796f595f14dfda41a76cbeb5b042543
+  data.tar.gz: cf8103c84fceffe91e4f7b0f5083c3989d2312a17ce96b1db01d7726a99b651c7d850f83fe23075c5a01628a825ef71d335d0eb42e91a478a62dd7772ee95e54

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [v4.0.0](https://github.com/bensheldon/good_job/tree/v4.0.0) (2024-07-07)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v3.99.0...v4.0.0)
+
+**Implemented enhancements:**
+
+- Release GoodJob v4 [\#1394](https://github.com/bensheldon/good_job/pull/1394) ([bensheldon](https://github.com/bensheldon))
+
+## [v3.99.0](https://github.com/bensheldon/good_job/tree/v3.99.0) (2024-07-07)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v3.30.1...v3.99.0)
+
+**Merged pull requests:**
+
+- Remove deprecation silencers for v3.99 release [\#1395](https://github.com/bensheldon/good_job/pull/1395) ([bensheldon](https://github.com/bensheldon))
+- Add instructions and `GoodJob.v4_ready?` for upgrading to v4 [\#1356](https://github.com/bensheldon/good_job/pull/1356) ([bensheldon](https://github.com/bensheldon))
+
 ## [v3.30.1](https://github.com/bensheldon/good_job/tree/v3.30.1) (2024-07-06)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v3.30.0...v3.30.1)

data/README.md

@@ -53,6 +53,7 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
     - [Batches](#batches)
     - [Updating](#updating)
         - [Upgrading minor versions](#upgrading-minor-versions)
+        - [Upgrading v3 to v4](#upgrading-v3-to-v4)
         - [Upgrading v2 to v3](#upgrading-v2-to-v3)
         - [Upgrading v1 to v2](#upgrading-v1-to-v2)
 - [Go deeper](#go-deeper)
@@ -873,6 +874,27 @@ To perform upgrades to the GoodJob database tables:
 1. Commit the migration files and resulting `db/schema.rb` changes.
 1. Deploy the code, run the migrations against the production database, and restart server/worker processes.
 
+#### Upgrading v3 to v4
+
+GoodJob v4 changes how job and job execution records are stored in the database; moving from job and executions being commingled in the `good_jobs` table to separately and discretely storing job executions in `good_job_executions`. To safely upgrade, all unfinished jobs must use the new format. This change was introduced in GoodJob [v3.15.4 (April 2023)](https://github.com/bensheldon/good_job/releases/tag/v3.15.4), so your application is likely ready-to-upgrade already if you have kept up with GoodJob updates.
+
+To upgrade:
+
+1. Upgrade to v3.99.x, following the minor version upgrade process, running any remaining database migrations (rails g good_job:update) and addressing deprecation warnings.
+1. Check if your application is safe to upgrade to the new job record format by running either:
+    - In a production console, run `GoodJob.v4_ready?` which should return `true` when safely upgradable.
+    - Or, when connected to the production database verify that `SELECT COUNT(*) FROM "good_jobs" WHERE finished_at IS NULL AND is_discrete IS NOT TRUE` returns `0`
+
+    If not all unfinished jobs are stored in the new format, either wait to upgrade until those jobs finish or discard them. Not waiting could prevent those jobs from successfully running when upgrading to v4.
+1. Upgrade from v3.99.x to v4.x.
+
+Notable changes:
+
+- Only supports Rails 6.1+, CRuby 3.0+ and JRuby 9.4+, Postgres 12+. Rails 6.0 is no longer supported. CRuby 2.6 and 2.7 are no longer supported. JRuby 9.3 is no longer supported.
+- Changes job `priority` to give smaller numbers higher priority (default: `0`), in accordance with Active Job's definition of priority.
+- Enqueues and executes jobs via the `GoodJob::Job` model instead of `GoodJob::Execution`
+- Setting `config.good_job.cleanup_interval_jobs`, `GOOD_JOB_CLEANUP_INTERVAL_JOBS`, `config.good_job.cleanup_interval_seconds`, or `GOOD_JOB_CLEANUP_INTERVAL_SECONDS` to `nil` or `""` no longer disables count- or time-based cleanups. Set to `false` to disable, or `-1` to run a cleanup after every job execution.
+
 #### Upgrading v2 to v3
 
 GoodJob v3 is operationally identical to v2; upgrading to GoodJob v3 should be simple. If you are already using `>= v2.9+` no other changes are necessary.

data/app/charts/good_job/scheduled_by_queue_chart.rb

@@ -11,7 +11,7 @@ module GoodJob
       start_time = end_time - 1.day
       table_name = GoodJob::Job.table_name
 
-      count_query = Arel.sql(GoodJob::Execution.pg_or_jdbc_query(<<~SQL.squish))
+      count_query = Arel.sql(GoodJob::Job.pg_or_jdbc_query(<<~SQL.squish))
         SELECT *
         FROM generate_series(
           date_trunc('hour', $1::timestamp),
@@ -35,7 +35,7 @@ module GoodJob
         ActiveRecord::Relation::QueryAttribute.new('start_time', start_time, ActiveRecord::Type::DateTime.new),
         ActiveRecord::Relation::QueryAttribute.new('end_time', end_time, ActiveRecord::Type::DateTime.new),
       ]
-      executions_data = GoodJob::Execution.connection.exec_query(GoodJob::Execution.pg_or_jdbc_query(count_query), "GoodJob Dashboard Chart", binds)
+      executions_data = GoodJob::Job.connection.exec_query(GoodJob::Job.pg_or_jdbc_query(count_query), "GoodJob Dashboard Chart", binds)
 
       queue_names = executions_data.reject { |d| d['count'].nil? }.map { |d| d['queue_name'] || BaseFilter::EMPTY }.uniq
       labels = []

data/app/controllers/good_job/cron_entries_controller.rb

@@ -2,8 +2,6 @@
 
 module GoodJob
   class CronEntriesController < GoodJob::ApplicationController
-    before_action :check_settings_migration!, only: [:enable, :disable]
-
     def index
       @cron_entries = CronEntry.all
     end
@@ -30,11 +28,5 @@ module GoodJob
       @cron_entry.disable
       redirect_back(fallback_location: cron_entries_path, notice: t(".notice"))
     end
-
-    private
-
-    def check_settings_migration!
-      redirect_back(fallback_location: cron_entries_path, alert: t("good_job.cron_entries.pending_migrations")) unless GoodJob::Setting.migrated?
-    end
   end
 end

data/app/controllers/good_job/metrics_controller.rb

@@ -4,7 +4,7 @@ module GoodJob
   class MetricsController < ApplicationController
     def primary_nav
       jobs_count = GoodJob::Job.count
-      batches_count = GoodJob::BatchRecord.migrated? ? GoodJob::BatchRecord.all.size : 0
+      batches_count = GoodJob::BatchRecord.all.size
       cron_entries_count = GoodJob::CronEntry.all.size
       processes_count = GoodJob::Process.active.count
 

data/app/controllers/good_job/performances_controller.rb

@@ -3,21 +3,17 @@
 module GoodJob
   class PerformancesController < ApplicationController
     def show
-      if GoodJob::DiscreteExecution.duration_interval_migrated?
-        @performances = GoodJob::DiscreteExecution
-                        .where.not(job_class: nil)
-                        .group(:job_class)
-                        .select("
+      @performances = GoodJob::DiscreteExecution
+                      .where.not(job_class: nil)
+                      .group(:job_class)
+                      .select("
                             job_class,
                             COUNT(*) AS executions_count,
                             AVG(duration) AS avg_duration,
                             MIN(duration) AS min_duration,
                             MAX(duration) AS max_duration
                           ")
-                        .order("job_class")
-      else
-        @needs_upgrade = true
-      end
+                      .order("job_class")
     end
   end
 end

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

@@ -35,7 +35,7 @@ module GoodJob
         next if query.blank?
 
         # TODO: turn this into proper bind parameters in Arel
-        tsvector = "(to_tsvector('english', id::text) || to_tsvector('english', COALESCE(active_job_id::text, '')) || to_tsvector('english', serialized_params) || to_tsvector('english', COALESCE(error, ''))#{" || to_tsvector('english', COALESCE(array_to_string(labels, ' '), ''))" if labels_migrated?})"
+        tsvector = "(to_tsvector('english', id::text) || to_tsvector('english', COALESCE(active_job_id::text, '')) || to_tsvector('english', serialized_params) || to_tsvector('english', COALESCE(error, '')) || to_tsvector('english', COALESCE(array_to_string(labels, ' '), '')))"
         to_tsquery_function = database_supports_websearch_to_tsquery? ? 'websearch_to_tsquery' : 'plainto_tsquery'
         where("#{tsvector} @@ #{to_tsquery_function}(?)", query)
           .order(sanitize_sql_for_order([Arel.sql("ts_rank(#{tsvector}, #{to_tsquery_function}(?))"), query]) => 'DESC')

data/app/models/good_job/base_execution.rb

@@ -74,9 +74,6 @@ module GoodJob
       end
     end
 
-    belongs_to :batch, class_name: 'GoodJob::BatchRecord', optional: true, inverse_of: :executions
-    has_many :discrete_executions, class_name: 'GoodJob::DiscreteExecution', foreign_key: 'active_job_id', primary_key: 'active_job_id', inverse_of: :execution # rubocop:disable Rails/HasManyOrHasOneDependent
-
     # With a given class name
     # @!method job_class(name)
     # @!scope class
@@ -84,11 +81,6 @@ module GoodJob
     # @return [ActiveRecord::Relation]
     scope :job_class, ->(name) { where(params_job_class.eq(name)) }
 
-    after_destroy lambda {
-      GoodJob::DiscreteExecution.where(active_job_id: active_job_id).delete_all if discrete? # TODO: move into association `dependent: :delete_all` after v4
-      self.class.active_job_id(active_job_id).delete_all
-    }, if: -> { @_destroy_job }
-
     # Get jobs with given ActiveJob ID
     # @!method active_job_id(active_job_id)
     # @!scope class
@@ -226,67 +218,12 @@ module GoodJob
       end
 
       def discrete_support?
-        GoodJob::DiscreteExecution.migrated?
-      end
-
-      def error_event_migrated?
-        return true if columns_hash["error_event"].present?
-
-        migration_pending_warning!
-        false
-      end
-
-      def cron_indices_migrated?
-        return true if connection.index_name_exists?(:good_jobs, :index_good_jobs_on_cron_key_and_created_at_cond)
-
-        migration_pending_warning!
-        false
-      end
-
-      def labels_migrated?
-        return true if columns_hash["labels"].present?
-
-        migration_pending_warning!
-        false
-      end
-
-      def labels_indices_migrated?
-        return true if connection.index_name_exists?(:good_jobs, :index_good_jobs_on_labels)
-
-        migration_pending_warning!
-        false
+        true
       end
-
-      def active_job_id_index_removal_migrated?
-        return true unless connection.index_name_exists?(:good_jobs, :index_good_jobs_on_active_job_id)
-
-        migration_pending_warning!
-        false
-      end
-
-      def candidate_lookup_index_migrated?
-        return true if connection.index_name_exists?(:good_jobs, :index_good_job_jobs_for_candidate_lookup)
-
-        migration_pending_warning!
-        false
-      end
-
-      def process_lock_migrated?
-        return true if connection.index_name_exists?(:good_job_executions, :index_good_job_executions_on_process_id_and_created_at)
-
-        migration_pending_warning!
-        false
-      end
-    end
-
-    # The ActiveJob job class, as a string
-    # @return [String]
-    def job_class
-      discrete? ? attributes['job_class'] : serialized_params['job_class']
     end
 
     def discrete?
-      self.class.discrete_support? && is_discrete?
+      is_discrete?
     end
 
     # Build an ActiveJob instance and deserialize the arguments, using `#active_job_data`.
@@ -304,55 +241,54 @@ module GoodJob
       raise unless ignore_deserialization_errors
     end
 
-    def self.build_for_enqueue(active_job, overrides = {})
-      new(**enqueue_args(active_job, overrides))
+    def self.build_for_enqueue(active_job, scheduled_at: nil)
+      new(**enqueue_args(active_job, scheduled_at: scheduled_at))
     end
 
     # Construct arguments for GoodJob::Execution from an ActiveJob instance.
-    def self.enqueue_args(active_job, overrides = {})
-      if active_job.priority && GoodJob.configuration.smaller_number_is_higher_priority.nil?
-        GoodJob.deprecator.warn(<<~DEPRECATION)
-          The next major version of GoodJob (v4.0) will change job `priority` to give smaller numbers higher priority (default: `0`), in accordance with Active Job's definition of priority.
-            To opt-in to this behavior now, set `config.good_job.smaller_number_is_higher_priority = true` in your GoodJob initializer or application.rb.
-            To not opt-in yet, but silence this deprecation warning, set `config.good_job.smaller_number_is_higher_priority = false`.
-        DEPRECATION
-      end
-
+    def self.enqueue_args(active_job, scheduled_at: nil)
       execution_args = {
+        id: active_job.job_id,
         active_job_id: active_job.job_id,
+        job_class: active_job.class.name,
         queue_name: active_job.queue_name.presence || DEFAULT_QUEUE_NAME,
         priority: active_job.priority || DEFAULT_PRIORITY,
         serialized_params: active_job.serialize,
+        created_at: Time.current,
       }
-      execution_args[:scheduled_at] = Time.zone.at(active_job.scheduled_at) if active_job.scheduled_at
+
+      execution_args[:scheduled_at] = if scheduled_at
+                                        scheduled_at
+                                      elsif active_job.scheduled_at
+                                        Time.zone.at(active_job.scheduled_at)
+                                      else
+                                        execution_args[:created_at]
+                                      end
+
       execution_args[:concurrency_key] = active_job.good_job_concurrency_key if active_job.respond_to?(:good_job_concurrency_key)
 
-      if active_job.respond_to?(:good_job_labels) && active_job.good_job_labels.any? && labels_migrated?
+      if active_job.respond_to?(:good_job_labels) && active_job.good_job_labels.any?
         labels = active_job.good_job_labels.dup
         labels.map! { |label| label.to_s.strip.presence }
         labels.tap(&:compact!).tap(&:uniq!)
         execution_args[:labels] = labels
       end
 
-      reenqueued_current_execution = CurrentThread.active_job_id && CurrentThread.active_job_id == active_job.job_id
-      current_execution = CurrentThread.execution
+      reenqueued_current_job = CurrentThread.active_job_id && CurrentThread.active_job_id == active_job.job_id
+      current_job = CurrentThread.job
 
-      if reenqueued_current_execution
-        if GoodJob::BatchRecord.migrated?
-          execution_args[:batch_id] = current_execution.batch_id
-          execution_args[:batch_callback_id] = current_execution.batch_callback_id
-        end
-        execution_args[:cron_key] = current_execution.cron_key
+      if reenqueued_current_job
+        execution_args[:batch_id] = current_job.batch_id
+        execution_args[:batch_callback_id] = current_job.batch_callback_id
+        execution_args[:cron_key] = current_job.cron_key
       else
-        if GoodJob::BatchRecord.migrated?
-          execution_args[:batch_id] = GoodJob::Batch.current_batch_id
-          execution_args[:batch_callback_id] = GoodJob::Batch.current_batch_callback_id
-        end
+        execution_args[:batch_id] = GoodJob::Batch.current_batch_id
+        execution_args[:batch_callback_id] = GoodJob::Batch.current_batch_callback_id
         execution_args[:cron_key] = CurrentThread.cron_key
         execution_args[:cron_at] = CurrentThread.cron_at
       end
 
-      execution_args.merge(overrides)
+      execution_args
     end
 
     # Finds the next eligible Execution, acquire an advisory lock related to it, and
@@ -364,21 +300,23 @@ module GoodJob
     #   raised, if any (if the job raised, then the second array entry will be
     #   +nil+). If there were no jobs to execute, returns +nil+.
     def self.perform_with_advisory_lock(lock_id:, parsed_queues: nil, queue_select_limit: nil)
-      execution = nil
+      job = nil
       result = nil
 
-      unfinished.dequeueing_ordered(parsed_queues).only_scheduled.limit(1).with_advisory_lock(select_limit: queue_select_limit) do |executions|
-        execution = executions.first
-        if execution&.executable?
-          yield(execution) if block_given?
-          result = execution.perform(lock_id: lock_id)
+      unfinished.dequeueing_ordered(parsed_queues).only_scheduled.limit(1).with_advisory_lock(select_limit: queue_select_limit) do |jobs|
+        job = jobs.first
+
+        if job&.executable?
+          yield(job) if block_given?
+
+          result = job.perform(lock_id: lock_id)
         else
-          execution = nil
+          job = nil
           yield(nil) if block_given?
         end
       end
 
-      execution&.run_callbacks(:perform_unlocked)
+      job&.run_callbacks(:perform_unlocked)
       result
     end
 
@@ -414,46 +352,38 @@ module GoodJob
     #   The new {Execution} instance representing the queued ActiveJob job.
     def self.enqueue(active_job, scheduled_at: nil, create_with_advisory_lock: false)
       ActiveSupport::Notifications.instrument("enqueue_job.good_job", { active_job: active_job, scheduled_at: scheduled_at, create_with_advisory_lock: create_with_advisory_lock }) do |instrument_payload|
-        current_execution = CurrentThread.execution
+        current_job = CurrentThread.job
 
-        retried = current_execution && current_execution.active_job_id == active_job.job_id
+        retried = current_job && current_job.active_job_id == active_job.job_id
         if retried
-          if current_execution.discrete?
-            execution = current_execution
-            execution.assign_attributes(enqueue_args(active_job, { scheduled_at: scheduled_at }))
-            execution.scheduled_at ||= Time.current
-            # TODO: these values ideally shouldn't be persisted until the current_execution is finished
-            #   which will require handling `retry_job` being called from outside the execution context.
-            execution.performed_at = nil
-            execution.finished_at = nil
-          else
-            execution = build_for_enqueue(active_job, { scheduled_at: scheduled_at })
-          end
+          job = current_job
+          job.assign_attributes(enqueue_args(active_job, scheduled_at: scheduled_at))
+          job.scheduled_at ||= Time.current
+          # TODO: these values ideally shouldn't be persisted until the current_job is finished
+          #   which will require handling `retry_job` being called from outside the job context.
+          job.performed_at = nil
+          job.finished_at = nil
         else
-          execution = build_for_enqueue(active_job, { scheduled_at: scheduled_at })
-          execution.make_discrete if discrete_support?
+          job = build_for_enqueue(active_job, scheduled_at: scheduled_at)
         end
 
         if create_with_advisory_lock
-          if execution.persisted?
-            execution.advisory_lock
+          if job.persisted?
+            job.advisory_lock
           else
-            execution.create_with_advisory_lock = true
+            job.create_with_advisory_lock = true
           end
         end
 
-        instrument_payload[:execution] = execution
-        execution.save!
+        instrument_payload[:job] = job
+        job.save!
 
-        if retried
-          CurrentThread.execution_retried = execution
-          CurrentThread.execution.retried_good_job_id = execution.id unless current_execution.discrete?
-        else
-          CurrentThread.execution_retried = nil
-        end
+        CurrentThread.execution_retried = (job if retried)
 
-        active_job.provider_job_id = execution.id
-        execution
+        active_job.provider_job_id = job.id
+        raise "These should be equal" if active_job.provider_job_id != active_job.job_id
+
+        job
       end
     end
 
@@ -477,64 +407,47 @@ module GoodJob
         discrete_execution = nil
         result = GoodJob::CurrentThread.within do |current_thread|
           current_thread.reset
-          current_thread.execution = self
+          current_thread.job = self
 
           existing_performed_at = performed_at
           if existing_performed_at
             current_thread.execution_interrupted = existing_performed_at
 
-            if discrete?
-              interrupt_error_string = self.class.format_error(GoodJob::InterruptError.new("Interrupted after starting perform at '#{existing_performed_at}'"))
-              self.error = interrupt_error_string
-              self.error_event = ERROR_EVENT_INTERRUPTED if self.class.error_event_migrated?
-              monotonic_duration = (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - monotonic_start).seconds
-
-              discrete_execution_attrs = {
-                error: interrupt_error_string,
-                finished_at: job_performed_at,
-              }
-              discrete_execution_attrs[:error_event] = GoodJob::ErrorEvents::ERROR_EVENT_ENUMS[GoodJob::ErrorEvents::ERROR_EVENT_INTERRUPTED] if self.class.error_event_migrated?
-              discrete_execution_attrs[:duration] = monotonic_duration if GoodJob::DiscreteExecution.duration_interval_usable?
-              discrete_executions.where(finished_at: nil).where.not(performed_at: nil).update_all(discrete_execution_attrs) # rubocop:disable Rails/SkipsModelValidations
-            end
+            interrupt_error_string = self.class.format_error(GoodJob::InterruptError.new("Interrupted after starting perform at '#{existing_performed_at}'"))
+            self.error = interrupt_error_string
+            self.error_event = ERROR_EVENT_INTERRUPTED
+            monotonic_duration = (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - monotonic_start).seconds
+
+            discrete_execution_attrs = {
+              error: interrupt_error_string,
+              finished_at: job_performed_at,
+            }
+            discrete_execution_attrs[:error_event] = GoodJob::ErrorEvents::ERROR_EVENT_ENUMS[GoodJob::ErrorEvents::ERROR_EVENT_INTERRUPTED]
+            discrete_execution_attrs[:duration] = monotonic_duration
+            discrete_executions.where(finished_at: nil).where.not(performed_at: nil).update_all(discrete_execution_attrs) # rubocop:disable Rails/SkipsModelValidations
           end
 
-          if discrete?
-            transaction do
-              discrete_execution_attrs = {
-                job_class: job_class,
-                queue_name: queue_name,
-                serialized_params: serialized_params,
-                scheduled_at: (scheduled_at || created_at),
-                created_at: job_performed_at,
-              }
-              discrete_execution_attrs[:process_id] = lock_id if GoodJob::DiscreteExecution.columns_hash.key?("process_id")
-
-              execution_attrs = {
-                performed_at: job_performed_at,
-                executions_count: ((executions_count || 0) + 1),
-              }
-              if GoodJob::Execution.columns_hash.key?("locked_by_id")
-                execution_attrs[:locked_by_id] = lock_id
-                execution_attrs[:locked_at] = Time.current
-              end
-
-              discrete_execution = discrete_executions.create!(discrete_execution_attrs)
-              update!(execution_attrs)
-            end
-          else
-            execution_attrs = {
+          transaction do
+            discrete_execution_attrs = {
+              job_class: job_class,
+              queue_name: queue_name,
+              serialized_params: serialized_params,
+              scheduled_at: (scheduled_at || created_at),
+              created_at: job_performed_at,
+              process_id: lock_id,
+            }
+            job_attrs = {
               performed_at: job_performed_at,
+              executions_count: ((executions_count || 0) + 1),
+              locked_by_id: lock_id,
+              locked_at: Time.current,
             }
-            if GoodJob::Execution.columns_hash.key?("locked_by_id")
-              execution_attrs[:locked_by_id] = lock_id
-              execution_attrs[:locked_at] = Time.current
-            end
 
-            update!(execution_attrs)
+            discrete_execution = discrete_executions.create!(discrete_execution_attrs)
+            update!(job_attrs)
           end
 
-          ActiveSupport::Notifications.instrument("perform_job.good_job", { execution: self, process_id: current_thread.process_id, thread_name: current_thread.thread_name }) do |instrument_payload|
+          ActiveSupport::Notifications.instrument("perform_job.good_job", { job: self, execution: discrete_execution, process_id: current_thread.process_id, thread_name: current_thread.thread_name }) do |instrument_payload|
             value = ActiveJob::Base.execute(active_job_data)
 
             if value.is_a?(Exception)
@@ -585,50 +498,39 @@ module GoodJob
           error_string = self.class.format_error(job_error)
 
           job_attributes[:error] = error_string
-          job_attributes[:error_event] = result.error_event if self.class.error_event_migrated?
-          if discrete_execution
-            discrete_execution.error = error_string
-            discrete_execution.error_event = result.error_event
-            discrete_execution.error_backtrace = job_error.backtrace if discrete_execution.class.backtrace_migrated?
-          end
+          job_attributes[:error_event] = result.error_event
+
+          discrete_execution.error = error_string
+          discrete_execution.error_event = result.error_event
+          discrete_execution.error_backtrace = job_error.backtrace
         else
           job_attributes[:error] = nil
           job_attributes[:error_event] = nil
         end
-        job_attributes.delete(:error_event) unless self.class.error_event_migrated?
 
         job_finished_at = Time.current
         monotonic_duration = (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - monotonic_start).seconds
         job_attributes[:finished_at] = job_finished_at
-        if discrete_execution
-          discrete_execution.finished_at = job_finished_at
-          discrete_execution.duration = monotonic_duration if GoodJob::DiscreteExecution.duration_interval_usable?
-        end
+
+        discrete_execution.finished_at = job_finished_at
+        discrete_execution.duration = monotonic_duration
 
         retry_unhandled_error = result.unhandled_error && GoodJob.retry_on_unhandled_error
         reenqueued = result.retried? || retried_good_job_id.present? || retry_unhandled_error
         if reenqueued
-          if discrete_execution
-            job_attributes[:performed_at] = nil
-            job_attributes[:finished_at] = nil
-          else
-            job_attributes[:retried_good_job_id] = retried_good_job_id
-            job_attributes[:finished_at] = nil if retry_unhandled_error
-          end
+          job_attributes[:performed_at] = nil
+          job_attributes[:finished_at] = nil
         end
 
+        assign_attributes(job_attributes)
         preserve_unhandled = (result.unhandled_error && (GoodJob.retry_on_unhandled_error || GoodJob.preserve_job_records == :on_unhandled_error))
-        if GoodJob.preserve_job_records == true || reenqueued || preserve_unhandled || cron_key.present?
-          if discrete_execution
-            transaction do
-              discrete_execution.save!
-              update!(job_attributes)
-            end
-          else
-            update!(job_attributes)
+        if finished_at.blank? || GoodJob.preserve_job_records == true || reenqueued || preserve_unhandled || cron_key.present?
+          transaction do
+            discrete_execution.save!
+            save!
           end
         else
-          destroy_job
+          destroy!
         end
 
         result
@@ -709,7 +611,7 @@ module GoodJob
     end
 
     def continue_discard_or_finish_batch
-      batch._continue_discard_or_finish(self) if GoodJob::BatchRecord.migrated? && batch.present?
+      batch._continue_discard_or_finish(self) if batch.present?
     end
 
     def active_job_data
@@ -717,7 +619,7 @@ module GoodJob
                        .tap do |job_data|
         job_data["provider_job_id"] = id
         job_data["good_job_concurrency_key"] = concurrency_key if concurrency_key
-        job_data["good_job_labels"] = Array(labels) if self.class.labels_migrated? && labels.present?
+        job_data["good_job_labels"] = Array(labels) if labels.present?
       end
     end
   end

data/app/models/good_job/cron_entry.rb

@@ -72,8 +72,6 @@ module GoodJob # :nodoc:
     end
 
     def enabled?
-      return true unless GoodJob::Setting.migrated?
-
       GoodJob::Setting.cron_key_enabled?(key, default: enabled_by_default?)
     end