good_job 3.15.0 → 3.16.3

data/app/models/good_job/active_record_parent_class.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module GoodJob
+  ActiveRecordParentClass = if GoodJob.active_record_parent_class
+                              Object.const_get(GoodJob.active_record_parent_class)
+                            else
+                              ActiveRecord::Base
+                            end
+end

data/app/models/good_job/base_execution.rb

@@ -4,6 +4,11 @@ module GoodJob
   # ActiveRecord model to share behavior between {Job} and {Execution} models
   # which both read out of the same table.
   class BaseExecution < BaseRecord
+    include ErrorEvents
+    include Filterable
+    include Lockable
+    include Reportable
+
     self.table_name = 'good_jobs'
 
     # With a given class name
@@ -33,12 +38,27 @@ module GoodJob
       def coalesce_scheduled_at_created_at
         arel_table.coalesce(arel_table['scheduled_at'], arel_table['created_at'])
       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
     end
 
     # The ActiveJob job class, as a string
     # @return [String]
     def job_class
-      serialized_params['job_class']
+      discrete? ? attributes['job_class'] : serialized_params['job_class']
+    end
+
+    def discrete?
+      self.class.discrete_support? && is_discrete?
     end
   end
 end

data/app/models/good_job/base_record.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
+
 module GoodJob
   # Base ActiveRecord class that all GoodJob models inherit from.
   # Parent class can be configured with +GoodJob.active_record_parent_class+.
   # @!parse
   #   class BaseRecord < ActiveRecord::Base; end
-  class BaseRecord < Object.const_get(GoodJob.active_record_parent_class)
+  class BaseRecord < ActiveRecordParentClass
     self.abstract_class = true
 
     def self.migration_pending_warning!
-      ActiveSupport::Deprecation.warn(<<~DEPRECATION)
+      GoodJob.deprecator.warn(<<~DEPRECATION)
         GoodJob has pending database migrations. To create the migration files, run:
             rails generate good_job:update
         To apply the migration files, run:
@@ -21,10 +22,12 @@ module GoodJob
     # Can be overriden by child class.
     # @return [Boolean]
     def self.migrated?
-      return true if connection.table_exists?(table_name)
+      return true if table_exists?
 
       migration_pending_warning!
       false
     end
+
+    ActiveSupport.run_load_hooks(:good_job_base_record, self)
   end
 end

data/app/models/good_job/cron_entry.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "concurrent/hash"
 require "concurrent/scheduled_task"
 require "fugit"

data/app/models/good_job/discrete_execution.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module GoodJob # :nodoc:
+  class DiscreteExecution < BaseRecord
+    include ErrorEvents
+
+    self.table_name = 'good_job_executions'
+
+    belongs_to :execution, class_name: 'GoodJob::Execution', foreign_key: 'active_job_id', primary_key: 'active_job_id', inverse_of: :discrete_executions, optional: true
+    belongs_to :job, class_name: 'GoodJob::Job', foreign_key: 'active_job_id', primary_key: 'active_job_id', inverse_of: :discrete_executions, optional: true
+
+    scope :finished, -> { where.not(finished_at: nil) }
+
+    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 number
+      serialized_params.fetch('executions', 0) + 1
+    end
+
+    # Time between when this job was expected to run and when it started running
+    def queue_latency
+      created_at - scheduled_at
+    end
+
+    # Time between when this job started and finished
+    def runtime_latency
+      (finished_at || Time.current) - performed_at if performed_at
+    end
+
+    def last_status_at
+      finished_at || created_at
+    end
+
+    def status
+      if finished_at.present?
+        if error.present?
+          :retried
+        elsif error.present? && job.finished_at.present?
+          :discarded
+        else
+          :succeeded
+        end
+      else
+        :running
+      end
+    end
+
+    def display_serialized_params
+      serialized_params.merge({
+                                _good_job_execution: attributes.except('serialized_params'),
+                              })
+    end
+  end
+end

data/app/models/good_job/execution.rb

@@ -1,11 +1,8 @@
 # frozen_string_literal: true
+
 module GoodJob
   # ActiveRecord model that represents an +ActiveJob+ job.
   class Execution < BaseExecution
-    include Lockable
-    include Filterable
-    include Reportable
-
     # Raised if something attempts to execute a previously completed Execution again.
     PreviouslyPerformedError = Class.new(StandardError)
 
@@ -70,9 +67,13 @@ module GoodJob
     end
 
     belongs_to :batch, class_name: 'GoodJob::BatchRecord', 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
-    after_destroy -> { self.class.active_job_id(active_job_id).delete_all }, if: -> { @_destroy_job }
+    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
+
+    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 executions with given ActiveJob ID
     # @!method active_job_id
