good_job 4.22.0 → 4.23.0

data/config/locales/pt-BR.yml

@@ -37,17 +37,17 @@ pt-BR:
         no_batches_found: Nenhum lote encontrado.
     cleaner:
       index:
-        all: All
-        class: Class
-        exception: Exception
-        grouped_by_class: Discards grouped by Class
-        grouped_by_exception: Discards grouped by Exception
-        last_1_hour: Last 1 hour
-        last_24_hours: Last 24 hours
-        last_3_days: Last 3 days
-        last_3_hours: Last 3 hours
-        last_7_days: Last 7 days
-        title: Discard Cleaner
+        all: Tudo
+        class: Classe
+        exception: Exceção
+        grouped_by_class: Descartes agrupados por Classe
+        grouped_by_exception: Descartes agrupados por Exceção
+        last_1_hour: Última hora
+        last_24_hours: Últimas 24 horas
+        last_3_days: Últimos 3 dias
+        last_3_hours: Últimas 3 horas
+        last_7_days: Últimos 7 dias
+        title: Limpeza de Descartes
         total: Total
     concurrency_claims:
       states:
@@ -142,12 +142,12 @@ pt-BR:
         reschedule: Reagendar tarefa
         retry: Tentar tarefa novamente
       destroy:
-        notice: A tarefa foi excluida.
+        notice: A tarefa foi excluída.
       discard:
         notice: A tarefa foi descartada.
       executions:
-        application_trace: Application Trace
-        full_trace: Full Trace
+        application_trace: Trace da aplicação
+        full_trace: Trace completo
         in_queue: na fila
         recovery: recuperação
         runtime: tempo de execução
@@ -175,7 +175,7 @@ pt-BR:
           destroy_all: Excluir tudo
           discard_all: Descartar tudo
           reschedule_all: Reagendar tudo
-          retry_all: Tentar novamente tudo
+          retry_all: Tentar tudo novamente
           title: Ações
         no_jobs_found: Nenhuma tarefa encontrada.
         toggle_actions: Alternar Ações
@@ -204,7 +204,7 @@ pt-BR:
       job:
         arguments: Argumentos
         attempts: Tentativas
-        concurrency_claims: Reivindicações de concorrência
+        concurrency_claims: Reservas de concorrência
         labels: Rótulos
         priority: Prioridade
         queue: Fila
@@ -230,7 +230,7 @@ pt-BR:
         confirm_pause: Tem certeza que deseja pausar %{value}?
         confirm_unpause: Tem certeza que deseja retomar %{value}?
         disabled: O recurso experimental de Pausas do GoodJob está desativado por padrão porque pode degradar o desempenho. Configure para ativar
-        job_class: Classe do trabalho
+        job_class: Classe da tarefa
         label: Rótulo
         pause: Pausar
         queue: Fila
@@ -245,8 +245,8 @@ pt-BR:
         chart_title_total: Latência total média em segundos
         execution_latency: Latência de execução
         executions: Execuções
-        job_class: Classe do trabalho
-        jobs: Trabalhos
+        job_class: Classe da tarefa
+        jobs: Tarefas
         no_executions: Nenhuma execução neste intervalo de tempo.
         queue_latency: Latência na fila
         queue_name: Nome da fila
@@ -267,7 +267,9 @@ pt-BR:
           days: "%{count}d"
           hours: "%{count}h"
           minutes: "%{count}m"
-          months: "~%{count} mês"
+          months:
+            one: "~%{count} mês"
+            other: "~%{count} meses"
           seconds: "%{count}s"
           years: "~%{count}a"
         chart_bucket_size: 'Granularidade temporal do gráfico: %{size}'
@@ -317,8 +319,8 @@ pt-BR:
         search: Pesquisar
       navbar:
         batches: Lotes
-        cleaner: Discard Cleaner
-        cron_schedules: Agendamentos
+        cleaner: Limpeza de Descartes
+        cron_schedules: Tarefas Programadas
         jobs: Tarefas
         live_poll: Acompanhamento ao Vivo
         name: "GoodJob 👍"
@@ -332,7 +334,7 @@ pt-BR:
           theme: Tema
       pending_migrations: O GoodJob tem migrações pendentes no banco de dados.
       secondary_navbar:
-        inspiration: Lembre-se, você também está fazendo uma Boa Tarefa!
+        inspiration: Lembre-se, você também está fazendo um Bom Trabalho!
         last_updated: Última atualização
     status:
       discarded: Descartado

