good_job 2.7.1 → 2.8.0

data/lib/good_job/configuration.rb

@@ -18,6 +18,10 @@ module GoodJob
     DEFAULT_MAX_CACHE = 10000
     # Default number of seconds to preserve jobs for {CLI#cleanup_preserved_jobs} and {GoodJob.cleanup_preserved_jobs}
     DEFAULT_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO = 24 * 60 * 60
+    # Default number of jobs to execute between preserved job cleanup runs
+    DEFAULT_CLEANUP_INTERVAL_JOBS = nil
+    # Default number of seconds to wait between preserved job cleanup runs
+    DEFAULT_CLEANUP_INTERVAL_SECONDS = nil
     # Default to always wait for jobs to finish for {Adapter#shutdown}
     DEFAULT_SHUTDOWN_TIMEOUT = -1
     # Default to not running cron
@@ -50,24 +54,22 @@ module GoodJob
     # for more details on possible values.
     # @return [Symbol]
     def execution_mode
-      @_execution_mode ||= begin
-        mode = if GoodJob::CLI.within_exe?
-                 :external
-               else
-                 options[:execution_mode] ||
-                   rails_config[:execution_mode] ||
-                   env['GOOD_JOB_EXECUTION_MODE']
-               end
-
-        if mode
-          mode.to_sym
-        elsif Rails.env.development?
-          :async
-        elsif Rails.env.test?
-          :inline
-        else
-          :external
-        end
+      mode = if GoodJob::CLI.within_exe?
+               :external
+             else
+               options[:execution_mode] ||
+                 rails_config[:execution_mode] ||
+                 env['GOOD_JOB_EXECUTION_MODE']
+             end
+
+      if mode
+        mode.to_sym
+      elsif Rails.env.development?
+        :async
+      elsif Rails.env.test?
+        :inline
+      else
+        :external
       end
     end
 
@@ -181,6 +183,28 @@ module GoodJob
       ).to_i
     end
 
+    # Number of jobs a {Scheduler} will execute before cleaning up preserved jobs.
+    # @return [Integer, nil]
+    def cleanup_interval_jobs
+      value = (
+        rails_config[:cleanup_interval_jobs] ||
+          env['GOOD_JOB_CLEANUP_INTERVAL_JOBS'] ||
+          DEFAULT_CLEANUP_INTERVAL_JOBS
+      )
+      value.present? ? value.to_i : nil
+    end
+
+    # Number of seconds a {Scheduler} will wait before cleaning up preserved jobs.
+    # @return [Integer, nil]
+    def cleanup_interval_seconds
+      value = (
+        rails_config[:cleanup_interval_seconds] ||
+          env['GOOD_JOB_CLEANUP_INTERVAL_SECONDS'] ||
+          DEFAULT_CLEANUP_INTERVAL_SECONDS
+      )
+      value.present? ? value.to_i : nil
+    end
+
     # Tests whether to daemonize the process.
     # @return [Boolean]
     def daemonize?

data/lib/good_job/cron_manager.rb

@@ -21,7 +21,7 @@ module GoodJob # :nodoc:
     def self.task_observer(time, output, thread_error) # rubocop:disable Lint/UnusedMethodArgument
       return if thread_error.is_a? Concurrent::CancelledOperationError
 
-      GoodJob.on_thread_error.call(thread_error) if thread_error && GoodJob.on_thread_error.respond_to?(:call)
+      GoodJob._on_thread_error(thread_error) if thread_error
     end
 
     # Execution configuration to be scheduled

data/lib/good_job/current_thread.rb

@@ -68,7 +68,7 @@ module GoodJob
 
     # @return [Integer] Current process ID
     def self.process_id
-      Process.pid
+      ::Process.pid
     end
 
     # @return [String] Current thread name

data/lib/good_job/daemon.rb

@@ -17,7 +17,7 @@ module GoodJob
     # @return [void]
     def daemonize
       check_pid
-      Process.daemon
+      ::Process.daemon
       write_pid
     end
 
@@ -25,7 +25,7 @@ module GoodJob
 
     # @return [void]
     def write_pid
