good_job 3.99.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad688cdbb78a81f0ec43164332e370dfa1cd1e63be003a8649ae4af3791da8fe
-  data.tar.gz: 3dcbc882063ea4085d4c58d4899a6e4dc4ae893220cc38f4648c4e00759bf27f
+  metadata.gz: 3a4006c920a731f763e36a964e7eb161a292e8a4b34bffa4b60b95b75145c28c
+  data.tar.gz: f54b107db6ac1e2304a4ee9e2d34fa65032dc2b1ab0425e0be5ea42d39e5590b
 SHA512:
-  metadata.gz: 52c1a70e3d0bc608318692cb7875c8736e36412186b3b53b19bd3ce4ea7535afdd63e16b98bdf89d726e80ffb5d17b18b9ff1d0452c44e4812df21cd77cab3b6
-  data.tar.gz: eeee619d6aff6be854122b54262eedf5ee732d7e56bec5ff516705643076e340326788e06fc6684d0e819ffd62dda1c9cc767327ad0b9e6e462feecd7467e862
+  metadata.gz: 4474aaa0540dc5ff1bba65e8807a6fa69a9901f2e68051c57cf954e30270e9e6d7eaf52a3ce8ec7de6f48b16fc60fa05e796f595f14dfda41a76cbeb5b042543
+  data.tar.gz: cf8103c84fceffe91e4f7b0f5083c3989d2312a17ce96b1db01d7726a99b651c7d850f83fe23075c5a01628a825ef71d335d0eb42e91a478a62dd7772ee95e54

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # 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)

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,54 +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.in?([nil, false])
-        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.
-        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
@@ -363,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
 
@@ -413,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
 
@@ -476,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)
@@ -584,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
@@ -708,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
@@ -716,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
 

data/app/models/good_job/discrete_execution.rb

@@ -14,31 +14,6 @@ module GoodJob # :nodoc:
 
     alias_attribute :performed_at, :created_at
 
-    def self.error_event_migrated?
-      return true if columns_hash["error_event"].present?
-
-      migration_pending_warning!
-      false
-    end
-
-    def self.backtrace_migrated?
-      return true if columns_hash["error_backtrace"].present?
-
-      migration_pending_warning!
-      false
-    end
-
-    def self.duration_interval_migrated?
-      return true if columns_hash["duration"].present?
-
-      migration_pending_warning!
-      false
-    end
-
-    def self.duration_interval_usable?
-      duration_interval_migrated? && Gem::Version.new(Rails.version) >= Gem::Version.new('6.1.0.a')
-    end
-
     def number
       serialized_params.fetch('executions', 0) + 1
     end
@@ -50,12 +25,7 @@ module GoodJob # :nodoc:
 
     # Monotonic time between when this job started and finished
     def runtime_latency
-      # migrated and Rails greater than 6.1
-      if self.class.duration_interval_usable?
-        duration
-      elsif performed_at
-        (finished_at || Time.current) - performed_at
-      end
+      duration
     end
 
     def last_status_at

data/app/models/good_job/execution.rb

@@ -1,12 +1,8 @@
 # frozen_string_literal: true
 
 module GoodJob
-  # Active Record model that represents an +ActiveJob+ job.
-  # Most behavior is currently in BaseExecution in anticipation of
-  # moving behavior into +GoodJob::Job+.
-  class Execution < BaseExecution
-    self.table_name = 'good_jobs'
-
-    belongs_to :job, class_name: 'GoodJob::Job', foreign_key: 'active_job_id', primary_key: 'active_job_id', optional: true, inverse_of: :executions
+  # Created at the time a Job begins executing.
+  # Behavior from +DiscreteExecution+ will be merged into this class.
+  class Execution < DiscreteExecution
   end
 end