data/config/routes.rb

@@ -5,7 +5,7 @@ GoodJob::Engine.routes.draw do
 
   resources :jobs, only: %i[index show destroy] do
     collection do
-      get :mass_update, to: redirect(path: 'jobs')
+      get :mass_update, to: ->(_env) { raise ActionController::RoutingError, 'Not Found' }
       put :mass_update
     end
 
@@ -15,6 +15,8 @@ GoodJob::Engine.routes.draw do
       put :reschedule
       put :retry
     end
+
+    resources :executions, only: %i[show]
   end
   get 'jobs/metrics/primary_nav', to: 'metrics#primary_nav', as: :metrics_primary_nav
   get 'jobs/metrics/job_status', to: 'metrics#job_status', as: :metrics_job_status

data/lib/generators/good_job/templates/install/migrations/create_good_jobs.rb.erb

@@ -114,6 +114,7 @@ class CreateGoodJobs < ActiveRecord::Migration<%= migration_version %>
 
     add_index :good_job_executions, [:active_job_id, :created_at], name: :index_good_job_executions_on_active_job_id_and_created_at
     add_index :good_job_executions, :scheduled_at, name: :index_good_job_executions_on_scheduled_at
+    add_index :good_job_executions, :created_at, name: :index_good_job_executions_on_created_at
     add_index :good_jobs, [:priority, :scheduled_at, :id],
                                                       where: "finished_at IS NULL", name: "index_good_jobs_on_priority_scheduled_at_unfinished"
     add_index :good_jobs, [:queue_name, :scheduled_at, :id],

data/lib/generators/good_job/templates/update/migrations/01_create_good_jobs.rb.erb

@@ -97,6 +97,7 @@ class CreateGoodJobs < ActiveRecord::Migration<%= migration_version %>
 
     add_index :good_job_executions, [:active_job_id, :created_at], name: :index_good_job_executions_on_active_job_id_and_created_at
     add_index :good_job_executions, :scheduled_at, name: :index_good_job_executions_on_scheduled_at
+    add_index :good_job_executions, :created_at, name: :index_good_job_executions_on_created_at
     add_index :good_jobs, :locked_by_id,
       where: "locked_by_id IS NOT NULL", name: "index_good_jobs_on_locked_by_id"
     add_index :good_jobs, [:priority, :scheduled_at, :id],

data/lib/generators/good_job/templates/update/migrations/22_add_index_good_job_executions_on_created_at.rb.erb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class AddIndexGoodJobExecutionsOnCreatedAt < ActiveRecord::Migration<%= migration_version %>
+  disable_ddl_transaction!
+
+  def change
+    add_index :good_job_executions, :created_at,
+      name: :index_good_job_executions_on_created_at,
+      algorithm: :concurrently,
+      if_not_exists: true
+  end
+end

data/lib/good_job/active_job_extensions/concurrency.rb

@@ -6,6 +6,8 @@ module GoodJob
       extend ActiveSupport::Concern
 
       VALID_TYPES = [String, Symbol, Numeric, Date, Time, TrueClass, FalseClass, NilClass].freeze
+      # The lock and claim key for a rule without a label or key, which counts all jobs.
+      ALL_KEY = "all"
 
       class ConcurrencyExceededError < StandardError
         def backtrace
@@ -52,6 +54,9 @@ module GoodJob
 
         def evaluate(job, stage)
           resolved_label = resolve_label(job)
+          # A rule with a label that resolves to blank does not apply
+          return nil if @label.present? && resolved_label.blank?
+
           resolved_key = resolve_key(job, resolved_label)
           return nil if resolved_key.blank? && resolved_label.blank?
 
@@ -77,8 +82,10 @@ module GoodJob
         end
 
         def resolve_key(job, label)
-          if label.present? || key.blank?
+          if label.present?
             "label:#{label}"
+          elsif key.blank?
+            ALL_KEY
           else
             key_value = @key.respond_to?(:call) ? job.instance_exec(&@key) : @key
             raise TypeError, "Concurrency key must be a String; was a #{key_value.class}" if key_value.present? && VALID_TYPES.none? { |type| key_value.is_a?(type) }
@@ -117,7 +124,7 @@ module GoodJob
           elsif key_explicit? && key.present?
             "key:#{key}"
           else
-            "all"
+            ALL_KEY
           end
         end
 

data/lib/good_job/adapter.rb

@@ -5,11 +5,7 @@ module GoodJob
   # ActiveJob Adapter.
   #
   class Adapter