-      File.open(pidfile, ::File::CREAT | ::File::EXCL | ::File::WRONLY) { |f| f.write(Process.pid.to_s) }
+      File.open(pidfile, ::File::CREAT | ::File::EXCL | ::File::WRONLY) { |f| f.write(::Process.pid.to_s) }
       at_exit { File.delete(pidfile) if File.exist?(pidfile) }
     rescue Errno::EEXIST
       check_pid
@@ -55,7 +55,7 @@ module GoodJob
       pid = ::File.read(pidfile).to_i
       return :dead if pid.zero?
 
-      Process.kill(0, pid) # check process status
+      ::Process.kill(0, pid) # check process status
       :running
     rescue Errno::ESRCH
       :dead

data/lib/good_job/execution.rb

@@ -1,10 +1,7 @@
 # frozen_string_literal: true
 module GoodJob
   # ActiveRecord model that represents an +ActiveJob+ job.
-  # Parent class can be configured with +GoodJob.active_record_parent_class+.
-  # @!parse
-  #   class Execution < ActiveRecord::Base; end
-  class Execution < Object.const_get(GoodJob.active_record_parent_class)
+  class Execution < BaseRecord
     include Lockable
     include Filterable
 
@@ -54,16 +51,6 @@ module GoodJob
       end
     end
 
-    def self._migration_pending_warning
-      ActiveSupport::Deprecation.warn(<<~DEPRECATION)
-        GoodJob has pending database migrations. To create the migration files, run:
-            rails generate good_job:update
-        To apply the migration files, run:
-            rails db:migrate
-      DEPRECATION
-      nil
-    end
-
     # Get Jobs with given ActiveJob ID
     # @!method active_job_id
     # @!scope class
@@ -224,7 +211,7 @@ module GoodJob
           if @cron_at_index
             execution_args[:cron_at] = CurrentThread.cron_at
           else
-            _migration_pending_warning
+            migration_pending_warning!
           end
         elsif CurrentThread.active_job_id && CurrentThread.active_job_id == active_job.job_id
           execution_args[:cron_key] = CurrentThread.execution.cron_key

data/lib/good_job/job_performer.rb

@@ -57,6 +57,12 @@ module GoodJob
       job_query.next_scheduled_at(after: after, limit: limit, now_limit: now_limit)
     end
 
+    # Delete expired preserved jobs
+    # @return [void]
+    def cleanup
+      GoodJob.cleanup_preserved_jobs
+    end
+
     private
 
     attr_reader :queue_string

data/lib/good_job/lockable.rb

@@ -215,7 +215,9 @@ module GoodJob
                 SQL
               end
 
-      binds = [[nil, key]]
+      binds = [
+        ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
+      ]
       self.class.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Lock', binds).first['locked']
     end
 
@@ -229,7 +231,9 @@ module GoodJob
       query = <<~SQL.squish
         SELECT #{function}(('x'||substr(md5($1::text), 1, 16))::bit(64)::bigint) AS unlocked
       SQL
-      binds = [[nil, key]]
+      binds = [
+        ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
+      ]
       self.class.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Unlock', binds).first['unlocked']
     end
 
@@ -279,7 +283,10 @@ module GoodJob
           AND pg_locks.classid = ('x' || substr(md5($1::text), 1, 16))::bit(32)::int
           AND pg_locks.objid = (('x' || substr(md5($2::text), 1, 16))::bit(64) << 32)::bit(32)::int
       SQL
-      binds = [[nil, key], [nil, key]]
+      binds = [
+        ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
+        ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
+      ]
       self.class.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Locked?', binds).any?
     end
 
@@ -303,7 +310,10 @@ module GoodJob
           AND pg_locks.objid = (('x' || substr(md5($2::text), 1, 16))::bit(64) << 32)::bit(32)::int
           AND pg_locks.pid = pg_backend_pid()
       SQL
-      binds = [[nil, key], [nil, key]]
+      binds = [
+        ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
+        ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
+      ]
       self.class.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Owns Advisory Lock?', binds).any?
     end
 