@@ -201,10 +202,14 @@ module GoodJob
       end
     end)
 
-    # Construct a GoodJob::Execution from an ActiveJob instance.
     def self.build_for_enqueue(active_job, overrides = {})
+      new(**enqueue_args(active_job, overrides))
+    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?
-        ActiveSupport::Deprecation.warn(<<~DEPRECATION)
+        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`.
@@ -216,8 +221,8 @@ module GoodJob
         queue_name: active_job.queue_name.presence || DEFAULT_QUEUE_NAME,
         priority: active_job.priority || DEFAULT_PRIORITY,
         serialized_params: active_job.serialize,
-        scheduled_at: active_job.scheduled_at,
       }
+      execution_args[:scheduled_at] = Time.zone.at(active_job.scheduled_at) if active_job.scheduled_at
       execution_args[:concurrency_key] = active_job.good_job_concurrency_key if active_job.respond_to?(:good_job_concurrency_key)
 
       reenqueued_current_execution = CurrentThread.active_job_id && CurrentThread.active_job_id == active_job.job_id
@@ -238,7 +243,7 @@ module GoodJob
         execution_args[:cron_at] = CurrentThread.cron_at
       end
 
-      new(**execution_args.merge(overrides))
+      execution_args.merge(overrides)
     end
 
     # Finds the next eligible Execution, acquire an advisory lock related to it, and
@@ -254,7 +259,11 @@ module GoodJob
       unfinished.dequeueing_ordered(parsed_queues).only_scheduled.limit(1).with_advisory_lock(unlock_session: true, select_limit: queue_select_limit) do |executions|
         execution = executions.first
         break if execution.blank?
-        break :unlocked unless execution&.executable?
+
+        unless execution.executable?
+          result = ExecutionResult.new(value: nil, unexecutable: true)
+          break
+        end
 
         yield(execution) if block_given?
         result = execution.perform
@@ -298,19 +307,53 @@ 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|
-        execution = build_for_enqueue(active_job, { scheduled_at: scheduled_at })
+        current_execution = CurrentThread.execution
+
+        retried = current_execution && current_execution.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
+        else
+          execution = build_for_enqueue(active_job, { scheduled_at: scheduled_at })
+          execution.make_discrete if discrete_support?
+        end
 
-        execution.create_with_advisory_lock = create_with_advisory_lock
-        instrument_payload[:execution] = execution
+        if create_with_advisory_lock
+          if execution.persisted?
+            execution.advisory_lock
+          else
+            execution.create_with_advisory_lock = true
+          end
+        end
 
+        instrument_payload[:execution] = execution
         execution.save!
-        active_job.provider_job_id = execution.id
-        CurrentThread.execution.retried_good_job_id = execution.id if CurrentThread.active_job_id && CurrentThread.active_job_id == active_job.job_id
 
+        if retried
+          CurrentThread.execution_retried = true
+          CurrentThread.execution.retried_good_job_id = execution.id unless current_execution.discrete?
+        end
+
+        active_job.provider_job_id = execution.id
         execution
       end
     end
 
+    def self.format_error(error)
+      raise ArgumentError unless error.is_a?(Exception)
+
+      [error.class.to_s, ERROR_MESSAGE_SEPARATOR, error.message].join
+    end
+
     # Execute the ActiveJob job this {Execution} represents.
     # @return [ExecutionResult]
     #   An array of the return value of the job's +#perform+ method and the
@@ -320,12 +363,43 @@ module GoodJob
       run_callbacks(:perform) do
         raise PreviouslyPerformedError, 'Cannot perform a job that has already been performed' if finished_at
 
+        discrete_execution = nil
         result = GoodJob::CurrentThread.within do |current_thread|
           current_thread.reset
           current_thread.execution = self
 
-          current_thread.execution_interrupted = performed_at if performed_at
-          update!(performed_at: Time.current)
+          if performed_at
+            current_thread.execution_interrupted = performed_at
+
+            if discrete?
+              interrupt_error_string = self.class.format_error(GoodJob::InterruptError.new("Interrupted after starting perform at '#{performed_at}'"))
+              self.error = interrupt_error_string
+              self.error_event = ERROR_EVENT_INTERRUPTED if self.class.error_event_migrated?
+
+              discrete_execution_attrs = {
+                error: interrupt_error_string,
+                finished_at: Time.current,
+              }
+              discrete_execution_attrs[:error_event] = GoodJob::ErrorEvents::ERROR_EVENT_ENUMS[GoodJob::ErrorEvents::ERROR_EVENT_INTERRUPTED] if self.class.error_event_migrated?
+              discrete_executions.where(finished_at: nil).where.not(performed_at: nil).update_all(discrete_execution_attrs) # rubocop:disable Rails/SkipsModelValidations
+            end
+          end
+
+          if discrete?
+            transaction do
+              now = Time.current
+              discrete_execution = discrete_executions.create!(
+                job_class: job_class,
+                queue_name: queue_name,
+                serialized_params: serialized_params,
+                scheduled_at: (scheduled_at || created_at),
+                created_at: now
+              )
+              update!(performed_at: now, executions_count: ((executions_count || 0) + 1))
+            end
+          else
+            update!(performed_at: Time.current)
+          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|
             value = ActiveJob::Base.execute(active_job_data)
@@ -336,27 +410,79 @@ module GoodJob
             end
             handled_error ||= current_thread.error_on_retry || current_thread.error_on_discard
 
+            error_event = if handled_error == current_thread.error_on_discard
+                            ERROR_EVENT_DISCARDED
+                          elsif handled_error == current_thread.error_on_retry
+                            ERROR_EVENT_RETRIED
+                          elsif handled_error == current_thread.error_on_retry_stopped
+                            ERROR_EVENT_RETRY_STOPPED
+                          elsif handled_error
+                            ERROR_EVENT_HANDLED
+                          end
+
             instrument_payload.merge!(
               value: value,
               handled_error: handled_error,
-              retried: current_thread.error_on_retry.present?
+              retried: current_thread.execution_retried,
+              error_event: error_event
             )
-            ExecutionResult.new(value: value, handled_error: handled_error, retried: current_thread.error_on_retry.present?)
+            ExecutionResult.new(value: value, handled_error: handled_error, error_event: error_event, retried: current_thread.execution_retried)
           rescue StandardError => e
+            error_event = if e.is_a?(GoodJob::InterruptError)
+                            ERROR_EVENT_INTERRUPTED
+                          elsif e == current_thread.error_on_retry_stopped
+                            ERROR_EVENT_RETRY_STOPPED
+                          else
+                            ERROR_EVENT_UNHANDLED
+                          end
+
             instrument_payload[:unhandled_error] = e
-            ExecutionResult.new(value: nil, unhandled_error: e)
+            ExecutionResult.new(value: nil, unhandled_error: e, error_event: error_event)
           end
         end
 
         job_error = result.handled_error || result.unhandled_error
-        self.error = [job_error.class, ERROR_MESSAGE_SEPARATOR, job_error.message].join if job_error
+
+        if job_error
+          error_string = self.class.format_error(job_error)
+          self.error = error_string
+          self.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 if discrete_execution.class.error_event_migrated?
+          end
+        else
+          self.error = nil
+          self.error_event = nil if self.class.error_event_migrated?
+        end
 
         reenqueued = result.retried? || retried_good_job_id.present?
         if result.unhandled_error && GoodJob.retry_on_unhandled_error
-          save!
+          if discrete_execution
+            transaction do
+              discrete_execution.update!(finished_at: Time.current)
+              update!(performed_at: nil, finished_at: nil, retried_good_job_id: nil)
+            end
+          else
+            save!
+          end
         elsif GoodJob.preserve_job_records == true || reenqueued || (result.unhandled_error && GoodJob.preserve_job_records == :on_unhandled_error) || cron_key.present?
-          self.finished_at = Time.current
-          save!
+          now = Time.current
+          if discrete_execution
+            if reenqueued
+              self.performed_at = nil
+            else
+              self.finished_at = now
+            end
+            discrete_execution.finished_at = now
+            transaction do
+              discrete_execution.save!
+              save!
+            end
+          else
+            self.finished_at = now
+            save!
+          end
         else
           destroy_job
         end
@@ -371,6 +497,17 @@ module GoodJob
       self.class.unscoped.unfinished.owns_advisory_locked.exists?(id: id)
     end
 
+    def make_discrete
+      self.is_discrete = true
+      self.id = active_job_id
+      self.job_class = serialized_params['job_class']
+      self.executions_count ||= 0
+
+      current_time = Time.current
+      self.created_at ||= current_time
+      self.scheduled_at ||= current_time
+    end
+
     # Build an ActiveJob instance and deserialize the arguments, using `#active_job_data`.
     #
     # @param ignore_deserialization_errors [Boolean]

