good_job 4.18.2 → 4.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d2eb2f4b216901a3f6abb9197facd9d9738c13fa4b61fcca2ec3ef4f2b64a6a
-  data.tar.gz: 7324f38c349116f108cbf216bffdc1207c2f0fd06ff136b7c0f0a8e0059d16a3
+  metadata.gz: d91dd892cc8a4110a371e8539b48200a20bb34bdbb08c3f5adc19ae96d2a9374
+  data.tar.gz: bea93501defb6c13acb563afced0a7ac340ce58f0567ad12143a7e82fbfd282f
 SHA512:
-  metadata.gz: 62c30d3afcfa5c7f697f5b156cdced9cf45757f2e05e5e53657fbdf11c1fb0bab0e0e63dad516206737e697bb39d3985c4d0b2fcfb0933c6225fc724a6aca4c7
-  data.tar.gz: 0d5174c12282329ec248573bfd28a0a86538f7b65b94bf9918c7434bce691a43711017e595b47afb3e200125df5fc33c63b307a545c3d1c7ffd2eb11405741af
+  metadata.gz: 2e4b30ddb0ef27b8409325dc98b775a46cb8398d5422c6387917f7d22df81ef5b5206ea4c23c9f8c2d9fd4e56b8ed0c27a46d26a021296e5f7c656ecb9ada865
+  data.tar.gz: 316857dc028b6d98db33e26fd68e5246659f0e79a92ae6fd923726e84770f8c069ef80ee73efdf608d478d4ed107f85a4afd4a0a45deb8145ed1147e43a9bf8a

