Allow GoodJob.preserve_job_records to take a lambda that is callable after each job executes

Author: bensheldon

README.md

@@ -309,7 +309,7 @@ Available configuration options are:
 - `cleanup_interval_seconds` (integer) Number of seconds a Scheduler will wait before cleaning up preserved jobs. Defaults to `600` (10 minutes). Disable with `false`. Can also be set with  the environment variable `GOOD_JOB_CLEANUP_INTERVAL_SECONDS` and disabled with `0`).
 - `inline_execution_respects_schedule` (boolean) Opt-in to future behavior of inline execution respecting scheduled jobs. Defaults to `false`.
 - `logger` ([Rails Logger](https://api.rubyonrails.org/classes/ActiveSupport/Logger.html)) lets you set a custom logger for GoodJob. It should be an instance of a Rails `Logger` (Default: `Rails.logger`).
-- `preserve_job_records` (boolean) keeps job records in your database even after jobs are completed. (Default: `true`)
+- `preserve_job_records` (boolean, symbol, or lambda) keeps job records in your database even after jobs are completed. If set to `true`, all job records are preserved. If set to `:on_unhandled_error`, only jobs that finished with an unhandled error are preserved. If set to a lambda, the lambda will be called with the error_event (e.g., `:discarded`, `:retry_stopped`, or `:unhandled`) and should return a boolean indicating whether to preserve the job. (Default: `true`)
 - `advisory_lock_heartbeat` (boolean) whether to use an advisory lock for the purpose of determining whether an execeution process is active. (Default `true` in Development; `false` in other environments)
 - `retry_on_unhandled_error` (boolean) causes jobs to be re-queued and retried if they raise an instance of `StandardError`. Be advised this may lead to jobs being repeated infinitely ([see below for more on retries](#retries)). Instances of `Exception`, like SIGINT, will *always* be retried, regardless of this attribute’s value. (Default: `false`)
 - `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:
@@ -375,7 +375,7 @@ GoodJob.active_record_parent_class = "ApplicationRecord"
 The following options are also configurable via accessors, but you are encouraged to use the configuration attributes instead because these may be deprecated and removed in the future:
 
 - **`GoodJob.logger`** ([Rails Logger](https://api.rubyonrails.org/classes/ActiveSupport/Logger.html)) lets you set a custom logger for GoodJob. It should be an instance of a Rails `Logger`.
-- **`GoodJob.preserve_job_records`** (boolean) keeps job records in your database even after jobs are completed. (Default: `true`)
+- **`GoodJob.preserve_job_records`** (boolean, symbol, or lambda) keeps job records in your database even after jobs are completed. If set to `true`, all job records are preserved. If set to `:on_unhandled_error`, only jobs that finished with an unhandled error are preserved. If set to a lambda, the lambda will be called with the error_event (e.g., `:discarded`, `:retry_stopped`, or `:unhandled`) and should return a boolean indicating whether to preserve the job. (Default: `true`)
 - **`GoodJob.retry_on_unhandled_error`** (boolean) causes jobs to be re-queued and retried if they raise an instance of `StandardError`. Be advised this may lead to jobs being repeated infinitely ([see below for more on retries](#retries)). Instances of `Exception`, like SIGINT, will *always* be retried, regardless of this attribute’s value. (Default: `false`)
 - **`GoodJob.on_thread_error`** (proc, lambda, or callable) will be called when there is an Exception. It can be useful for logging errors to bug tracking services, like Sentry or Airbrake.
 
@@ -1366,7 +1366,11 @@ To instead delete job records immediately after they are finished:
 
 ```ruby
 # config/initializers/good_job.rb
-config.good_job.preserve_job_records = false # defaults to true; can also be `false` or `:on_unhandled_error`
+config.good_job.preserve_job_records = false # defaults to true; can also be `false`, `:on_unhandled_error`, or a lambda that takes error_event argument
+
+# Example of using a lambda to preserve only discarded jobs
+config.good_job.preserve_job_records = ->(error_event) { error_event == :discarded }
+
 ```
 
 GoodJob will automatically delete preserved job records after 14 days. The retention period, as well as the frequency GoodJob checks for deletable records can be configured:

app/models/concerns/good_job/error_events.rb

@@ -5,14 +5,21 @@ module GoodJob
   module ErrorEvents
     extend ActiveSupport::Concern
 
+    INTERRUPTED = :interrupted
+    UNHANDLED = :unhandled
+    HANDLED = :handled
+    RETRIED = :retried
+    RETRY_STOPPED = :retry_stopped
+    DISCARDED = :discarded
+
     included do
       error_event_enum = {
-        interrupted: 0,
-        unhandled: 1,
-        handled: 2,
-        retried: 3,
-        retry_stopped: 4,
-        discarded: 5,
+        INTERRUPTED => 0,
+        UNHANDLED => 1,
+        HANDLED => 2,
+        RETRIED => 3,
+        RETRY_STOPPED => 4,
+        DISCARDED => 5,
       }
       if Gem::Version.new(Rails.version) >= Gem::Version.new('7.1.0.a')
         enum :error_event, error_event_enum, validate: { allow_nil: true }, scopes: false

app/models/good_job/job.rb

@@ -612,13 +612,13 @@ def perform(lock_id:)
 
             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 = :interrupted
+            self.error_event = ErrorEvents::INTERRUPTED
             monotonic_duration = (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - monotonic_start).seconds
 
             execution_attrs = {
               error: interrupt_error_string,
               finished_at: job_performed_at,
-              error_event: :interrupted,
+              error_event: error_event,
               duration: monotonic_duration,
             }
             executions.where(finished_at: nil).where.not(performed_at: nil).update_all(execution_attrs) # rubocop:disable Rails/SkipsModelValidations
@@ -655,13 +655,13 @@ def perform(lock_id:)
             error_event = if !handled_error
                             nil
                           elsif handled_error == current_thread.error_on_discard
-                            :discarded
+                            ErrorEvents::DISCARDED
                           elsif handled_error == current_thread.error_on_retry
-                            :retried
+                            ErrorEvents::RETRIED
                           elsif handled_error == current_thread.error_on_retry_stopped
-                            :retry_stopped
+                            ErrorEvents::RETRY_STOPPED
                           elsif handled_error
-                            :handled
+                            ErrorEvents::HANDLED
                           end
 
             instrument_payload.merge!(
@@ -674,11 +674,11 @@ def perform(lock_id:)
             ExecutionResult.new(value: value, handled_error: handled_error, error_event: error_event, retried_job: current_thread.retried_job)
           rescue StandardError => e
             error_event = if e.is_a?(GoodJob::InterruptError)
-                            :interrupted
+                            ErrorEvents::INTERRUPTED
                           elsif e == current_thread.error_on_retry_stopped
-                            :retry_stopped
+                            ErrorEvents::RETRY_STOPPED
                           else
-                            :unhandled
+                            ErrorEvents::UNHANDLED
                           end
 
             instrument_payload.merge!(
@@ -722,8 +722,7 @@ def perform(lock_id:)
         end
 
         assign_attributes(job_attributes)
-        preserve_unhandled = result.unhandled_error && (GoodJob.retry_on_unhandled_error || GoodJob.preserve_job_records == :on_unhandled_error)
-        if finished_at.blank? || GoodJob.preserve_job_records == true || reenqueued || preserve_unhandled || cron_key.present?
+        if finished_at.blank? || cron_key.present? || preserve_job_record?(result)
           transaction do
             execution.save!
             save!
@@ -809,6 +808,14 @@ def active_job_data
         job_data["good_job_labels"] = Array(labels) if labels.present?
       end
     end
+
+    def preserve_job_record?(result)
+      return true if GoodJob.preserve_job_records == true
+      return true if result.unhandled_error && GoodJob.preserve_job_records == :on_unhandled_error
+      return true if GoodJob.preserve_job_records.respond_to?(:call) && GoodJob.preserve_job_records.call(result.error_event)
+
+      false
+    end
   end
 end
 

lib/good_job.rb

@@ -80,9 +80,12 @@ module GoodJob
   #   Whether to preserve job records in the database after they have finished (default: +true+).
   #   If you want to preserve jobs for latter inspection, set this to +true+.
   #   If you want to preserve only jobs that finished with error for latter inspection, set this to +:on_unhandled_error+.
+  #   If you want to preserve jobs based on the error event, set this to a lambda that takes the error_event argument.
   #   If you do not want to preserve jobs, set this to +false+.
   #   When using GoodJob's cron functionality, job records will be preserved for a brief time to prevent duplicate jobs.
-  #   @return [Boolean, Symbol, nil]
+  #   @example Preserve only jobs that were discarded
+  #     GoodJob.preserve_job_records = ->(error_event) { error_event == :discarded }
+  #   @return [Boolean, Symbol, Proc, nil]
   mattr_accessor :preserve_job_records, default: true
 
   # @!attribute [rw] retry_on_unhandled_error

spec/app/models/good_job/job_spec.rb

@@ -1047,7 +1047,7 @@ def job_params
                 job: good_job,
                 error: an_instance_of(TestJob::ExpectedError),
                 unhandled_error: an_instance_of(TestJob::ExpectedError),
-                error_event: :unhandled
+                error_event: GoodJob::ErrorEvents::UNHANDLED
               )
             end
             ActiveSupport::Notifications.subscribed(callback, "perform_job.good_job") do