data/lib/good_job/notifier/process_registration.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module GoodJob # :nodoc:
+  class Notifier # :nodoc:
+    # Extends the Notifier to register the process in the database.
+    module ProcessRegistration
+      extend ActiveSupport::Concern
+
+      included do
+        set_callback :listen, :after, :register_process
+        set_callback :unlisten, :after, :deregister_process
+      end
+
+      # Registers the current process.
+      def register_process
+        GoodJob::Process.with_connection(connection) do
+          next unless Process.migrated?
+
+          GoodJob::Process.cleanup
+          @process = GoodJob::Process.register
+        end
+      end
+
+      # Deregisters the current process.
+      def deregister_process
+        GoodJob::Process.with_connection(connection) do
+          next unless Process.migrated?
+
+          @process&.deregister
+        end
+      end
+    end
+  end
+end

data/lib/good_job/notifier.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'active_support/core_ext/module/attribute_accessors_per_thread'
 require 'concurrent/atomic/atomic_boolean'
 
 module GoodJob # :nodoc:
@@ -10,6 +11,11 @@ module GoodJob # :nodoc:
   # When a message is received, the notifier passes the message to each of its recipients.
   #
   class Notifier
+    include ActiveSupport::Callbacks
+    define_callbacks :listen, :unlisten
+
+    include Notifier::ProcessRegistration
+
     # Raised if the Database adapter does not implement LISTEN.
     AdapterCannotListenError = Class.new(StandardError)
 
@@ -43,6 +49,12 @@ module GoodJob # :nodoc:
     #   @return [Array<GoodJob::Notifier>, nil]
     cattr_reader :instances, default: [], instance_reader: false
 
+    # @!attribute [rw] connection
+    #   @!scope class
+    #   ActiveRecord Connection that has been established for the Notifier.
+    #   @return [ActiveRecord::ConnectionAdapters::AbstractAdapter, nil]
+    thread_cattr_accessor :connection
+
     # Send a message via Postgres NOTIFY
     # @param message [#to_json]
     def self.notify(message)
@@ -120,7 +132,7 @@ module GoodJob # :nodoc:
       return if thread_error.is_a? AdapterCannotListenError
 
       if thread_error
-        GoodJob.on_thread_error.call(thread_error) if GoodJob.on_thread_error.respond_to?(:call)
+        GoodJob._on_thread_error(thread_error)
         ActiveSupport::Notifications.instrument("notifier_notify_error.good_job", { error: thread_error })
 
         connection_error = CONNECTION_ERRORS.any? do |error_string|
@@ -146,30 +158,36 @@ module GoodJob # :nodoc:
 
     def listen(delay: 0)
       future = Concurrent::ScheduledTask.new(delay, args: [@recipients, executor, @listening], executor: @executor) do |thr_recipients, thr_executor, thr_listening|
-        with_listen_connection do |conn|
-          ActiveSupport::Notifications.instrument("notifier_listen.good_job") do
-            conn.async_exec("LISTEN #{CHANNEL}").clear
-          end
+        with_connection do
+          begin
+            run_callbacks :listen do
+              ActiveSupport::Notifications.instrument("notifier_listen.good_job") do
+                connection.execute("LISTEN #{CHANNEL}")
+              end
+              thr_listening.make_true
+            end
 
-          ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-            thr_listening.make_true
-            while thr_executor.running?
-              conn.wait_for_notify(WAIT_INTERVAL) do |channel, _pid, payload|
-                next unless channel == CHANNEL
-
-                ActiveSupport::Notifications.instrument("notifier_notified.good_job", { payload: payload })
-                parsed_payload = JSON.parse(payload, symbolize_names: true)
-                thr_recipients.each do |recipient|
-                  target, method_name = recipient.is_a?(Array) ? recipient : [recipient, :call]
-                  target.send(method_name, parsed_payload)
+            ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+              while thr_executor.running?
+                wait_for_notify do |channel, payload|
+                  next unless channel == CHANNEL
+
+                  ActiveSupport::Notifications.instrument("notifier_notified.good_job", { payload: payload })
+                  parsed_payload = JSON.parse(payload, symbolize_names: true)
+                  thr_recipients.each do |recipient|
+                    target, method_name = recipient.is_a?(Array) ? recipient : [recipient, :call]
+                    target.send(method_name, parsed_payload)
+                  end
                 end
               end
             end
           end
         ensure