data/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## [v4.19.0](https://github.com/bensheldon/good_job/tree/v4.19.0) (2026-05-27)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v4.18.2...v4.19.0)
+
+**Implemented enhancements:**
+
+- Truncate long labels in dashboard badges [\#1766](https://github.com/bensheldon/good_job/pull/1766) ([MahmoudBakr23](https://github.com/MahmoudBakr23))
+- Set default queue\_select\_limit to 1000 [\#1762](https://github.com/bensheldon/good_job/pull/1762) ([MahmoudBakr23](https://github.com/MahmoudBakr23))
+
+**Fixed bugs:**
+
+- Use table\_name instead of hardcoding :good\_jobs in schema introspection [\#1774](https://github.com/bensheldon/good_job/pull/1774) ([eidarus](https://github.com/eidarus))
+- Fix incorrect ENV variable guard for GOOD\_JOB\_ENABLE\_PAUSES [\#1772](https://github.com/bensheldon/good_job/pull/1772) ([jqr](https://github.com/jqr))
+- Fix `PG::ProgramLimitExceeded` in jobs index search for large error payloads [\#1769](https://github.com/bensheldon/good_job/pull/1769) ([createdbypete](https://github.com/createdbypete))
+- Fix PG::AmbiguousColumn in skiplocked/hybrid claim with ordered queues + concurrency rules [\#1768](https://github.com/bensheldon/good_job/pull/1768) ([createdbypete](https://github.com/createdbypete))
+- Make execution state completely Fiber-safe via Rails isolated execution state [\#1765](https://github.com/bensheldon/good_job/pull/1765) ([ollym](https://github.com/ollym))
+- Handle nil updated\_at in stale? method [\#1764](https://github.com/bensheldon/good_job/pull/1764) ([gavinballard](https://github.com/gavinballard))
+
+**Closed issues:**
+
+- enable\_pauses ENV var check has singular/plural mismatch [\#1771](https://github.com/bensheldon/good_job/issues/1771)
+- Raises `PG::AmbiguousColumn` under hybrid lock strategy on ordered queues with throttle [\#1767](https://github.com/bensheldon/good_job/issues/1767)
+- Handle long labels more gracefully [\#1674](https://github.com/bensheldon/good_job/issues/1674)
+- Drop Duplicate index [\#1661](https://github.com/bensheldon/good_job/issues/1661)
+- Job runner process enters a loop on create\_listen\_task - stale check fails [\#1649](https://github.com/bensheldon/good_job/issues/1649)
+- Set a default queue\_select\_limit [\#1596](https://github.com/bensheldon/good_job/issues/1596)
+
+**Merged pull requests:**
+
+- Prune CI test matrix to boundary Ruby versions per Rails version [\#1777](https://github.com/bensheldon/good_job/pull/1777) ([bensheldon](https://github.com/bensheldon))
+- Refactor Concurrency::Rule to use explicit ivars instead of options hash [\#1776](https://github.com/bensheldon/good_job/pull/1776) ([bensheldon](https://github.com/bensheldon))
+- Fix typo in README.md [\#1773](https://github.com/bensheldon/good_job/pull/1773) ([NobodysNightmare](https://github.com/NobodysNightmare))
+- Use explicit keyword arguments for concurrency controls [\#1770](https://github.com/bensheldon/good_job/pull/1770) ([bdewater-thatch](https://github.com/bdewater-thatch))
+
 ## [v4.18.2](https://github.com/bensheldon/good_job/tree/v4.18.2) (2026-04-20)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v4.18.1...v4.18.2)
@@ -83,10 +117,6 @@
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v4.16.0...v4.17.0)
 
-**Implemented enhancements:**
-
-- Introduce advisory lock key customization support methods [\#1722](https://github.com/bensheldon/good_job/pull/1722) ([amkisko](https://github.com/amkisko))
-
 **Merged pull requests:**
 
 - Convert UI JavaScript modules to Stimulus controllers [\#1743](https://github.com/bensheldon/good_job/pull/1743) ([bensheldon](https://github.com/bensheldon))
@@ -102,11 +132,6 @@
 - Allow filtering by label on dashboard [\#1739](https://github.com/bensheldon/good_job/pull/1739) ([bensheldon](https://github.com/bensheldon))
 - Allow multiple concurrency rules per job via labels [\#1700](https://github.com/bensheldon/good_job/pull/1700) ([bscofield](https://github.com/bscofield))
 
-**Fixed bugs:**
-
-- Fix advisory lock connection stickiness in block contexts [\#1736](https://github.com/bensheldon/good_job/pull/1736) ([bensheldon](https://github.com/bensheldon))
-- Add JRuby 10 to testing matrix [\#1559](https://github.com/bensheldon/good_job/pull/1559) ([bensheldon](https://github.com/bensheldon))
-
 **Closed issues:**
 
 - Job duration misreported if interrupted [\#1723](https://github.com/bensheldon/good_job/issues/1723)
@@ -116,7 +141,6 @@
 - Use annotated git tag in release script [\#1741](https://github.com/bensheldon/good_job/pull/1741) ([bensheldon](https://github.com/bensheldon))
 - Double single-thread scheduler integration test timeout on JRuby [\#1738](https://github.com/bensheldon/good_job/pull/1738) ([bensheldon](https://github.com/bensheldon))
 - Fix JRuby test flakes for scheduler timeout and interrupted execution duration [\#1737](https://github.com/bensheldon/good_job/pull/1737) ([bensheldon](https://github.com/bensheldon))
-- Count Advisory Locks and refactor advisory lock lifecycle [\#1735](https://github.com/bensheldon/good_job/pull/1735) ([bensheldon](https://github.com/bensheldon))
 - Show interrupted execution recovery duration in dashboard [\#1733](https://github.com/bensheldon/good_job/pull/1733) ([bensheldon](https://github.com/bensheldon))
 - chore: use `merge` to avoid mutate the query object [\#1717](https://github.com/bensheldon/good_job/pull/1717) ([luizkowalski](https://github.com/luizkowalski))
 
@@ -132,7 +156,6 @@
 
 **Merged pull requests:**
 
-- Fix JRuby in development lockfile, with test [\#1734](https://github.com/bensheldon/good_job/pull/1734) ([bensheldon](https://github.com/bensheldon))
 - Add herb to linter [\#1732](https://github.com/bensheldon/good_job/pull/1732) ([bensheldon](https://github.com/bensheldon))
 - Update development dependencies; apply Rubocop to\_h lints [\#1728](https://github.com/bensheldon/good_job/pull/1728) ([bensheldon](https://github.com/bensheldon))
 
@@ -194,7 +217,6 @@
 
 **Fixed bugs:**
 
-- Check for graceful shutdown inside job cleanup loops [\#1711](https://github.com/bensheldon/good_job/pull/1711) ([bdewater-thatch](https://github.com/bdewater-thatch))
 - Add title to Good Job Dashboard layout [\#1701](https://github.com/bensheldon/good_job/pull/1701) ([mockdeep](https://github.com/mockdeep))
 
 **Closed issues:**
@@ -290,7 +312,6 @@
 **Merged pull requests:**
 
 - Update sorbet/tapioca [\#1681](https://github.com/bensheldon/good_job/pull/1681) ([bensheldon](https://github.com/bensheldon))
-- Remove obsolete property from tests [\#1676](https://github.com/bensheldon/good_job/pull/1676) ([RDIL](https://github.com/RDIL))
 - Bump actions/checkout from 4 to 5 [\#1673](https://github.com/bensheldon/good_job/pull/1673) ([dependabot[bot]](https://github.com/apps/dependabot))
 
 ## [v4.11.2](https://github.com/bensheldon/good_job/tree/v4.11.2) (2025-08-06)
@@ -413,10 +434,6 @@
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v4.9.0...v4.9.1)
 
-**Implemented enhancements:**
-
-- Order Dashboard jobs in more "natural" order [\#1604](https://github.com/bensheldon/good_job/pull/1604) ([francois](https://github.com/francois))
-
 **Fixed bugs:**
 
 - \[dashboard\] Scheduled tasks are shown "backwards" [\#1580](https://github.com/bensheldon/good_job/issues/1580)
@@ -3015,7 +3032,6 @@
 
 **Fixed bugs:**
 
-- Transactions in "aborting" threads do not commit; causes GoodJob::Process record not destroyed on exit [\#489](https://github.com/bensheldon/good_job/issues/489)
 - Deserialize ActiveJob arguments when manually retrying a job [\#513](https://github.com/bensheldon/good_job/pull/513) ([bensheldon](https://github.com/bensheldon))
 
 **Closed issues:**

data/README.md

@@ -726,7 +726,7 @@ config.good_job.cron = {
 
 ### Bulk enqueue
 
-GoodJob's Bulk-enqueue functionality can buffer and enqueue multiple jobs at once, using a single INSERT statement. This can more performant when enqueuing a large number of jobs.
+GoodJob's Bulk-enqueue functionality can buffer and enqueue multiple jobs at once, using a single INSERT statement. This can be more performant when enqueuing a large number of jobs.
 
 ```ruby
 # Capture jobs using `.perform_later`:
@@ -1292,7 +1292,7 @@ The recommended way to monitor the queue in production is:
 
 GoodJob’s advisory locking strategy uses a materialized CTE (Common Table Expression). This strategy can be non-performant when querying a very large queue of executable jobs (100,000+) because the database query must materialize all executable jobs before acquiring an advisory lock.
 
-GoodJob offers an optional optimization to limit the number of jobs that are queried: Queue Select Limit.
+GoodJob's Queue Select Limit restricts how many jobs are materialized per advisory lock cycle. **It defaults to `1000` — no configuration needed.** Override it if your deployment requires a different value:
 
 ```none
 # CLI option
@@ -1305,7 +1305,7 @@ config.good_job.queue_select_limit = 1000
 GOOD_JOB_QUEUE_SELECT_LIMIT=1000
 ```
 
-The Queue Select Limit value should be set to a rough upper-bound that exceeds all GoodJob execution threads / database connections. `1000` is a number that likely exceeds the available database connections on most PaaS offerings, but still offers a performance boost for GoodJob when executing very large queues.
+The default of `1000` is a rough upper-bound that exceeds the available database connections on most PaaS offerings, while still offering a significant performance boost for GoodJob when executing very large queues.
 
 To explain where this value is used, here is the pseudo-query that GoodJob uses to find executable jobs:
 
@@ -1318,7 +1318,7 @@ To explain where this value is used, here is the pseudo-query that GoodJob uses
       FROM good_jobs
       WHERE (scheduled_at <= NOW() OR scheduled_at IS NULL) AND finished_at IS NULL
       ORDER BY priority DESC NULLS LAST, created_at ASC
-      [LIMIT 1000] -- <= introduced when queue_select_limit is set
+      [LIMIT 1000] -- <= applied by default; configurable via queue_select_limit
     )
     SELECT id
     FROM rows

data/app/frontend/good_job/modules/bootstrap_init.js

@@ -15,7 +15,14 @@ function setupPopovers() {
   })
 }
 
+function setupTooltips() {
+  document.querySelectorAll('[data-bs-toggle="tooltip"]').forEach((el) => {
+    new bootstrap.Tooltip(el)
+  })
+}
+
 window.document.addEventListener("turbo:load", function() {
   showToasts();
   setupPopovers();
+  setupTooltips();
 });

data/app/frontend/good_job/style.css

@@ -1,24 +1,3 @@
-.tooltip {
-  position: absolute;
-  z-index: 1;
-  padding: 5px;
-  background: rgba(0, 0, 0, 0.3);
-  opacity: 1;
-  border-radius: 3px;
-  text-align: center;
-  pointer-events: none;
-  color: white;
-  transition: opacity .1s ease-out;
-}
-
-.tooltip.tooltip-hidden {
-  opacity: 0;
-}
-
-.ct-label.ct-horizontal {
-  white-space: nowrap;
-}
-
 .chart-wrapper {
   position: relative;
   height: 200px;

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

@@ -5,6 +5,11 @@ module GoodJob
   module Filterable
     extend ActiveSupport::Concern
 
+    # Caps the largest free-form columns (error, serialized_params->>'arguments')
+    # fed to to_tsvector() so the combined tsvector stays under PG's ~1 MB limit
+    # (PG::ProgramLimitExceeded: "string is too long for tsvector").
+    MAX_SEARCH_COLUMN_CHARS = 262_144
+
     included do
       # Get records in display order with optional keyset pagination.
       # @!method display_all(ordered_by: ["created_at", "desc"], after_at: nil, after_id: nil)
@@ -65,7 +70,16 @@ module GoodJob
         next if query.blank?
 
         # TODO: turn this into proper bind parameters in Arel
-        tsvector = "(to_tsvector('english', id::text) || to_tsvector('english', COALESCE(active_job_id::text, '')) || to_tsvector('english', serialized_params) || to_tsvector('english', COALESCE(serialized_params->>'arguments', '')) || to_tsvector('english', COALESCE(error, '')) || to_tsvector('english', COALESCE(array_to_string(labels, ' '), '')))"
+        tsvector = <<~SQL.squish
+          (
+            to_tsvector('english', id::text) ||
+            to_tsvector('english', COALESCE(active_job_id::text, '')) ||
+            to_tsvector('english', serialized_params) ||
+            to_tsvector('english', COALESCE(LEFT(serialized_params->>'arguments', #{MAX_SEARCH_COLUMN_CHARS}), '')) ||
+            to_tsvector('english', COALESCE(LEFT(error, #{MAX_SEARCH_COLUMN_CHARS}), '')) ||
+            to_tsvector('english', COALESCE(array_to_string(labels, ' '), ''))
+          )
+        SQL
         to_tsquery_function = database_supports_websearch_to_tsquery? ? 'websearch_to_tsquery' : 'plainto_tsquery'
         where("#{tsvector} @@ #{to_tsquery_function}('english', CAST(? AS text))", query)
           .order(sanitize_sql_for_order([Arel.sql("ts_rank(#{tsvector}, #{to_tsquery_function}('english', CAST(? AS text)))"), query]) => 'DESC')

data/app/models/good_job/job/lockable.rb

@@ -59,7 +59,7 @@ module GoodJob
           record = unscoped.find_by_sql([sql, locked_by_id, locked_at, lock_types[lock_type.to_s]]).first
 
           begin
-            yield(record)
+            unscoped { yield(record) }
           ensure
             record.update(locked_by_id: nil, locked_at: nil, lock_type: nil) if record && !record.destroyed? && record.locked_by_id.present?
             record&.run_callbacks(:perform_unlocked)
@@ -103,7 +103,7 @@ module GoodJob
           record_advisory_lock(lease_connection, record.lockable_column_key, cte: true) if record
 
           begin
-            yield(record)
+            unscoped { yield(record) }
           ensure
             if record
               record.advisory_unlock

data/app/models/good_job/job.rb

@@ -187,8 +187,9 @@ module GoodJob
     # @param queues [Array<string] ordered names of queues
     # @return [ActiveRecord::Relation]
     scope :queue_ordered, (lambda do |queues|
+      qualified_queue_name = "#{quoted_table_name}.#{adapter_class.quote_column_name('queue_name')}"
       clauses = queues.map.with_index do |queue_name, index|
-        sanitize_sql_array(["WHEN queue_name = ? THEN ?", queue_name, index])
+        sanitize_sql_array(["WHEN #{qualified_queue_name} = ? THEN ?", queue_name, index])
       end
       order(Arel.sql("(CASE #{clauses.join(' ')} ELSE #{queues.size} END)"))
     end)
@@ -286,14 +287,14 @@ module GoodJob
       end
 
       def historic_finished_at_index_migrated?
-        return true if connection.index_name_exists?(:good_jobs, "index_good_jobs_on_queue_name_priority_scheduled_at_unfinished")
+        return true if connection.index_name_exists?(table_name, "index_good_jobs_on_queue_name_priority_scheduled_at_unfinished")
 
         migration_pending_warning!
         false
       end
 
       def lock_type_migrated?
-        return true if connection.index_name_exists?(:good_jobs, :index_good_jobs_for_candidate_dequeue_unlocked)
+        return true if connection.index_name_exists?(table_name, :index_good_jobs_for_candidate_dequeue_unlocked)
 
         migration_pending_warning!
         false
@@ -305,7 +306,7 @@ module GoodJob
       def lock_type_column_exists?
         return @_lock_type_column_exists if defined?(@_lock_type_column_exists)
 
-        @_lock_type_column_exists = connection_pool.with_connection { |conn| conn.column_exists?(:good_jobs, :lock_type) }
+        @_lock_type_column_exists = connection_pool.with_connection { |conn| conn.column_exists?(table_name, :lock_type) }
       end
 
       def reset_column_information

data/app/models/good_job/process.rb

@@ -151,6 +151,8 @@ module GoodJob # :nodoc:
     end
 
     def stale?
+      return true if updated_at.nil?
+
       updated_at < STALE_INTERVAL.ago
     end
 

data/app/views/good_job/batches/_jobs.erb

@@ -37,7 +37,8 @@
               <div class="col-4 col-lg-1 text-lg-end">
                 <div class="d-lg-none small text-muted mt-1"><%= t "good_job.models.job.labels" %></div>
                 <% job.labels&.each do |label| %>
-                  <span class="badge rounded-pill text-bg-secondary font-monospace"><%= label %></span>
+                  <% truncated_label = truncate(label, length: 15) %>
+                  <%= tag.span truncated_label, class: "badge rounded-pill text-bg-secondary font-monospace", **(truncated_label == label ? {} : { title: label, data: { bs_toggle: "tooltip" } }) %>
                 <% end %>
               </div>
               <div class="col-4 col-lg-1 text-lg-end">

data/app/views/good_job/jobs/_table.erb

@@ -104,7 +104,8 @@
               <div class="col-4 col-lg-1 text-wrap text-lg-end">
                 <div class="d-lg-none small text-muted mt-1"><%= t "good_job.models.job.labels" %></div>
                 <% job.labels&.each do |label| %>
-                  <%= link_to label, filter.to_params(label: label), class: "badge rounded-pill text-bg-secondary font-monospace text-decoration-none" %>
+                  <% truncated_label = truncate(label, length: 15) %>
+                  <%= link_to truncated_label, filter.to_params(label: label), class: "badge rounded-pill text-bg-secondary font-monospace text-decoration-none", **(truncated_label == label ? {} : { title: label, data: { bs_toggle: "tooltip" } }) %>
                 <% end %>
               </div>
               <div class="col-4 col-lg-1 text-lg-end">

data/config/brakeman.ignore

@@ -90,25 +90,25 @@
     {
       "warning_type": "SQL Injection",
       "warning_code": 0,
-      "fingerprint": "c837568c590d9608a8bb9927b31b9597aaacc72053b6482e1a54bd02aa0dd2d7",
+      "fingerprint": "c57f2525e5d0780a0bcb460502f1b3ebceb9992885466f45b4035ab670c628d9",
       "check_name": "SQL",
       "message": "Possible SQL injection",
       "file": "app/models/good_job/job.rb",
-      "line": 162,
+      "line": 194,
       "link": "https://brakemanscanner.org/docs/warning_types/sql_injection/",
-      "code": "Arel.sql(\"(CASE #{queues.map.with_index do\n sanitize_sql_array([\"WHEN queue_name = ? THEN ?\", queue_name, index])\n end.join(\" \")} ELSE #{queues.size} END)\")",
+      "code": "Arel.sql(\"(CASE #{queues.map.with_index do\n sanitize_sql_array([\"WHEN #{\"#{quoted_table_name}.#{adapter_class.quote_column_name(\"queue_name\")}\"} = ? THEN ?\", queue_name, index])\n end.join(\" \")} ELSE #{queues.size} END)\")",
       "render_path": null,
       "location": {
         "type": "method",
         "class": "Job",
         "method": null
       },
-      "user_input": "queues.map.with_index do\n sanitize_sql_array([\"WHEN queue_name = ? THEN ?\", queue_name, index])\n end.join(\" \")",
+      "user_input": "queues.map.with_index do\n sanitize_sql_array([\"WHEN #{\"#{quoted_table_name}.#{adapter_class.quote_column_name(\"queue_name\")}\"} = ? THEN ?\", queue_name, index])\n end.join(\" \")",
       "confidence": "Medium",
       "cwe_id": [
         89
       ],
-      "note": "Developer provided value, queue_name, is sanitized."
+      "note": "Developer provided value, queue_name, is sanitized; identifier is quoted via Rails quoted_table_name and quote_column_name."
     },
     {
       "warning_type": "Command Injection",

data/lib/good_job/active_job_extensions/concurrency.rb

@@ -16,52 +16,66 @@ module GoodJob
       ThrottleExceededError = Class.new(ConcurrencyExceededError)
 
       class Rule
+        attr_reader :label, :total_limit, :enqueue_limit, :perform_limit, :enqueue_throttle, :perform_throttle
+
         def initialize(config)
-          @config = config
+          @label = config[:label]
+          @key = config.key?(:key) ? config[:key] : GoodJob::NONE
+          @total_limit = config[:total_limit]
+          @enqueue_limit = config[:enqueue_limit]
+          @perform_limit = config[:perform_limit]
+          @enqueue_throttle = config[:enqueue_throttle]
+          @perform_throttle = config[:perform_throttle]
+        end
+
+        def key
+          @key.equal?(GoodJob::NONE) ? nil : @key
         end
 
         def evaluate(job, stage)
-          key = key(job)
-          label = label(job)
-          return nil if key.blank? && label.blank?
+          resolved_key = resolve_key(job)
+          resolved_label = resolve_label(job)
+          return nil if resolved_key.blank? && resolved_label.blank?
 
           if stage == :enqueue
-            enqueue_limit = limit(job, :enqueue_limit) || limit(job, :total_limit)
-            enqueue_throttle = throttle(job, :enqueue_throttle)
+            enqueue_limit = resolve_limit(job, @enqueue_limit) || resolve_limit(job, @total_limit)
+            enqueue_throttle = resolve_throttle(job, @enqueue_throttle)
             return nil unless enqueue_limit || enqueue_throttle
 
-            check_enqueue(enqueue_limit, enqueue_throttle, job, key, label, enqueue_limit_flag: @config[:enqueue_limit].present?)
+            check_enqueue(enqueue_limit, enqueue_throttle, job, resolved_key, resolved_label, enqueue_limit_flag: @enqueue_limit.present?)
           elsif stage == :perform
-            perform_limit = limit(job, :perform_limit) || limit(job, :total_limit)
-            perform_throttle = throttle(job, :perform_throttle)
+            perform_limit = resolve_limit(job, @perform_limit) || resolve_limit(job, @total_limit)
+            perform_throttle = resolve_throttle(job, @perform_throttle)
             return nil unless perform_limit || perform_throttle
 
-            check_perform(perform_limit, perform_throttle, job, key, label)
+            check_perform(perform_limit, perform_throttle, job, resolved_key, resolved_label)
           end
         end
 
-        def key(job)
-          key_spec = @config[:key]
-          if key_spec.blank?
-            "label:#{label(job)}"
+        private
+
+        def key_explicit?
+          !@key.equal?(GoodJob::NONE)
+        end
+
+        def resolve_key(job)
+          if key.blank?
+            "label:#{resolve_label(job)}"
           else
-            key_value = key_spec.respond_to?(:call) ? job.instance_exec(&key_spec) : key_spec
+            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) }
 
             key_value
           end
         end
 
-        def label(job)
-          label_spec = @config[:label]
+        def resolve_label(job)
+          return if @label.blank?
 
-          return if label_spec.blank?
-
-          label_spec.respond_to?(:call) ? job.instance_exec(&label_spec) : label_spec
+          @label.respond_to?(:call) ? job.instance_exec(&@label) : @label
         end
 
-        def limit(job, limit_name)
-          value = @config[limit_name]
+        def resolve_limit(job, value)
           return nil if value.nil?
 
           value = job.instance_exec(&value) if value.respond_to?(:call)
@@ -69,8 +83,7 @@ module GoodJob
           value
         end
 
-        def throttle(job, throttle_name)
-          value = @config[throttle_name]
+        def resolve_throttle(job, value)
           return nil if value.nil?
 
           value = job.instance_exec(&value) if value.respond_to?(:call)
@@ -78,12 +91,10 @@ module GoodJob
           value
         end
 
-        private
-
         def query_scope(label, key)
           if label.present?
             GoodJob::Job.labeled(label)
-          elsif @config.key?(:key) && key.present?
+          elsif key_explicit? && key.present?
             GoodJob::Job.where(concurrency_key: key)
           else
             GoodJob::Job.all
@@ -269,16 +280,48 @@ module GoodJob
       end
 
       class_methods do
-        def good_job_control_concurrency_with(config)
-          self.good_job_concurrency_config = config
+        def good_job_control_concurrency_with(
+          total_limit: NONE,
+          enqueue_limit: NONE,
+          perform_limit: NONE,
+          enqueue_throttle: NONE,
+          perform_throttle: NONE,
+          key: NONE
+        )
+          self.good_job_concurrency_config = {
+            total_limit: total_limit,
+            enqueue_limit: enqueue_limit,
+            perform_limit: perform_limit,
+            enqueue_throttle: enqueue_throttle,
+            perform_throttle: perform_throttle,
+            key: key,
+          }.reject { |_key, value| value.equal?(NONE) }
         end
 
         # Define a concurrency rule. Rules are appended to the class-level
-        # `good_job_concurrency_rules` array. Each rule is a Hash that may
+        # `good_job_concurrency_rules` array. Each rule uses keyword arguments that may
         # include keys such as :label, :key (optional lock key), and
         # stage-specific settings like :enqueue_limit, :enqueue_throttle,
-        # :perform_limit, :perform_throttle, and :total_limit/:total_throttle.
-        def good_job_concurrency_rule(rule)
+        # :perform_limit, :perform_throttle, and :total_limit.
+        def good_job_concurrency_rule(
+          label: NONE,
+          key: NONE,
+          total_limit: NONE,
+          enqueue_limit: NONE,
+          perform_limit: NONE,
+          enqueue_throttle: NONE,
+          perform_throttle: NONE
+        )
+          rule = {
+            label: label,
+            key: key,
+            total_limit: total_limit,
+            enqueue_limit: enqueue_limit,
+            perform_limit: perform_limit,
+            enqueue_throttle: enqueue_throttle,
+            perform_throttle: perform_throttle,
+          }.reject { |_key, value| value.equal?(NONE) }
+
           self.good_job_concurrency_rules = Array(good_job_concurrency_rules) + [Rule.new(rule)]
         end
       end

data/lib/good_job/cli.rb

@@ -105,7 +105,7 @@ module GoodJob
     method_option :queue_select_limit,
                   type: :numeric,
                   banner: 'COUNT',
-                  desc: "The number of queued jobs to select when polling for a job to run. (env var: GOOD_JOB_QUEUE_SELECT_LIMIT, default: nil)"
+                  desc: "The number of queued jobs to select when polling for a job to run. (env var: GOOD_JOB_QUEUE_SELECT_LIMIT, default: 1000)"
 
     def start
       set_up_application!

data/lib/good_job/configuration.rb

@@ -39,6 +39,8 @@ module GoodJob
     DEFAULT_ENQUEUE_AFTER_TRANSACTION_COMMIT = false
     # Default enable_pauses setting
     DEFAULT_ENABLE_PAUSES = false
+    # Default number of candidate jobs to query when polling
+    DEFAULT_QUEUE_SELECT_LIMIT = 1_000
     # Valid dequeue query sorts
     DEQUEUE_QUERY_SORTS = [:created_at, :scheduled_at].freeze
     # Valid lock strategies
@@ -242,13 +244,14 @@ module GoodJob
     # This limit is intended to avoid locking a large number of rows when selecting eligible jobs
     # from the queue. This value should be higher than the total number of threads across all good_job
     # processes to ensure a thread can retrieve an eligible and unlocked job.
-    # @return [Integer, nil]
+    # @return [Integer]
     def queue_select_limit
       (
         options[:queue_select_limit] ||
           rails_config[:queue_select_limit] ||
-          env['GOOD_JOB_QUEUE_SELECT_LIMIT']
-      )&.to_i
+          env['GOOD_JOB_QUEUE_SELECT_LIMIT'] ||
+          DEFAULT_QUEUE_SELECT_LIMIT
+      ).to_i
     end
 
     # The number of seconds that a good_job process will idle with out running a job before exiting
@@ -388,7 +391,7 @@ module GoodJob
     def enable_pauses
       return options[:enable_pauses] unless options[:enable_pauses].nil?
       return rails_config[:enable_pauses] unless rails_config[:enable_pauses].nil?
-      return ActiveModel::Type::Boolean.new.cast(env['GOOD_JOB_ENABLE_PAUSES']) unless env['GOOD_JOB_ENABLE_PAUSE'].nil?
+      return ActiveModel::Type::Boolean.new.cast(env['GOOD_JOB_ENABLE_PAUSES']) unless env['GOOD_JOB_ENABLE_PAUSES'].nil?
 
       DEFAULT_ENABLE_PAUSES
     end

data/lib/good_job/safe_state.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module GoodJob
+  # Execution-local storage with a compatibility fallback.
+  # Uses ActiveSupport::IsolatedExecutionState on Rails 7.0+ (which respects
+  # config.active_support.isolation_level = :fiber for Fiber-aware servers).
+  # Falls back to Thread.current on older Rails.
+  module SafeState
+    def self.[](key)
+      state[key]
+    end
+
+    def self.[]=(key, value)
+      state[key] = value
+    end
+
+    def self.delete(key)
+      if defined?(ActiveSupport::IsolatedExecutionState)
+        ActiveSupport::IsolatedExecutionState.delete(key)
+      else
+        Thread.current[key] = nil
+      end
+    end
+
+    def self.state
+      if defined?(ActiveSupport::IsolatedExecutionState)
+        ActiveSupport::IsolatedExecutionState
+      else
+        Thread.current
+      end
+    end
+    private_class_method :state
+  end
+end

data/lib/good_job/scheduler.rb

@@ -282,7 +282,7 @@ module GoodJob # :nodoc:
     def create_task(delay = 0, fanout: false)
       future = Concurrent::ScheduledTask.new(delay, args: [self, performer], executor: executor, timer_set: timer_set) do |thr_scheduler, thr_performer|
         Thread.current.name = Thread.current.name.sub("-worker-", "-thread-") if Thread.current.name
-        Thread.current[:good_job_scheduler] = thr_scheduler
+        GoodJob::SafeState[:good_job_scheduler] = thr_scheduler
         Thread.current.priority = -3 if thr_scheduler.lower_thread_priority
 
         Rails.application.reloader.wrap do

data/lib/good_job/thread_status.rb

@@ -11,7 +11,7 @@ module GoodJob
       # Whether the current job execution thread is in a running state.
       # @return [Boolean]
       def current_thread_running?
-        scheduler = Thread.current[:good_job_scheduler]
+        scheduler = GoodJob::SafeState[:good_job_scheduler]
         scheduler ? scheduler.running? : true
       end
 
@@ -19,7 +19,7 @@ module GoodJob
       # (the opposite of running).
       # @return [Boolean]
       def current_thread_shutting_down?
-        scheduler = Thread.current[:good_job_scheduler]
+        scheduler = GoodJob::SafeState[:good_job_scheduler]
         scheduler && !scheduler.running?
       end
     end

data/lib/good_job/version.rb

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

data/lib/good_job.rb

@@ -40,6 +40,7 @@ require_relative "good_job/probe_server/healthcheck_middleware"
 require_relative "good_job/probe_server/not_found_app"
 require_relative "good_job/probe_server/simple_handler"
 require_relative "good_job/probe_server/webrick_handler"
+require_relative "good_job/safe_state"
 require_relative "good_job/scheduler"
 require_relative "good_job/shared_executor"
 require_relative "good_job/systemd_service"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 4.18.2
+  version: 4.19.0
 platform: ruby
 authors:
 - Ben Sheldon
@@ -396,6 +396,7 @@ files:
 - lib/good_job/probe_server/not_found_app.rb
 - lib/good_job/probe_server/simple_handler.rb
 - lib/good_job/probe_server/webrick_handler.rb
+- lib/good_job/safe_state.rb
 - lib/good_job/scheduler.rb
 - lib/good_job/sd_notify.rb
 - lib/good_job/shared_executor.rb
@@ -433,7 +434,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.11
 specification_version: 4
 summary: A multithreaded, Postgres-based ActiveJob backend for Ruby on Rails
 test_files: []