data/app/models/good_job/execution_result.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module GoodJob
   # Stores the results of job execution
   class ExecutionResult
@@ -8,18 +9,32 @@ module GoodJob
     attr_reader :handled_error
     # @return [Exception, nil]
     attr_reader :unhandled_error
-    # @return [Exception, nil]
+    # @return [String, nil]
+    attr_reader :error_event
+    # @return [Boolean, nil]
+    attr_reader :unexecutable
+    # @return [Boolean, nil]
     attr_reader :retried
     alias retried? retried
 
     # @param value [Object, nil]
     # @param handled_error [Exception, nil]
     # @param unhandled_error [Exception, nil]
-    def initialize(value:, handled_error: nil, unhandled_error: nil, retried: false)
+    # @param error_event [String, nil]
+    # @param unexecutable [Boolean, nil]
+    # @param retried [Boolean, nil]
+    def initialize(value:, handled_error: nil, unhandled_error: nil, error_event: nil, unexecutable: nil, retried: false)
       @value = value
       @handled_error = handled_error
       @unhandled_error = unhandled_error
+      @error_event = error_event
+      @unexecutable = unexecutable
       @retried = retried
     end
+
+    # @return [Boolean]
+    def succeeded?
+      !(handled_error || unhandled_error || unexecutable || retried)
+    end
   end
 end