-          thr_listening.make_false
-          ActiveSupport::Notifications.instrument("notifier_unlisten.good_job") do
-            conn.async_exec("UNLISTEN *").clear
+          run_callbacks :unlisten do
+            thr_listening.make_false
+            ActiveSupport::Notifications.instrument("notifier_unlisten.good_job") do
+              connection.execute("UNLISTEN *")
+            end
           end
         end
       end
@@ -178,17 +196,27 @@ module GoodJob # :nodoc:
       future.execute
     end
 
-    def with_listen_connection
-      ar_conn = Execution.connection_pool.checkout.tap do |conn|
+    def with_connection
+      self.connection = Execution.connection_pool.checkout.tap do |conn|
         Execution.connection_pool.remove(conn)
       end
-      pg_conn = ar_conn.raw_connection
-      raise AdapterCannotListenError unless pg_conn.respond_to? :wait_for_notify
+      connection.execute("SET application_name = #{connection.quote(self.class.name)}")
 
-      pg_conn.async_exec("SET application_name = #{pg_conn.escape_identifier(self.class.name)}").clear
-      yield pg_conn
+      yield
     ensure
-      ar_conn&.disconnect!
+      connection&.disconnect!
+      self.connection = nil
+    end
+
+    def wait_for_notify
+      raw_connection = connection.raw_connection
+      if raw_connection.respond_to?(:wait_for_notify)
+        raw_connection.wait_for_notify(WAIT_INTERVAL) do |channel, _pid, payload|
+          yield(channel, payload)
+        end
+      else
+        sleep WAIT_INTERVAL
+      end
     end
   end
 end

data/lib/good_job/poller.rb

@@ -91,7 +91,7 @@ module GoodJob # :nodoc:
     # @param thread_error [Exception, nil]
     # @return [void]
     def timer_observer(time, executed_task, thread_error)
-      GoodJob.on_thread_error.call(thread_error) if thread_error && GoodJob.on_thread_error.respond_to?(:call)
+      GoodJob._on_thread_error(thread_error) if thread_error
       ActiveSupport::Notifications.instrument("finished_timer_task", { result: executed_task, error: thread_error, time: time })
     end
 

data/lib/good_job/probe_server.rb

@@ -7,7 +7,7 @@ module GoodJob
     def self.task_observer(time, output, thread_error) # rubocop:disable Lint/UnusedMethodArgument
       return if thread_error.is_a? Concurrent::CancelledOperationError
 
-      GoodJob.on_thread_error.call(thread_error) if thread_error && GoodJob.on_thread_error.respond_to?(:call)
+      GoodJob._on_thread_error(thread_error) if thread_error
     end
 
     def initialize(port:)

data/lib/good_job/process.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+require 'socket'
+
+module GoodJob # :nodoc:
+  # ActiveRecord model that represents an GoodJob process (either async or CLI).
+  class Process < BaseRecord
+    include AssignableConnection
+    include Lockable
+
+    self.table_name = 'good_job_processes'
+
+    cattr_reader :mutex, default: Mutex.new
+    cattr_accessor :_current_id, default: nil
+    cattr_accessor :_pid, default: nil
+
+    # Processes that are active and locked.
+    # @!method active
+    # @!scope class
+    # @return [ActiveRecord::Relation]
+    scope :active, -> { advisory_locked }
+
+    # Processes that are inactive and unlocked (e.g. SIGKILLed)
+    # @!method active
+    # @!scope class
+    # @return [ActiveRecord::Relation]
+    scope :inactive, -> { advisory_unlocked }
+
+    # Whether the +good_job_processes+ table exsists.
+    # @return [Boolean]
+    def self.migrated?
+      return true if connection.table_exists?(table_name)
+
+      migration_pending_warning!
+      false
+    end
+
+    # UUID that is unique to the current process and changes when forked.
+    # @return [String]
+    def self.current_id
+      mutex.synchronize do
+        if _current_id.nil? || _pid != ::Process.pid
+          self._current_id = SecureRandom.uuid
+          self._pid = ::Process.pid
+        end
+        _current_id
+      end
+    end
+
+    # Hash representing metadata about the current process.
+    # @return [Hash]
+    def self.current_state
+      {
+        id: current_id,
+        hostname: Socket.gethostname,
+        pid: ::Process.pid,
+        proctitle: $PROGRAM_NAME,
+        schedulers: GoodJob::Scheduler.instances.map(&:name),
+      }
+    end
+
+    # Deletes all inactive process records.
+    def self.cleanup
+      inactive.delete_all
+    end
+
+    # Registers the current process in the database
+    # @return [GoodJob::Process]
+    def self.register
+      create(id: current_id, state: current_state, create_with_advisory_lock: true)
+    rescue ActiveRecord::RecordNotUnique
+      nil
+    end
+
+    # Unregisters the instance.
+    def deregister
+      return unless owns_advisory_lock?
+
+      destroy!
+      advisory_unlock
+    end
+  end
+end

