good_job 3.15.13 → 3.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce708c401123eb5129c55505dbc02c6e7bca76f6e3d0886a43a359fb1861d99f
-  data.tar.gz: 477481c84a743ba4f3a07e7940c8a0cd21c0ec99b4f86277bf86db5e1529a2ad
+  metadata.gz: 20bb64485159969378a5abf5d960de13a3f27df63846f85cda6e4ef410c9af23
+  data.tar.gz: de0d39b68577c973ca4a4c9d9bccd8bda29bad7e6ca5a936112db7c8df6b038b
 SHA512:
-  metadata.gz: 50152f710bbb121123e76a5ced97b06c0b0427cc6eefe6229d9fc6756cb586cba1f1d5624ddea198879a461909e34e631e8f5147940fcef8daf4615fd5c32311
-  data.tar.gz: a7981cac24a946d8edfc7a892a35383376325071bf89da5321f2c05138907d90ac0ca4e3220277ecc3d32a709abb9b63262c7d97581a3514e64488a645994ff2
+  metadata.gz: 9fa9474d0ee2ff9e8e47aa5e3cc31d6cd1924c7d00276a9da2bc4611b970ea80d68a0bc79c9da7f4266c85e0bedfc491860dabff4d4e1088d485a11a21a895f5
+  data.tar.gz: eb6a2ea5cdacd25fd930aab7eba6b498ffb5998fa82c78e552f7acaebf59f6f6cd950fb6488e4c317b461ff8931df5250820cdeb46d40a4047a1e8c24495756b

data/CHANGELOG.md

@@ -1,5 +1,61 @@
 # Changelog
 