data/app/models/good_job/i18n_config.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module GoodJob
+  class I18nConfig < ::I18n::Config
+    BACKEND = I18n::Backend::Simple.new
+    AVAILABLE_LOCALES = GoodJob::Engine.root.join("config/locales").glob("*.yml").map { |path| File.basename(path, ".yml").to_sym }.uniq
+    AVAILABLE_LOCALES_SET = AVAILABLE_LOCALES.inject(Set.new) { |set, locale| set << locale.to_s << locale.to_sym }
+
+    def backend
+      BACKEND
+    end
+
+    def available_locales
+      AVAILABLE_LOCALES
+    end
+
+    def available_locales_set
+      AVAILABLE_LOCALES_SET
+    end
+
+    def default_locale
+      GoodJob.configuration.dashboard_default_locale
+    end
+  end
+end

data/app/models/good_job/job.rb

@@ -1,4 +1,5 @@
 # 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".
@@ -6,10 +7,6 @@ module GoodJob
   # A single row from the +good_jobs+ table of executions is fetched to represent a Job.
   #
   class Job < BaseExecution
-    include Filterable
-    include Lockable
-    include Reportable
-
     # 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.
@@ -30,6 +27,11 @@ module GoodJob
 
     belongs_to :batch, class_name: 'GoodJob::BatchRecord', inverse_of: :jobs, optional: true
     has_many :executions, -> { order(created_at: :asc) }, class_name: 'GoodJob::Execution', foreign_key: 'active_job_id', inverse_of: :job # rubocop:disable Rails/HasManyOrHasOneDependent
+    has_many :discrete_executions, -> { order(created_at: :asc) }, class_name: 'GoodJob::DiscreteExecution', foreign_key: 'active_job_id', primary_key: :active_job_id, inverse_of: :job # rubocop:disable Rails/HasManyOrHasOneDependent
+
+    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
+    }
 
     # Only the most-recent unretried execution represents a "Job"
     default_scope { where(retried_good_job_id: nil) }
@@ -56,6 +58,8 @@ module GoodJob
     # Errored but will not be retried
     scope :discarded, -> { finished.where.not(error: nil) }
 
+    scope :unfinished_undiscrete, -> { where(finished_at: nil, retried_good_job_id: nil, is_discrete: [nil, false]) }
+
     # The job's ActiveJob UUID
     # @return [String]
     def id
@@ -141,6 +145,12 @@ module GoodJob
                               })
     end
 
+    # Used when displaying this job in the GoodJob dashboard.
+    # @return [String]
+    def display_name
+      job_class
+    end
+
     # Tests whether the job is being executed right now.
     # @return [Boolean]
     def running?
@@ -191,9 +201,11 @@ module GoodJob
 
           execution.class.transaction(joinable: false, requires_new: true) do
             new_active_job = active_job.retry_job(wait: 0, error: execution.error)
-            execution.save
+            execution.error_event = ERROR_EVENT_RETRIED if execution.error && execution.class.error_event_migrated?
+            execution.save!
           end
         end
+
         new_active_job
       end
     end
@@ -212,8 +224,12 @@ module GoodJob
 
         update_execution = proc do
           execution.update(
-            finished_at: Time.current,
-            error: [job_error.class, GoodJob::Execution::ERROR_MESSAGE_SEPARATOR, job_error.message].join
+            {
+              finished_at: Time.current,
+              error: GoodJob::Execution.format_error(job_error),
+            }.tap do |attrs|
+              attrs[:error_event] = ERROR_EVENT_DISCARDED if self.class.error_event_migrated?
+            end
           )
         end