-    # @!attribute [r] instances
-    #   @!scope class
-    #   List of all instantiated Adapters in the current process.
-    #   @return [Array<GoodJob::Adapter>, nil]
-    cattr_reader :instances, default: Concurrent::Array.new, instance_reader: false
+    include InstanceRegistry
 
     # @param execution_mode [Symbol, nil] specifies how and where jobs should be executed. You can also set this with the environment variable +GOOD_JOB_EXECUTION_MODE+.
     #
@@ -25,13 +21,15 @@ module GoodJob
     #   -+test+: +:inline+
     #  - +production+ and all other environments: +:external+
     #
-    def initialize(execution_mode: nil, _capsule: GoodJob.capsule) # rubocop:disable Lint/UnderscorePrefixedVariableName
+    # @param _capsule [GoodJob::Capsule, nil] Capsule to use instead of {GoodJob.capsule}. An adapter with
+    #   its own capsule cannot be made Ractor-shareable.
+    def initialize(execution_mode: nil, _capsule: nil) # rubocop:disable Lint/UnderscorePrefixedVariableName
       @_execution_mode_override = execution_mode
       GoodJob::Configuration.validate_execution_mode(@_execution_mode_override) if @_execution_mode_override
-      @capsule = _capsule
+      @_capsule = _capsule
 
       start_async if GoodJob.async_ready?
-      self.class.instances << self
+      register_instance
     end
 
     # Enqueues the ActiveJob job to be performed.
@@ -75,16 +73,19 @@ module GoodJob
         lock_id = nil
 
         if execute_inline?
-          @capsule.tracker.register
+          lock_id = register_tracker
           tracker_registered = true
-          lock_id = @capsule.tracker.id_for_lock
         end
 
         begin
           GoodJob::Job.transaction(requires_new: true, joinable: false) do
-            column_names = GoodJob::Job.column_names
-            job_attributes = jobs.map { |job| job.attributes.slice(*column_names) }
-            results = GoodJob::Job.insert_all(job_attributes, returning: %w[id active_job_id]) # rubocop:disable Rails/SkipsModelValidations
+            results = if GoodJob::Ractors.main?
+                        column_names = GoodJob::Job.column_names
+                        job_attributes = jobs.map { |job| job.attributes.slice(*column_names) }
+                        GoodJob::Job.insert_all(job_attributes, returning: %w[id active_job_id]) # rubocop:disable Rails/SkipsModelValidations
+                      else
+                        insert_individually(jobs)
+                      end
 
             job_id_to_provider_job_id = results.to_h { |result| [result['active_job_id'], result['id']] }
             active_jobs.each do |active_job|
@@ -120,16 +121,16 @@ module GoodJob
               end
             ensure
               inline_jobs.each(&:advisory_unlock)
-              @capsule.tracker.unregister if tracker_registered
+              unregister_tracker if tracker_registered
               tracker_registered = false
             end
           elsif tracker_registered
-            @capsule.tracker.unregister
+            unregister_tracker
             tracker_registered = false
           end
         rescue StandardError
           if tracker_registered
-            @capsule.tracker.unregister
+            unregister_tracker
             tracker_registered = false
           end
           raise
@@ -147,7 +148,7 @@ module GoodJob
               state = { queue_name: queue_name, count: jobs_by_queue_and_scheduled_at.size }
               state[:scheduled_at] = scheduled_at if scheduled_at
 
-              executed_locally = execute_async? && @capsule&.create_thread(state)
+              executed_locally = execute_async? && create_capsule_thread(state)
               unless executed_locally
                 state[:count] = job_id_to_active_jobs.values_at(*jobs_by_queue_and_scheduled_at.map(&:active_job_id)).count { |active_job| send_notify?(active_job) }
                 Notifier.notify(state) unless state[:count].zero?
@@ -183,8 +184,7 @@ module GoodJob
           )
         elsif will_execute_inline
           lock_strategy = GoodJob::Job.effective_lock_strategy
-          @capsule.tracker.register
-          lock_id = @capsule.tracker.id_for_lock
+          lock_id = register_tracker
           tracker_registered = true
           begin
             job = case lock_strategy
@@ -198,12 +198,12 @@ module GoodJob
             InlineBuffer.perform_now_or_defer do
               perform_inline(job, notify: send_notify?(active_job), already_claimed: lock_strategy != :advisory, advisory_unlock: lock_strategy != :skiplocked)
             ensure