+## [v3.16.0](https://github.com/bensheldon/good_job/tree/v3.16.0) (2023-07-10)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v3.15.14...v3.16.0)
+
+**Implemented enhancements:**
+
+- Add `GoodJob.configure_active_record` as alternative to `GoodJob.active_record_parent_class` [\#1004](https://github.com/bensheldon/good_job/pull/1004) ([bensheldon](https://github.com/bensheldon))
+- Configure `dashboard_default_locale` using custom subclass of `I18n::Config` to isolate I18n configuration from parent application [\#1001](https://github.com/bensheldon/good_job/pull/1001) ([bensheldon](https://github.com/bensheldon))
+- Create `error_event` column to track the context of an error \(discarded, retried, retry\_stopped, etc\) [\#995](https://github.com/bensheldon/good_job/pull/995) ([bensheldon](https://github.com/bensheldon))
+- Added metrics to Scheduler and track in Process state [\#984](https://github.com/bensheldon/good_job/pull/984) ([AndersGM](https://github.com/AndersGM))
+
+**Fixed bugs:**
+
+- Use Concurrent::Array for class `instances` to avoid JRuby synchronization errors [\#1002](https://github.com/bensheldon/good_job/pull/1002) ([bensheldon](https://github.com/bensheldon))
+- Add test to assert enqueuing behavior within transactions [\#998](https://github.com/bensheldon/good_job/pull/998) ([bensheldon](https://github.com/bensheldon))
+- Fix Ukrainian language code [\#996](https://github.com/bensheldon/good_job/pull/996) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- Is `pgcrypto` necessary? [\#805](https://github.com/bensheldon/good_job/issues/805)
+- Integrate Sorbet type checking [\#404](https://github.com/bensheldon/good_job/issues/404)
+
+**Merged pull requests:**
+
+- Unify `frozen_string_literal` comment style [\#1003](https://github.com/bensheldon/good_job/pull/1003) ([dixpac](https://github.com/dixpac))
+- Add more execution mode details and caveats to Readme Set Up section [\#997](https://github.com/bensheldon/good_job/pull/997) ([bensheldon](https://github.com/bensheldon))
+- Add note in migrations that `pgcrypto` extension isn't necessary in PG 13+ [\#837](https://github.com/bensheldon/good_job/pull/837) ([bensheldon](https://github.com/bensheldon))
+- Add Sorbet to linter [\#760](https://github.com/bensheldon/good_job/pull/760) ([sam1el](https://github.com/sam1el))
+
+## [v3.15.14](https://github.com/bensheldon/good_job/tree/v3.15.14) (2023-07-03)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v3.15.13...v3.15.14)
+
+**Implemented enhancements:**
+
+- Add Process heartbeat that is updated inside of Notifier [\#977](https://github.com/bensheldon/good_job/pull/977) ([bensheldon](https://github.com/bensheldon))
+
+**Fixed bugs:**
+
+- Dashboard error when trying to display 0 running/queued/retried jobs due to missing 'zero' translation [\#990](https://github.com/bensheldon/good_job/issues/990)
+- Add explicit namespace back to `GoodJob::DiscreteExecution` [\#983](https://github.com/bensheldon/good_job/pull/983) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- Persisting ActiveSupport::CurrentAttributes  [\#981](https://github.com/bensheldon/good_job/issues/981)
+- uninitialized constant DiscreteExecution [\#962](https://github.com/bensheldon/good_job/issues/962)
+- Hard kill resilience with execution counts [\#922](https://github.com/bensheldon/good_job/issues/922)
+
+**Merged pull requests:**
+
+- Bump rubocop from 1.53.0 to 1.54.0 [\#994](https://github.com/bensheldon/good_job/pull/994) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Bump rails from 7.0.5 to 7.0.6 [\#993](https://github.com/bensheldon/good_job/pull/993) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Fix CI: Lock traces version for Ruby 2.6 compatible version [\#987](https://github.com/bensheldon/good_job/pull/987) ([bensheldon](https://github.com/bensheldon))
+- Turkish Language support [\#986](https://github.com/bensheldon/good_job/pull/986) ([SemihCag](https://github.com/SemihCag))
+- Use generic error reporter in Readme examples [\#964](https://github.com/bensheldon/good_job/pull/964) ([shouichi](https://github.com/shouichi))
+
 ## [v3.15.13](https://github.com/bensheldon/good_job/tree/v3.15.13) (2023-06-14)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v3.15.12...v3.15.13)
@@ -43,10 +99,6 @@
 
 - Ensure migration warning for `DiscreteExecution` constant is in explicit `GoodJob::` namespace [\#963](https://github.com/bensheldon/good_job/pull/963) ([bensheldon](https://github.com/bensheldon))
 
-**Closed issues:**
-
-- uninitialized constant DiscreteExecution [\#962](https://github.com/bensheldon/good_job/issues/962)
-
 ## [v3.15.9](https://github.com/bensheldon/good_job/tree/v3.15.9) (2023-05-21)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v3.15.8...v3.15.9)

data/README.md

@@ -121,8 +121,13 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
     YourJob.set(queue: :some_queue, wait: 5.minutes, priority: 10).perform_later
     ```
 
-1. In development, GoodJob executes jobs immediately in a separate thread ("async" mode). In production, GoodJob provides different options:
-
+1. **In Rails' development environment**, by default, GoodJob's Adapter executes jobs `async` in a background thread pool in `rails server`.
+    - Because of Rails deferred autoloading, jobs enqueued via the `rails console` may not begin executing on a separate server process until the Rails application is fully initialized by loading a web page once.
+    - Remember, only Active Job's `perform_later` sends jobs to the queue adapter; Active Job's `perform_now` executes the job immediately and does not invoke the queue adapter. GoodJob is not involved in `perform_now` jobs.
+1. **In Rails' test environment**, by default, GoodJob's Adapter executes jobs `inline` immediately in the current thread.
+    - Future-scheduled jobs can be executed with `GoodJob.perform_inline` using using a tool like Timecop or `ActiveSupport::Testing::TimeHelpers`.
+    - Note that Active Job's TestAdapter, which powers test helpers (e.g. `assert_enqueued_with`), may override GoodJob's Adapter in [some configurations](https://github.com/rails/rails/issues/37270).
+1. **In Rails' production environment**, by default, GoodJob's Adapter enqueues jobs in `external` mode to be executed by a separate execution process:
     - By default, GoodJob separates job enqueuing from job execution so that jobs can be scaled independently of the web server.  Use the GoodJob command-line tool to execute jobs:
 
         ```bash
@@ -231,7 +236,7 @@ Rails.application.configure do
   # Configure options individually...
   config.good_job.preserve_job_records = true
   config.good_job.retry_on_unhandled_error = false
-  config.good_job.on_thread_error = -> (exception) { Sentry.capture_exception(exception) }
+  config.good_job.on_thread_error = -> (exception) { Rails.error.report(exception) }
   config.good_job.execution_mode = :async
   config.good_job.queues = '*'
   config.good_job.max_threads = 5
@@ -239,12 +244,13 @@ Rails.application.configure do
   config.good_job.shutdown_timeout = 25 # seconds
   config.good_job.enable_cron = true
   config.good_job.cron = { example: { cron: '0 * * * *', class: 'ExampleJob'  } }
+  config.good_job.dashboard_default_locale = :en
 
   # ...or all at once.
   config.good_job = {
     preserve_job_records: true,
     retry_on_unhandled_error: false,
-    on_thread_error: -> (exception) { Sentry.capture_exception(exception) },
+    on_thread_error: -> (exception) { Rails.error.report(exception) },
     execution_mode: :async,
     queues: '*',
     max_threads: 5,
@@ -257,6 +263,7 @@ Rails.application.configure do
         class: 'ExampleJob'
       },
     },
+    dashboard_default_locale: :en,
   }
 end
 ```
@@ -287,7 +294,7 @@ Available configuration options are:
 - `on_thread_error` (proc, lambda, or callable) will be called when there is an Exception. It can be useful for logging errors to bug tracking services, like Sentry or Airbrake. Example:
 
     ```ruby
-    config.good_job.on_thread_error = -> (exception) { Sentry.capture_exception(exception) }
+    config.good_job.on_thread_error = -> (exception) { Rails.error.report(exception) }
     ```
 
 By default, GoodJob configures the following execution modes per environment:
@@ -311,7 +318,17 @@ config.good_job.execution_mode = :external
 
 Good Job’s general behavior can also be configured via attributes directly on the `GoodJob` module:
 
-- **`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.configure_active_record { ... }`** Inject Active Record configuration into GoodJob's base model, for example, 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. Example:
+
+    ```ruby
+    # config/initializers/good_job.rb
+    GoodJob.configure_active_record do
+      connects_to database: :special_database
+      self.table_name_prefix = "special_application_"
+    end
+    ```
+
+- **`GoodJob.active_record_parent_class`** (string) Alternatively, modify the ActiveRecord parent class inherited by GoodJob's Active Record model `GoodJob::Job` (defaults to `"ActiveRecord::Base"`). Configure this _The value must be a String to avoid premature initialization of ActiveRecord._
 
 You’ll generally want to configure these in `config/initializers/good_job.rb`, like so:
 
@@ -760,7 +777,7 @@ If errors do reach GoodJob, you can assign a callable to `GoodJob.on_thread_erro
 
 ```ruby
 # config/initializers/good_job.rb
-GoodJob.on_thread_error = -> (exception) { Sentry.capture_exception(exception) }
+GoodJob.on_thread_error = -> (exception) { Rails.error.report(exception) }
 ```
 
 #### Retries
@@ -794,13 +811,13 @@ class ApplicationJob < ActiveJob::Base
   retry_on StandardError, wait: :exponentially_longer, attempts: Float::INFINITY
 
   retry_on SpecialError, attempts: 5 do |_job, exception|
-    Sentry.capture_exception(exception)
+    Rails.error.report(exception)
   end
 
   around_perform do |_job, block|
     block.call
   rescue StandardError => e
-    Sentry.capture_exception(e)
+    Rails.error.report(e)
     raise
   end
   # ...
@@ -823,7 +840,7 @@ ActionMailer::MailDeliveryJob.retry_on StandardError, wait: :exponentially_longe
 ActionMailer::MailDeliveryJob.around_perform do |_job, block|
   block.call
 rescue StandardError => e
-  Sentry.capture_exception(e)
+  Rails.error.report(e)
   raise
 end
 ```

data/app/controllers/good_job/application_controller.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+
 module GoodJob
   class ApplicationController < ActionController::Base
     protect_from_forgery with: :exception
 
-    around_action :switch_locale
+    around_action :use_good_job_locale
 
     content_security_policy do |policy|
       policy.default_src(:none) if policy.default_src(*policy.default_src).blank?
@@ -30,8 +31,21 @@ module GoodJob
       { locale: I18n.locale }.merge(options)
     end
 
-    def switch_locale(&action)
+    def use_good_job_locale(&action)
+      @original_i18n_config = I18n.config
+      I18n.config = ::GoodJob::I18nConfig.new
       I18n.with_locale(current_locale, &action)
+    ensure
+      I18n.config = @original_i18n_config
+      @original_i18n_config = nil
+    end
+
+    def use_original_locale
+      prev_config = I18n.config
+      I18n.config = @original_i18n_config if @original_i18n_config
+      yield
+    ensure
+      I18n.config = prev_config
     end
 
     def current_locale
@@ -39,16 +53,9 @@ module GoodJob
         request.GET['locale']
       elsif params[:locale]
         params[:locale]
-      elsif good_job_available_locales.exclude?(I18n.default_locale) && I18n.available_locales.include?(:en)
-        :en
       else
         I18n.default_locale
       end
     end
-
-    def good_job_available_locales
-      @_good_job_available_locales ||= GoodJob::Engine.root.join("config/locales").glob("*.yml").map { |path| File.basename(path, ".yml").to_sym }.uniq
-    end
-    helper_method :good_job_available_locales
   end
 end

data/app/controllers/good_job/batches_controller.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module GoodJob
   class BatchesController < GoodJob::ApplicationController
     def index

data/app/controllers/good_job/cron_entries_controller.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module GoodJob
   class CronEntriesController < GoodJob::ApplicationController
     before_action :check_settings_migration!, only: [:enable, :disable]
@@ -14,7 +15,7 @@ module GoodJob
 
     def enqueue
       @cron_entry = CronEntry.find(params[:cron_key])
-      @cron_entry.enqueue(Time.current)
+      use_original_locale { @cron_entry.enqueue(Time.current) }
       redirect_back(fallback_location: cron_entries_path, notice: t(".notice"))
     end
 

data/app/controllers/good_job/frontends_controller.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module GoodJob
   class FrontendsController < ActionController::Base # rubocop:disable Rails/ApplicationController
     skip_after_action :verify_same_origin_request, raise: false

data/app/controllers/good_job/jobs_controller.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module GoodJob
   class JobsController < GoodJob::ApplicationController
     DISCARD_MESSAGE = "Discarded through dashboard"

data/app/controllers/good_job/processes_controller.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module GoodJob
   class ProcessesController < GoodJob::ApplicationController
     def index

data/app/filters/good_job/base_filter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module GoodJob
   class BaseFilter
     DEFAULT_LIMIT = 25

data/app/filters/good_job/batches_filter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module GoodJob
   class BatchesFilter < BaseFilter
     def records

data/app/filters/good_job/jobs_filter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module GoodJob
   class JobsFilter < BaseFilter
     def states

data/app/helpers/good_job/application_helper.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module GoodJob
   module ApplicationHelper
     def format_duration(sec)
@@ -63,7 +64,6 @@ module GoodJob
     end
 
     def translation_exists?(key, **options)
-      true if good_job_available_locales.include?(I18n.locale)
       I18n.exists?(scope_key_by_partial(key), **options)
     end
   end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module GoodJob
+  # Shared methods for filtering Execution/Job records from the +good_jobs+ table.
+  module ErrorEvents
+    extend ActiveSupport::Concern
+
+    ERROR_EVENTS = [
+      ERROR_EVENT_INTERRUPTED = 'interrupted',
+      ERROR_EVENT_UNHANDLED = 'unhandled',
+      ERROR_EVENT_HANDLED = 'handled',
+      ERROR_EVENT_RETRIED = 'retried',
+      ERROR_EVENT_RETRY_STOPPED = 'retry_stopped',
+      ERROR_EVENT_DISCARDED = 'discarded',
+    ].freeze
+
+    included do
+      enum error_event: {
+        ERROR_EVENT_INTERRUPTED => 0,
+        ERROR_EVENT_UNHANDLED => 1,
+        ERROR_EVENT_HANDLED => 2,
+        ERROR_EVENT_RETRIED => 3,
+        ERROR_EVENT_RETRY_STOPPED => 4,
+        ERROR_EVENT_DISCARDED => 5,
+      }.freeze, _prefix: :error_event
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module GoodJob
   # Shared methods for filtering Execution/Job records from the +good_jobs+ table.
   module Filterable

data/app/models/{good_job → concerns/good_job}/lockable.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module GoodJob
   #
   # Adds Postgres advisory locking capabilities to an ActiveRecord record.

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module GoodJob
   module Reportable
     # There are 3 buckets of non-overlapping statuses:

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,8 @@ 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
+
     self.table_name = 'good_jobs'
 
     # With a given class name
@@ -35,7 +37,14 @@ module GoodJob
       end
 
       def discrete_support?
-        DiscreteExecution.migrated?
+        GoodJob::DiscreteExecution.migrated?
+      end
+
+      def error_event_migrated?
+        return true if columns_hash["error_event"].present?
+
+        migration_pending_warning!
+        false
       end
     end
 

data/app/models/good_job/base_record.rb

@@ -1,10 +1,11 @@
 # 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!
@@ -26,5 +27,7 @@ module GoodJob
       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

@@ -2,6 +2,8 @@
 
 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
@@ -11,6 +13,13 @@ 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 number
       serialized_params.fetch('executions', 0) + 1
     end

data/app/models/good_job/execution.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module GoodJob
   # ActiveRecord model that represents an +ActiveJob+ job.
   class Execution < BaseExecution
@@ -262,7 +263,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
@@ -373,10 +378,14 @@ module GoodJob
             if discrete?
               interrupt_error_string = self.class.format_error(GoodJob::InterruptError.new("Interrupted after starting perform at '#{performed_at}'"))
               self.error = interrupt_error_string
-              discrete_executions.where(finished_at: nil).where.not(performed_at: nil).update_all( # rubocop:disable Rails/SkipsModelValidations
+              self.error_event = ERROR_EVENT_INTERRUPTED if self.class.error_event_migrated?
+
+              discrete_execution_attrs = {
                 error: interrupt_error_string,
-                finished_at: Time.current
-              )
+                finished_at: Time.current,
+              }
+              discrete_execution_attrs[:error_event] = GoodJob::DiscreteExecution.error_events[GoodJob::DiscreteExecution::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
 
@@ -405,15 +414,34 @@ 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.execution_retried
+              retried: current_thread.execution_retried,
+              error_event: error_event
             )
-            ExecutionResult.new(value: value, handled_error: handled_error, retried: current_thread.execution_retried)
+            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
 
@@ -422,9 +450,14 @@ module GoodJob
         if job_error
           error_string = self.class.format_error(job_error)
           self.error = error_string
-          discrete_execution.error = error_string if discrete_execution
+          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?

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".
@@ -198,6 +199,7 @@ module GoodJob
 
           execution.class.transaction(joinable: false, requires_new: true) do
             new_active_job = active_job.retry_job(wait: 0, error: execution.error)
+            execution.error_event = ERROR_EVENT_RETRIED if execution.error && execution.class.error_event_migrated?
             execution.save!
           end
         end
@@ -221,7 +223,8 @@ module GoodJob
         update_execution = proc do
           execution.update(
             finished_at: Time.current,
-            error: GoodJob::Execution.format_error(job_error)
+            error: GoodJob::Execution.format_error(job_error),
+            error_event: :discarded
           )
         end