good_job 3.19.4 → 3.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b2fd15bbee1a5d3cbe17a0154fa15fdd960c9b5fc39a55b60831792095538e0
-  data.tar.gz: 831a78bc9a7e569fb72601f817bb4397b702ad89dc4f1e5776b3c8fc28ab042e
+  metadata.gz: f1e8a8a3ec28224d48f23c9c2795cd15f9eb515ba9059ab2bea4316a03b42aa9
+  data.tar.gz: e469a0f1be765789433ef9d0096c6c1c3fe3e87c90a184c11996a204a36dabd1
 SHA512:
-  metadata.gz: c598627e0a4999e7faef09edb7c286344019a4c20fb7cf952bf0026a2247aa1f4aef4f9e9530e8cc105ec502cbf258f41f58ad5a1ec62ce7e2453f8dd4f0f92c
-  data.tar.gz: 40dfbac0623a460c22f55889cd80bccc77a7391c3c05b42692267424c136af3224d20d042735906dca506540a699a5f7a592d8eda16ff79255089fc15b390829
+  metadata.gz: 6546caba43d15714d87c2b6f3a072b493804685411f7fdd3c73b8aaa0aacffb2f77ae8fcbb8f3eb0d9aeed9fbfab2c4175b49adebd3d5356a8994138b92e3852
+  data.tar.gz: 30f85524258b9f1b2b774601ef0fd23965ed21eac87b0a3c0491a94c0fe85a3c70efb57b9979d11047d8ea5176cf0008317c860c27411db86ecdf8ef2fd0a69c

data/CHANGELOG.md

@@ -1,5 +1,53 @@
 # Changelog
 