-              @capsule.tracker.unregister if tracker_registered
+              unregister_tracker if tracker_registered
               tracker_registered = false
             end
           rescue StandardError
             if tracker_registered
-              @capsule.tracker.unregister
+              unregister_tracker
               tracker_registered = false
             end
             raise
@@ -215,7 +215,7 @@ module GoodJob
           )
 
           if job
-            executed_locally = execute_async? && @capsule&.create_thread(job.job_state)
+            executed_locally = execute_async? && create_capsule_thread(job.job_state)
             Notifier.notify(job.job_state) if !executed_locally && send_notify?(active_job)
           end
         end
@@ -246,8 +246,7 @@ module GoodJob
     #   * A positive number will wait that many seconds before stopping any remaining active threads.
     # @return [void]
     def shutdown(timeout: NONE)
-      @capsule&.shutdown(timeout: timeout)
-      @_async_started = false
+      capsule.shutdown(timeout: timeout)
     end
 
     # This adapter's execution mode
@@ -282,19 +281,63 @@ module GoodJob
     def start_async
       return unless execute_async?
 
-      @capsule.start
-      @capsule.lower_thread_priority = true if GoodJob.configuration.lower_thread_priority.in?([true, nil])
-      @_async_started = true
+      capsule.start
+      capsule.lower_thread_priority = true if GoodJob.configuration.lower_thread_priority.in?([true, nil])
     end
 
     # Whether the async executors are running
     # @return [Boolean]
     def async_started?
-      @_async_started
+      GoodJob::Ractors.on_main(self) { capsule.running? }
+    end
+
+    # Adapters are retained until Rails has initialized so that async adapters can be started.
+    # @return [Boolean]
+    def prunable?
+      GoodJob.async_ready?
     end
 
     private
 
+    # The capsule is resolved on each use (rather than stored) so the adapter
+    # remains Ractor-shareable. Only call from the main Ractor.
+    # @return [GoodJob::Capsule]
+    def capsule
+      @_capsule || GoodJob.capsule
+    end
+
+    # The capsule is not Ractor-shareable, so it is always used on the main Ractor.
+    def create_capsule_thread(state)
+      job_state = GoodJob::Ractors.main? ? state : GoodJob::Ractors.make_shareable(state.dup)
+      GoodJob::Ractors.on_main(self) { capsule&.create_thread(job_state) }
+    end
+
+    def register_tracker
+      GoodJob::Ractors.on_main(self) do
+        tracker = capsule.tracker
+        tracker.register
+        tracker.id_for_lock
+      end
+    end
+
+    def unregister_tracker
+      GoodJob::Ractors.on_main(self) { capsule.tracker.unregister }
+    end
+
+    def tracker_id_for_lock
+      GoodJob::Ractors.on_main(self) { capsule.tracker.id_for_lock }
+    end
+
+    # Active Record does not support +insert_all+ outside of the main Ractor.
+    def insert_individually(jobs)
+      jobs.filter_map do |job|
+        GoodJob::Job.transaction(requires_new: true) { job.save!(validate: false) }
+        { 'id' => job.id, 'active_job_id' => job.active_job_id }
+      rescue ActiveRecord::RecordNotUnique
+        nil
+      end
+    end
+
     def send_notify?(active_job)
       return false unless GoodJob.configuration.enable_listen_notify
       return true unless active_job.respond_to?(:good_job_notify)
@@ -309,7 +352,7 @@ module GoodJob
       retried_job = nil
 
       loop do
-        result = job.perform(lock_id: @capsule.tracker.id_for_lock, already_claimed: already_claimed)
+        result = job.perform(lock_id: tracker_id_for_lock, already_claimed: already_claimed)
         already_claimed = false # only skip lock-write on first iteration
         retried_job = result.retried_job
         break if retried_job.nil? || retried_job.scheduled_at.nil? || retried_job.scheduled_at > Time.current

data/lib/good_job/capsule.rb

@@ -5,11 +5,7 @@ module GoodJob
   # a {GoodJob::Scheduler}, {GoodJob::Poller}, {GoodJob::Notifier}, and {GoodJob::CronManager}.
   # GoodJob creates a default capsule on initialization.
   class Capsule
-    # @!attribute [r] instances
-    #   @!scope class
-    #   List of all instantiated Capsules in the current process.
-    #   @return [Array<GoodJob::Capsule>, nil]
-    cattr_reader :instances, default: Concurrent::Array.new, instance_reader: false
+    include InstanceRegistry
 
     delegate :register, :renew, :unregister, :id_for_lock, to: :@tracker, prefix: :_tracker
 