data/lib/good_job/railtie.rb

@@ -7,7 +7,7 @@ module GoodJob
 
     initializer "good_job.logger" do |_app|
       ActiveSupport.on_load(:good_job) do
-        self.logger = ::Rails.logger
+        self.logger = ::Rails.logger if GoodJob.logger == GoodJob::DEFAULT_LOGGER
       end
       GoodJob::LogSubscriber.attach_to :good_job
     end
@@ -22,9 +22,21 @@ module GoodJob
       end
     end
 
-    config.after_initialize do
-      GoodJob::Scheduler.instances.each(&:warm_cache)
-      GoodJob::CronManager.instances.each(&:start)
+    initializer 'good_job.rails_config' do
+      config.after_initialize do
+        rails_config = Rails.application.config.good_job
+
+        GoodJob.logger = rails_config[:logger] if rails_config.key?(:logger)
+        GoodJob.on_thread_error = rails_config[:on_thread_error] if rails_config.key?(:on_thread_error)
+        GoodJob.preserve_job_records = rails_config[:preserve_job_records] if rails_config.key?(:preserve_job_records)
+        GoodJob.retry_on_unhandled_error = rails_config[:retry_on_unhandled_error] if rails_config.key?(:retry_on_unhandled_error)
+      end
+    end
+
+    initializer "good_job.start_async" do
+      config.after_initialize do
+        GoodJob::Adapter.instances.each(&:start_async)
+      end
     end
   end
 end

data/lib/good_job/scheduler.rb

@@ -48,7 +48,9 @@ module GoodJob # :nodoc:
           job_performer,
           max_threads: max_threads,
           max_cache: configuration.max_cache,
-          warm_cache_on_initialize: warm_cache_on_initialize
+          warm_cache_on_initialize: warm_cache_on_initialize,
+          cleanup_interval_seconds: configuration.cleanup_interval_seconds,
+          cleanup_interval_jobs: configuration.cleanup_interval_jobs
         )
       end
 
@@ -59,11 +61,17 @@ module GoodJob # :nodoc:
       end
     end
 
+    # Human readable name of the scheduler that includes configuration values.
+    # @return [String]
+    attr_reader :name
+
     # @param performer [GoodJob::JobPerformer]
     # @param max_threads [Numeric, nil] number of seconds between polls for jobs
     # @param max_cache [Numeric, nil] maximum number of scheduled jobs to cache in memory
     # @param warm_cache_on_initialize [Boolean] whether to warm the cache immediately, or manually by calling +warm_cache+
-    def initialize(performer, max_threads: nil, max_cache: nil, warm_cache_on_initialize: false)
+    # @param cleanup_interval_seconds [Numeric, nil] number of seconds between cleaning up job records
+    # @param cleanup_interval_jobs [Numeric, nil] number of executed jobs between cleaning up job records
+    def initialize(performer, max_threads: nil, max_cache: nil, warm_cache_on_initialize: false, cleanup_interval_seconds: nil, cleanup_interval_jobs: nil)
       raise ArgumentError, "Performer argument must implement #next" unless performer.respond_to?(:next)
 
       self.class.instances << self
@@ -76,8 +84,10 @@ module GoodJob # :nodoc:
         @executor_options[:max_threads] = max_threads
         @executor_options[:max_queue] = max_threads
       end
-      @executor_options[:name] = "GoodJob::Scheduler(queues=#{@performer.name} max_threads=#{@executor_options[:max_threads]})"
+      @name = "GoodJob::Scheduler(queues=#{@performer.name} max_threads=#{@executor_options[:max_threads]})"
+      @executor_options[:name] = name
 