+## [v3.21.0](https://github.com/bensheldon/good_job/tree/v3.21.0) (2023-11-06)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v3.20.0...v3.21.0)
+
+**Implemented enhancements:**
+
+- Add "cron enabled" column to processes index page [\#1127](https://github.com/bensheldon/good_job/pull/1127) ([bforma](https://github.com/bforma))
+- Add `limit:` kwarg to `GoodJob.perform_inline` [\#1126](https://github.com/bensheldon/good_job/pull/1126) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- Cron scheduler and multiple processes [\#1128](https://github.com/bensheldon/good_job/issues/1128)
+- `GoodJob.on_thread_error` not called in tests [\#1102](https://github.com/bensheldon/good_job/issues/1102)
+
+**Merged pull requests:**
+
+- Use a Concurrent::Event for CLI signal-trapping loop [\#1141](https://github.com/bensheldon/good_job/pull/1141) ([bensheldon](https://github.com/bensheldon))
+- Update README's optimize queue explanation [\#1138](https://github.com/bensheldon/good_job/pull/1138) ([maestromac](https://github.com/maestromac))
+- Update development dependencies and light Rubocop'ing [\#1136](https://github.com/bensheldon/good_job/pull/1136) ([bensheldon](https://github.com/bensheldon))
+- Move the Rails app harness from `spec/test_app` to `demo` [\#1135](https://github.com/bensheldon/good_job/pull/1135) ([bensheldon](https://github.com/bensheldon))
+- In test, shutdown schedulers/capsules before doing assertions because of race conditions; store CI logs for Dev Env tests [\#1129](https://github.com/bensheldon/good_job/pull/1129) ([bensheldon](https://github.com/bensheldon))
+- Use a constant to represent `None` for default/blank memoizable values [\#1125](https://github.com/bensheldon/good_job/pull/1125) ([bensheldon](https://github.com/bensheldon))
+
+## [v3.20.0](https://github.com/bensheldon/good_job/tree/v3.20.0) (2023-10-23)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v3.19.4...v3.20.0)
+
+**Closed issues:**
+
+- Dashboard blocked in iframe tag [\#1111](https://github.com/bensheldon/good_job/issues/1111)
+- PG::ConnectionBad: PQsocket\(\) can't get socket descriptor [\#1100](https://github.com/bensheldon/good_job/issues/1100)
+
+**Merged pull requests:**
+
+- Wrap Adapter enqueue methods and Batch callbacks with Rails Reloader; verify in tests that no Advisory locks remain at database connection check-in  [\#1124](https://github.com/bensheldon/good_job/pull/1124) ([bensheldon](https://github.com/bensheldon))
+- Run all RSpec examples within a Rails Executor [\#1122](https://github.com/bensheldon/good_job/pull/1122) ([bensheldon](https://github.com/bensheldon))
+- Print better debugging for retained advisory locks in test [\#1121](https://github.com/bensheldon/good_job/pull/1121) ([bensheldon](https://github.com/bensheldon))
+- Replace Heroku-specific Rake tasks with `db:prepare` now that Demo is upgraded to Rails 7.1 [\#1120](https://github.com/bensheldon/good_job/pull/1120) ([bensheldon](https://github.com/bensheldon))
+- Do not error debug logs if `pg_stat_activity` join is empty [\#1119](https://github.com/bensheldon/good_job/pull/1119) ([bensheldon](https://github.com/bensheldon))
+- Remove pinned psych version [\#1114](https://github.com/bensheldon/good_job/pull/1114) ([bensheldon](https://github.com/bensheldon))
+- Remove `pg_advisory_unlock_all()` after job is run; only verify blank `finished_at` \(and not lock presence\) before performing job [\#1113](https://github.com/bensheldon/good_job/pull/1113) ([bensheldon](https://github.com/bensheldon))
+- Update docs url [\#1112](https://github.com/bensheldon/good_job/pull/1112) ([ur5us](https://github.com/ur5us))
+- Pin psych gem 5.1.0 [\#1108](https://github.com/bensheldon/good_job/pull/1108) ([bensheldon](https://github.com/bensheldon))
+- Add sampling for Skylight traces on Demo [\#1107](https://github.com/bensheldon/good_job/pull/1107) ([bensheldon](https://github.com/bensheldon))
+- Add Rails 7.1 to test matrix [\#1105](https://github.com/bensheldon/good_job/pull/1105) ([bensheldon](https://github.com/bensheldon))
+- Add spec to verify unhandled thread errors are reported [\#1104](https://github.com/bensheldon/good_job/pull/1104) ([bensheldon](https://github.com/bensheldon))
+- Update Codespace configuration [\#1101](https://github.com/bensheldon/good_job/pull/1101) ([bensheldon](https://github.com/bensheldon))
+
 ## [v3.19.4](https://github.com/bensheldon/good_job/tree/v3.19.4) (2023-10-04)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v3.19.3...v3.19.4)

data/README.md

@@ -939,7 +939,7 @@ By default, GoodJob creates a single thread execution pool that will execute job
 
     - `transactional_messages:2`: execute jobs enqueued on `transactional_messages`, with up to 2 threads.
     - `batch_processing:1` execute jobs enqueued on `batch_processing`, with a single thread.
-    - `-transactional_messages,batch_processing`: execute jobs enqueued on _any_ queue _excluding_ `transactional_messages` or `batch_processing`, with up to 2 threads.
+    - `-transactional_messages,batch_processing:2`: execute jobs enqueued on _any_ queue _excluding_ `transactional_messages` or `batch_processing`, with up to 2 threads.
     - `*`: execute jobs on any queue, with up to 5 threads (as configured by `--max-threads=5`).
 
     When a pool is performing jobs from multiple queues, jobs will be performed from specified queues, ordered by priority and creation time. To perform jobs from queues in the queues' given order, use the `+` modifier. In this example, jobs in `batch_processing` will be performed only when there are no jobs in `transactional_messages`:
@@ -1370,7 +1370,7 @@ bin/setup
 
 #### Rails development harness
 
-A Rails application exists within `spec/test_app` that is used for development, test, and GoodJob Demo environments.
+A Rails application exists within `demo` that is used for development, test, and GoodJob Demo environments.
 
 ```bash
 # Run a local development webserver

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

@@ -53,7 +53,7 @@ module GoodJob
         composed_cte = Arel::Nodes::As.new(cte_table, Arel::Nodes::SqlLiteral.new([cte_type, "(", cte_query.to_sql, ")"].join(' ')))
         query = cte_table.project(cte_table[:id])
                          .with(composed_cte)
-                         .where(Arel.sql(sanitize_sql_for_conditions(["#{function}(('x' || substr(md5(:table_name || '-' || #{connection.quote_table_name(cte_table.name)}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(64)::bigint)", { table_name: table_name }])))
+                         .where(Arel.sql("#{function}(('x' || substr(md5(#{connection.quote(table_name)} || '-' || #{connection.quote_table_name(cte_table.name)}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(64)::bigint)"))
 
         limit = original_query.arel.ast.limit
         query.limit = limit.value if limit.present?
@@ -74,14 +74,12 @@ module GoodJob
       # @example Get the records that have a session awaiting a lock:
       #   MyLockableRecord.joins_advisory_locks.where("pg_locks.granted = ?", false)
       scope :joins_advisory_locks, (lambda do |column: _advisory_lockable_column|
-        join_sql = <<~SQL.squish
+        joins(<<~SQL.squish)
           LEFT JOIN pg_locks ON pg_locks.locktype = 'advisory'
             AND pg_locks.objsubid = 1
-            AND pg_locks.classid = ('x' || substr(md5(:table_name || '-' || #{quoted_table_name}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(32)::int
-            AND pg_locks.objid = (('x' || substr(md5(:table_name || '-' || #{quoted_table_name}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(64) << 32)::bit(32)::int
+            AND pg_locks.classid = ('x' || substr(md5(#{connection.quote(table_name)} || '-' || #{quoted_table_name}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(32)::int
+            AND pg_locks.objid = (('x' || substr(md5(#{connection.quote(table_name)} || '-' || #{quoted_table_name}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(64) << 32)::bit(32)::int
         SQL
-
-        joins(sanitize_sql_for_conditions([join_sql, { table_name: table_name }]))
       end)
 
       # Joins the current query with Postgres's +pg_locks+ table AND SELECTs the resulting columns
@@ -151,6 +149,10 @@ module GoodJob
       # can (as in {Lockable.advisory_lock}) and only pass those that could be
       # locked to the block.
       #
+      # If the Active Record Relation has WHERE conditions that have the potential
+      # to be updated/changed elsewhere, be sure to verify the conditions are still
+      # satisfied, or check the lock status, as an unlocked and out-of-date record could be returned.
+      #
       # @param column [String, Symbol]  name of advisory lock or unlock function
       # @param function [String, Symbol] Postgres Advisory Lock function name to use
       # @param unlock_session [Boolean] Whether to unlock all advisory locks in the session afterwards

data/app/models/good_job/batch.rb

@@ -101,9 +101,13 @@ module GoodJob
 
       active_jobs = add(active_jobs, &block)
 
-      record.with_advisory_lock(function: "pg_advisory_lock") do
-        record.update!(enqueued_at: Time.current)
-        record._continue_discard_or_finish(lock: false)
+      Rails.application.reloader.wrap do
+        record.with_advisory_lock(function: "pg_advisory_lock") do
+          record.update!(enqueued_at: Time.current)
+
+          # During inline execution, this could enqueue and execute further jobs
+          record._continue_discard_or_finish(lock: false)
+        end
       end
 
       active_jobs

data/app/models/good_job/execution.rb

@@ -256,12 +256,13 @@ module GoodJob
     def self.perform_with_advisory_lock(parsed_queues: nil, queue_select_limit: nil)
       execution = nil
       result = nil
-      unfinished.dequeueing_ordered(parsed_queues).only_scheduled.limit(1).with_advisory_lock(unlock_session: true, select_limit: queue_select_limit) do |executions|
+      unfinished.dequeueing_ordered(parsed_queues).only_scheduled.limit(1).with_advisory_lock(select_limit: queue_select_limit) do |executions|
         execution = executions.first
         break if execution.blank?
 
         unless execution.executable?
           result = ExecutionResult.new(value: nil, unexecutable: true)
+          execution = nil
           break
         end
 
@@ -491,7 +492,9 @@ module GoodJob
     # Tests whether this job is safe to be executed by this thread.
     # @return [Boolean]
     def executable?
-      self.class.unscoped.unfinished.owns_advisory_locked.exists?(id: id)
+      reload.finished_at.blank?
+    rescue ActiveRecord::RecordNotFound
+      false
     end
 
     def make_discrete

data/app/views/good_job/processes/index.html.erb

@@ -8,6 +8,7 @@
       <div class="row small text-muted text-uppercase align-items-center">
         <div class="col"><%= t ".process" %></div>
         <div class="col"><%= t ".schedulers" %></div>
+        <div class="col-2 d-flex gap-2"><%= t ".cron_enabled" %></div>
         <div class="col-2 d-flex gap-2">
           <span><%= t ".started" %></span>
         </div>
@@ -44,6 +45,7 @@
               <pre class="mb-0"><%= scheduler.is_a?(Hash) ? scheduler['name'] : scheduler %></pre>
             <% end %>
           </div>
+          <div class="col-2 small"><%= t(ActiveModel::Type::Boolean.new.cast(process.state["cron_enabled"]), scope: "good_job.shared.boolean") %></div>
           <div class="col-2 small"><%= relative_time(process.created_at) %></div>
           <div class="col-2 small"><%= relative_time(process.updated_at) %></div>
           <div class="col-auto">

data/config/locales/de.yml

@@ -198,6 +198,7 @@ de:
             unit: ''
     processes:
       index:
+        cron_enabled: Cron aktiviert
         no_good_job_processes_found: Keine GoodJob-Prozesse gefunden.
         process: Verfahren
         schedulers: Planer
@@ -205,6 +206,9 @@ de:
         title: Prozesse
         updated: Aktualisiert
     shared:
+      boolean:
+        'false': Nein
+        'true': Ja
       error: Fehler
       filter:
         all: Alle

data/config/locales/en.yml

@@ -198,6 +198,7 @@ en:
             unit: ''
     processes:
       index:
+        cron_enabled: Cron enabled
         no_good_job_processes_found: No GoodJob processes found.
         process: Process
         schedulers: Schedulers
@@ -205,6 +206,9 @@ en:
         title: Processes
         updated: Updated
     shared:
+      boolean:
+        'false': 'No'
+        'true': 'Yes'
       error: Error
       filter:
         all: All

data/config/locales/es.yml

@@ -196,6 +196,7 @@ es:
             unit: ''
     processes:
       index:
+        cron_enabled: Cron habilitado
         no_good_job_processes_found: No hay procesos de GoodJob.
         process: Proceso
         schedulers: Schedulers
@@ -203,6 +204,9 @@ es:
         title: Procesos
         updated: Actualizado
     shared:
+      boolean:
+        'false': 'No'
+        'true': Sí
       error: Error
       filter:
         all: Todas

data/config/locales/fr.yml

@@ -198,6 +198,7 @@ fr:
             unit: ''
     processes:
       index:
+        cron_enabled: Cron activé
         no_good_job_processes_found: Aucun processus GoodJob trouvé.
         process: Processus
         schedulers: Schedulers
@@ -205,6 +206,9 @@ fr:
         title: Processus
         updated: Mis à jour
     shared:
+      boolean:
+        'false': Non
+        'true': Oui
       error: Erreur
       filter:
         all: Tous

data/config/locales/ja.yml

@@ -198,6 +198,7 @@ ja:
             unit: ''
     processes:
       index:
+        cron_enabled: Cron が有効になっている
         no_good_job_processes_found: GoodJobのプロセスが見つかりませんでした。
         process: プロセス
         schedulers: スケジューラー
@@ -205,6 +206,9 @@ ja:
         title: プロセス
         updated: 更新された
     shared:
+      boolean:
+        'false': いいえ
+        'true': はい
       error: エラー
       filter:
         all: 全て

data/config/locales/nl.yml

@@ -198,6 +198,7 @@ nl:
             unit: ''
     processes:
       index:
+        cron_enabled: Cron ingeschakeld
         no_good_job_processes_found: Geen GoodJob-processen gevonden.
         process: Proces
         schedulers: Planners
@@ -205,6 +206,9 @@ nl:
         title: Processen
         updated: Bijgewerkt
     shared:
+      boolean:
+        'false': Nee
+        'true': Ja
       error: Fout
       filter:
         all: Alle

data/config/locales/ru.yml

@@ -224,6 +224,7 @@ ru:
             unit: ''
     processes:
       index:
+        cron_enabled: Крон включен
         no_good_job_processes_found: Процессы GoodJob не найдены.
         process: Процесс
         schedulers: Планировщики
@@ -231,6 +232,9 @@ ru:
         title: Процессы
         updated: Обновлено
     shared:
+      boolean:
+        'false': Нет
+        'true': Да
       error: Ошибка
       filter:
         all: Все

data/config/locales/tr.yml

@@ -198,6 +198,7 @@ tr:
             unit: ''
     processes:
       index:
+        cron_enabled: Cron etkin
         no_good_job_processes_found: GoodJob süreci bulunamadı.
         process: Süreç
         schedulers: Planlayıcılar
@@ -205,6 +206,9 @@ tr:
         title: Süreçler
         updated: Güncellenmiş
     shared:
+      boolean:
+        'false': Hayır
+        'true': Evet
       error: Hata
       filter:
         all: Tümü

data/config/locales/uk.yml

@@ -224,6 +224,7 @@ uk:
             unit: ''
     processes:
       index:
+        cron_enabled: Cron увімкнено
         no_good_job_processes_found: Процеси GoodJob не знайдені.
         process: Процес
         schedulers: Планувальники
@@ -231,6 +232,9 @@ uk:
         title: Процеси
         updated: Оновлено
     shared:
+      boolean:
+        'false': Ні
+        'true': Так
       error: Помилка
       filter:
         all: Всі

data/lib/good_job/adapter.rb

@@ -49,74 +49,76 @@ module GoodJob
       active_jobs = Array(active_jobs)
       return 0 if active_jobs.empty?
 
-      current_time = Time.current
-      executions = active_jobs.map do |active_job|
-        GoodJob::Execution.build_for_enqueue(active_job).tap do |execution|
-          if GoodJob::Execution.discrete_support?
-            execution.make_discrete
-            execution.scheduled_at = current_time if execution.scheduled_at == execution.created_at
-          end
+      Rails.application.reloader.wrap do
+        current_time = Time.current
+        executions = active_jobs.map do |active_job|
+          GoodJob::Execution.build_for_enqueue(active_job).tap do |execution|
+            if GoodJob::Execution.discrete_support?
+              execution.make_discrete
+              execution.scheduled_at = current_time if execution.scheduled_at == execution.created_at
+            end
 
-          execution.created_at = current_time
-          execution.updated_at = current_time
+            execution.created_at = current_time
+            execution.updated_at = current_time
+          end
         end
-      end
 
-      inline_executions = []
-      GoodJob::Execution.transaction(requires_new: true, joinable: false) do
-        execution_attributes = executions.map do |execution|
-          if GoodJob::Execution.error_event_migrated?
-            execution.attributes
-          else
-            execution.attributes.except('error_event')
+        inline_executions = []
+        GoodJob::Execution.transaction(requires_new: true, joinable: false) do
+          execution_attributes = executions.map do |execution|
+            if GoodJob::Execution.error_event_migrated?
+              execution.attributes
+            else
+              execution.attributes.except('error_event')
+            end
           end
-        end
 
-        results = GoodJob::Execution.insert_all(execution_attributes, returning: %w[id active_job_id]) # rubocop:disable Rails/SkipsModelValidations
+          results = GoodJob::Execution.insert_all(execution_attributes, returning: %w[id active_job_id]) # rubocop:disable Rails/SkipsModelValidations
 
-        job_id_to_provider_job_id = results.each_with_object({}) { |result, hash| hash[result['active_job_id']] = result['id'] }
-        active_jobs.each do |active_job|
-          active_job.provider_job_id = job_id_to_provider_job_id[active_job.job_id]
-          active_job.successfully_enqueued = active_job.provider_job_id.present? if active_job.respond_to?(:successfully_enqueued=)
-        end
-        executions.each do |execution|
-          execution.instance_variable_set(:@new_record, false) if job_id_to_provider_job_id[execution.active_job_id]
-        end
-        executions = executions.select(&:persisted?) # prune unpersisted executions
+          job_id_to_provider_job_id = results.each_with_object({}) { |result, hash| hash[result['active_job_id']] = result['id'] }
+          active_jobs.each do |active_job|
+            active_job.provider_job_id = job_id_to_provider_job_id[active_job.job_id]
+            active_job.successfully_enqueued = active_job.provider_job_id.present? if active_job.respond_to?(:successfully_enqueued=)
+          end
+          executions.each do |execution|
+            execution.instance_variable_set(:@new_record, false) if job_id_to_provider_job_id[execution.active_job_id]
+          end
+          executions = executions.select(&:persisted?) # prune unpersisted executions
 
-        if execute_inline?
-          inline_executions = executions.select { |execution| (execution.scheduled_at.nil? || execution.scheduled_at <= Time.current) }
-          inline_executions.each(&:advisory_lock!)
+          if execute_inline?
+            inline_executions = executions.select { |execution| (execution.scheduled_at.nil? || execution.scheduled_at <= Time.current) }
+            inline_executions.each(&:advisory_lock!)
+          end
         end
-      end
 
-      begin
-        until inline_executions.empty?
-          begin
-            inline_execution = inline_executions.shift
-            inline_result = inline_execution.perform
-          ensure
-            inline_execution.advisory_unlock
-            inline_execution.run_callbacks(:perform_unlocked)
+        begin
+          until inline_executions.empty?
+            begin
+              inline_execution = inline_executions.shift
+              inline_result = inline_execution.perform
+            ensure
+              inline_execution.advisory_unlock
+              inline_execution.run_callbacks(:perform_unlocked)
+            end
+            raise inline_result.unhandled_error if inline_result.unhandled_error
           end
-          raise inline_result.unhandled_error if inline_result.unhandled_error
+        ensure
+          inline_executions.each(&:advisory_unlock)
         end
-      ensure
-        inline_executions.each(&:advisory_unlock)
-      end
 
-      non_inline_executions = executions.reject(&:finished_at)
-      if non_inline_executions.any?
-        job_id_to_active_jobs = active_jobs.index_by(&:job_id)
-        non_inline_executions.group_by(&:queue_name).each do |queue_name, executions_by_queue|
-          executions_by_queue.group_by(&:scheduled_at).each do |scheduled_at, executions_by_queue_and_scheduled_at|
-            state = { queue_name: queue_name, count: executions_by_queue_and_scheduled_at.size }
-            state[:scheduled_at] = scheduled_at if scheduled_at
-
-            executed_locally = execute_async? && @capsule&.create_thread(state)
-            unless executed_locally
-              state[:count] = job_id_to_active_jobs.values_at(*executions_by_queue_and_scheduled_at.map(&:active_job_id)).count { |active_job| send_notify?(active_job) }
-              Notifier.notify(state) unless state[:count].zero?
+        non_inline_executions = executions.reject(&:finished_at)
+        if non_inline_executions.any?
+          job_id_to_active_jobs = active_jobs.index_by(&:job_id)
+          non_inline_executions.group_by(&:queue_name).each do |queue_name, executions_by_queue|
+            executions_by_queue.group_by(&:scheduled_at).each do |scheduled_at, executions_by_queue_and_scheduled_at|
+              state = { queue_name: queue_name, count: executions_by_queue_and_scheduled_at.size }
+              state[:scheduled_at] = scheduled_at if scheduled_at
+
+              executed_locally = execute_async? && @capsule&.create_thread(state)
+              unless executed_locally
+                state[:count] = job_id_to_active_jobs.values_at(*executions_by_queue_and_scheduled_at.map(&:active_job_id)).count { |active_job| send_notify?(active_job) }
+                Notifier.notify(state) unless state[:count].zero?
+              end
             end
           end
         end
@@ -137,40 +139,42 @@ module GoodJob
       # job there to be enqueued using enqueue_all
       return if GoodJob::Bulk.capture(active_job, queue_adapter: self)
 
-      will_execute_inline = execute_inline? && (scheduled_at.nil? || scheduled_at <= Time.current)
-      execution = GoodJob::Execution.enqueue(
-        active_job,
-        scheduled_at: scheduled_at,
-        create_with_advisory_lock: will_execute_inline
-      )
+      Rails.application.reloader.wrap do
+        will_execute_inline = execute_inline? && (scheduled_at.nil? || scheduled_at <= Time.current)
+        execution = GoodJob::Execution.enqueue(
+          active_job,
+          scheduled_at: scheduled_at,
+          create_with_advisory_lock: will_execute_inline
+        )
 
-      if will_execute_inline
-        begin
-          result = execution.perform
-        ensure
-          execution.advisory_unlock
-          execution.run_callbacks(:perform_unlocked)
+        if will_execute_inline
+          begin
+            result = execution.perform
+          ensure
+            execution.advisory_unlock
+            execution.run_callbacks(:perform_unlocked)
+          end
+          raise result.unhandled_error if result.unhandled_error
+        else
+          job_state = { queue_name: execution.queue_name }
+          job_state[:scheduled_at] = execution.scheduled_at if execution.scheduled_at
+
+          executed_locally = execute_async? && @capsule&.create_thread(job_state)
+          Notifier.notify(job_state) if !executed_locally && send_notify?(active_job)
         end
-        raise result.unhandled_error if result.unhandled_error
-      else
-        job_state = { queue_name: execution.queue_name }
-        job_state[:scheduled_at] = execution.scheduled_at if execution.scheduled_at
 
-        executed_locally = execute_async? && @capsule&.create_thread(job_state)
-        Notifier.notify(job_state) if !executed_locally && send_notify?(active_job)
+        execution
       end
-
-      execution
     end
 
     # Shut down the thread pool executors.
-    # @param timeout [nil, Numeric, Symbol] Seconds to wait for active threads.
+    # @param timeout [nil, Numeric, NONE] Seconds to wait for active threads.
     #   * +nil+ trigger a shutdown but not wait for it to complete.
     #   * +-1+ wait until the shutdown is complete.
     #   * +0+ immediately shutdown and stop any threads.
     #   * A positive number will wait that many seconds before stopping any remaining active threads.
     # @return [void]
-    def shutdown(timeout: :default)
+    def shutdown(timeout: NONE)
       @capsule&.shutdown(timeout: timeout)
       @_async_started = false
     end

data/lib/good_job/capsule.rb

@@ -44,23 +44,23 @@ module GoodJob
     end
 
     # Shut down the thread pool executors.
-    # @param timeout [nil, Numeric, Symbol] Seconds to wait for active threads.
+    # @param timeout [nil, Numeric, NONE] Seconds to wait for active threads.
     #   * +-1+ will wait for all active threads to complete.
     #   * +0+ will interrupt active threads.
     #   * +N+ will wait at most N seconds and then interrupt active threads.
     #   * +nil+ will trigger a shutdown but not wait for it to complete.
     # @return [void]
-    def shutdown(timeout: :default)
-      timeout = @configuration.shutdown_timeout if timeout == :default
+    def shutdown(timeout: NONE)
+      timeout = @configuration.shutdown_timeout if timeout == NONE
       GoodJob._shutdown_all([@shared_executor, @notifier, @poller, @scheduler, @cron_manager].compact, timeout: timeout)
       @startable = false
       @running = false
     end
 
     # Shutdown and then start the capsule again.
-    # @param timeout [Numeric, Symbol] Seconds to wait for active threads.
+    # @param timeout [Numeric, NONE] Seconds to wait for active threads.
     # @return [void]
-    def restart(timeout: :default)
+    def restart(timeout: NONE)
       raise ArgumentError, "Capsule#restart cannot be called with a timeout of nil" if timeout.nil?
 
       shutdown(timeout: timeout)

data/lib/good_job/cli.rb

@@ -17,6 +17,9 @@ module GoodJob
     # Requiring this loads the application's configuration and classes.
     RAILS_ENVIRONMENT_RB = File.expand_path("config/environment.rb")
 
+    # Number of seconds between checking shutdown conditions
+    SHUTDOWN_EVENT_TIMEOUT = 10
+
     class << self
       # Whether the CLI is running from the executable
       # @return [Boolean, nil]
@@ -106,14 +109,15 @@ module GoodJob
         probe_server.start
       end
 
-      @stop_good_job_executable = false
+      require 'concurrent/atomic/event'
+      @stop_good_job_executable = Concurrent::Event.new
       %w[INT TERM].each do |signal|
-        trap(signal) { @stop_good_job_executable = true }
+        trap(signal) { Thread.new { @stop_good_job_executable.set }.join }
       end
 
       Kernel.loop do
-        sleep 0.1
-        break if @stop_good_job_executable || capsule.shutdown?
+        @stop_good_job_executable.wait(SHUTDOWN_EVENT_TIMEOUT)
+        break if @stop_good_job_executable.set? || capsule.shutdown?
       end
 
       systemd.stop do

data/lib/good_job/version.rb

@@ -2,7 +2,7 @@
 
 module GoodJob
   # GoodJob gem version.
-  VERSION = '3.19.4'
+  VERSION = '3.21.0'
 
   # GoodJob version as Gem::Version object
   GEM_VERSION = Gem::Version.new(VERSION)

data/lib/good_job.rb

@@ -42,6 +42,10 @@ require "good_job/systemd_service"
 module GoodJob
   include GoodJob::Dependencies
 
+  # Default, null, blank value placeholder.
+  NONE = Module.new.freeze
+
+  # Default logger for GoodJob; overridden by Rails.logger in Railtie.
   DEFAULT_LOGGER = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new($stdout))
 
   # @!attribute [rw] active_record_parent_class
@@ -233,13 +237,19 @@ module GoodJob
   # This is primarily intended for usage in a test environment.
   # Unhandled job errors will be raised.
   # @param queue_string [String] Queues to execute jobs from
+  # @param limit [Integer, nil] Maximum number of iterations for the loop
   # @return [void]
-  def self.perform_inline(queue_string = "*")
+  def self.perform_inline(queue_string = "*", limit: nil)
     job_performer = JobPerformer.new(queue_string)
+    iteration = 0
     loop do
-      result = job_performer.next
+      break if limit && iteration >= limit
+
+      result = Rails.application.reloader.wrap { job_performer.next }
       break unless result
       raise result.unhandled_error if result.unhandled_error
+
+      iteration += 1
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 3.19.4
+  version: 3.21.0
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-10-04 00:00:00.000000000 Z
+date: 2023-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -384,7 +384,7 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/bensheldon/good_job/issues
   changelog_uri: https://github.com/bensheldon/good_job/blob/master/CHANGELOG.md
-  documentation_uri: https://rdoc.info/github/bensheldon/good_job
+  documentation_uri: https://rubydoc.info/gems/good_job
   homepage_uri: https://github.com/bensheldon/good_job
   source_code_uri: https://github.com/bensheldon/good_job
   rubygems_mfa_required: 'true'