@@ -26,7 +22,7 @@ module GoodJob
       @tracker = GoodJob::CapsuleTracker.new(executor: @shared_executor)
       @lower_thread_priority = nil
 
-      self.class.instances << self
+      register_instance
     end
 
     # Start the capsule once. After a shutdown, {#restart} must be used to start again.
@@ -37,6 +33,8 @@ module GoodJob
       @mutex.synchronize do
         return unless startable?(force: force)
 
+        register_instance
+
         @notifier = GoodJob::Notifier.new(enable_listening: configuration.enable_listen_notify, capsule: self, executor: @shared_executor)
         @poller = GoodJob::Poller.new(poll_interval: configuration.poll_interval)
         @multi_scheduler = GoodJob::MultiScheduler.from_configuration(configuration, capsule: self, warm_cache_on_initialize: true).tap do |multischeduler|
@@ -116,12 +114,14 @@ module GoodJob
       @multi_scheduler&.lower_thread_priority = value
     end
 
-    private
-
+    # Configuration for this capsule, falling back to the global configuration.
+    # @return [GoodJob::Configuration]
     def configuration
       @configuration || GoodJob.configuration
     end
 
+    private
+
     def startable?(force: false)
       !@started_at && (@startable || force)
     end

data/lib/good_job/capsule_tracker.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "concurrent/errors"
+require "concurrent/scheduled_task"
+
 module GoodJob # :nodoc:
   # CapsuleTracker save a record in the database and periodically refreshes it. The intention is to
   # create a heartbeat that can be used to determine whether a capsule/process is still active
@@ -16,11 +19,7 @@ module GoodJob # :nodoc:
     # @return [Integer]
     attr_reader :advisory_locks
 
-    # @!attribute [r] instances
-    #   @!scope class
-    #   List of all instantiated CapsuleTrackers in the current process.
-    #   @return [Array<GoodJob::CapsuleTracker>, nil]
-    cattr_reader :instances, default: Concurrent::Array.new, instance_reader: false
+    include InstanceRegistry
 
     # @param executor [Concurrent::AbstractExecutorService] The executor to use for refreshing the process record.
     def initialize(executor: Concurrent.global_io_executor)
@@ -32,10 +31,9 @@ module GoodJob # :nodoc:
       @record_id = SecureRandom.uuid
       @record = nil
       @refresh_task = nil
+      @pid = ::Process.pid
 
-      ActiveSupport::ForkTracker.after_fork { reset }
-
-      self.class.instances << self
+      register_instance
     end
 
     # The UUID to use for locking. May be nil if the process is not registered or is unusable/expired.
@@ -57,10 +55,18 @@ module GoodJob # :nodoc:
       value
     end
 
+    # Whether the tracker has no active registrations and can be removed from {.instances}.
+    # It is re-added to {.instances} when it is registered again.
+    # @return [Boolean]
+    def prunable?
+      @locks.zero?
+    end
+
     # The expected UUID of the process for use in inspection.
     # Use {#id_for_lock} if using this as a lock key.
     # @return [String]
     def process_id
+      reset if forked?
       @record_id
     end
 
@@ -75,6 +81,7 @@ module GoodJob # :nodoc:
       # where with_connection always returns a newly borrowed connection.
       GoodJob::Process.lease_connection if with_advisory_lock && advisory_lock_connection.nil?
 
+      register_instance
       synchronize(with_connection: with_advisory_lock) do
         if with_advisory_lock && !advisory_locked?
           if @record
@@ -112,9 +119,10 @@ module GoodJob # :nodoc:
         if with_advisory_lock && @advisory_locked
           active = advisory_locked?
           if !active || matches_advisory_locked_connection?(advisory_lock_connection)
-            @record.advisory_unlock(connection: advisory_lock_connection) if active
-            # Remaining jobs need heartbeat liveness once the advisory lock is gone.
+            # Move remaining jobs to heartbeat liveness before releasing the lock; otherwise
+            # another process's cleanup can see an unlocked advisory record and release them.
             @record&.update(lock_type: nil) if @locks > 1
+            @record.advisory_unlock(connection: advisory_lock_connection) if active
             @advisory_locked = false
             @advisory_locked_connection = nil
           end
@@ -213,7 +221,14 @@ module GoodJob # :nodoc:
       synchronize { ns_reset }
     end
 