+      @cleanup_tracker = CleanupTracker.new(cleanup_interval_seconds: cleanup_interval_seconds, cleanup_interval_jobs: cleanup_interval_jobs)
       create_executor
       warm_cache if warm_cache_on_initialize
     end
@@ -169,10 +179,17 @@ module GoodJob # :nodoc:
     # @return [void]
     def task_observer(time, output, thread_error)
       error = thread_error || (output.is_a?(GoodJob::ExecutionResult) ? output.unhandled_error : nil)
-      GoodJob.on_thread_error.call(error) if error && GoodJob.on_thread_error.respond_to?(:call)
+      GoodJob._on_thread_error(error) if error
 
       instrument("finished_job_task", { result: output, error: thread_error, time: time })
-      create_task if output
+      return unless output
+
+      @cleanup_tracker.increment
+      if @cleanup_tracker.cleanup?
+        cleanup
+      else
+        create_task
+      end
     end
 
     # Information about the Scheduler
@@ -206,11 +223,29 @@ module GoodJob # :nodoc:
       end
 
       observer = lambda do |_time, _output, thread_error|
-        GoodJob.on_thread_error.call(thread_error) if thread_error && GoodJob.on_thread_error.respond_to?(:call)
+        GoodJob._on_thread_error(thread_error) if thread_error
         create_task # If cache-warming exhausts the threads, ensure there isn't an executable task remaining
       end
       future.add_observer(observer, :call)
+      future.execute
+    end
+
+    # Preload existing runnable and future-scheduled jobs
+    # @return [void]
+    def cleanup
+      @cleanup_tracker.reset
+
+      future = Concurrent::Future.new(args: [self, @performer], executor: executor) do |_thr_scheduler, thr_performer|
+        Rails.application.executor.wrap do
+          thr_performer.cleanup
+        end
+      end
 
+      observer = lambda do |_time, _output, thread_error|
+        GoodJob._on_thread_error(thread_error) if thread_error
+        create_task
+      end
+      future.add_observer(observer, :call)
       future.execute
     end
 

data/lib/good_job/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module GoodJob
   # GoodJob gem version.
-  VERSION = '2.7.1'
+  VERSION = '2.8.0'
 end

data/lib/good_job.rb

@@ -18,6 +18,8 @@ require "good_job/railtie"
 #
 # +GoodJob+ is the top-level namespace and exposes configuration attributes.
 module GoodJob
+  DEFAULT_LOGGER = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new($stdout))
+
   # @!attribute [rw] active_record_parent_class
   #   @!scope class
   #   The ActiveRecord parent class inherited by +GoodJob::Execution+ (default: +ActiveRecord::Base+).
@@ -34,7 +36,7 @@ module GoodJob
   #   @return [Logger, nil]
   #   @example Output GoodJob logs to a file:
   #     GoodJob.logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new("log/my_logs.log"))
-  mattr_accessor :logger, default: ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new($stdout))
+  mattr_accessor :logger, default: DEFAULT_LOGGER
 
   # @!attribute [rw] preserve_job_records
   #   @!scope class
@@ -66,6 +68,13 @@ module GoodJob
   #   @return [Proc, nil]
   mattr_accessor :on_thread_error, default: nil
 
+  # Called with exception when a GoodJob thread raises an exception
+  # @param exception [Exception] Exception that was raised
+  # @return [void]
+  def self._on_thread_error(exception)
+    on_thread_error.call(exception) if on_thread_error.respond_to?(:call)
+  end
+
   # Stop executing jobs.
   # GoodJob does its work in pools of background threads.
   # When forking processes you should shut down these background threads before forking, and restart them after forking.
@@ -122,7 +131,7 @@ module GoodJob
   # analyze or inspect job performance.
   # If you are preserving job records this way, use this method regularly to
   # delete old records and preserve space in your database.
-  # @params older_than [nil,Numeric,ActiveSupport::Duration] Jobs olders than this will be deleted (default: +86400+).
+  # @params older_than [nil,Numeric,ActiveSupport::Duration] Jobs older than this will be deleted (default: +86400+).
   # @return [Integer] Number of jobs that were deleted.
   def self.cleanup_preserved_jobs(older_than: nil)
     older_than ||= GoodJob::Configuration.new({}).cleanup_preserved_jobs_before_seconds_ago