+    # Reset lazily after a fork (rather than with an ActiveSupport::ForkTracker callback)
+    # so that the tracker is not retained after it is no longer used.
+    def forked?
+      @pid != ::Process.pid
+    end
+
     def ns_reset
+      @pid = ::Process.pid
       @record_id = SecureRandom.uuid
       @record = nil
       @advisory_locked = false
@@ -235,7 +250,10 @@ module GoodJob # :nodoc:
       elsif @mutex.owned?
         yield
       else
-        @mutex.synchronize(&block)
+        @mutex.synchronize do
+          ns_reset if forked?
+          yield
+        end
       end
     end
   end

data/lib/good_job/configuration.rb

@@ -528,6 +528,15 @@ module GoodJob
       (options[:dequeue_query_sort] || rails_config[:dequeue_query_sort] || :created_at).to_sym
     end
 
+    # Resolves lazily memoized values so the configuration can be frozen.
+    # @return [self]
+    def prepare_for_sharing
+      in_webserver?
+      validator
+      @_rails_config = rails_config
+      self
+    end
+
     private
 
     # Reads a configuration value from one or more deprecated sources, emitting a
@@ -586,7 +595,7 @@ module GoodJob
     end
 
     def rails_config
-      Rails.application.config.good_job
+      @_rails_config || Rails.application.config.good_job
     end
   end
 end

data/lib/good_job/cron_manager.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "concurrent/errors"
+require "concurrent/future"
 require "concurrent/hash"
 require "concurrent/scheduled_task"
 require "fugit"
@@ -9,11 +11,7 @@ module GoodJob # :nodoc:
   # CronManagers enqueue jobs on a repeating schedule.
   #
   class CronManager
-    # @!attribute [r] instances
-    #   @!scope class
-    #   List of all instantiated CronManagers in the current process.
-    #   @return [Array<GoodJob::CronManager>, nil]
-    cattr_reader :instances, default: Concurrent::Array.new, instance_reader: false
+    include InstanceRegistry
 
     # Task observer for cron task
     # @param time [Time]
@@ -41,11 +39,12 @@ module GoodJob # :nodoc:
       @graceful_restart_period = graceful_restart_period
 
       start if start_on_initialize
-      self.class.instances << self
+      register_instance
     end
 
     # Schedule tasks that will enqueue jobs based on their schedule
     def start
+      register_instance
       ActiveSupport::Notifications.instrument("cron_manager_start.good_job", cron_entries: cron_entries) do
         @running = true
         graceful_restart = graceful_restart?

data/lib/good_job/engine.rb

@@ -10,6 +10,10 @@ module GoodJob
     config.good_job = ActiveSupport::OrderedOptions.new
     config.good_job.cron = {}
 
+    initializer "good_job.ractors" do |app|
+      app.singleton_class.prepend(GoodJob::Ractors::ApplicationExtension) if GoodJob::Ractors.enabled? && app.respond_to?(:ractorize!)
+    end
+
     initializer "good_job.logger" do |_app|
       ActiveSupport.on_load(:good_job) do
         self.logger = ::Rails.logger if GoodJob.logger == GoodJob::DEFAULT_LOGGER

data/lib/good_job/instance_registry.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "concurrent/array"
+
+module GoodJob # :nodoc:
+  # Tracks instances of a class in a class-level +instances+ registry so they can be
+  # shut down or restarted together (e.g. by {GoodJob.shutdown} and {GoodJob.restart}).
+  # Instances remain in the registry after they are shut down so that they can be
+  # restarted; use +prune+ to remove them so they can be garbage collected.
+  module InstanceRegistry
+    extend ActiveSupport::Concern
+
+    included do
+      # @!attribute [r] instances
+      #   @!scope class
+      #   List of all registered instances in the current process.
+      #   @return [Array]
+      cattr_reader :instances, default: Concurrent::Array.new, instance_reader: false
+    end
+
+    class_methods do
+      # Removes prunable (e.g. shut down) instances from the registry so they can be garbage collected.
+      # Instances are re-registered if they are started again.
+      # @return [Array] The pruned instances.
+      def prune
+        pruned = instances.select(&:prunable?)
+        instances.delete_if { |instance| pruned.include?(instance) }
+        pruned
+      end
+    end
+
+    # Whether the instance can be removed from the registry.
+    # @return [Boolean]
+    def prunable?
+      shutdown?
+    end
+
+    private
+
+    def register_instance
+      instances = self.class.instances
+      instances << self unless instances.include?(self)
+    end
+  end
+end