good_job 4.19.4 → 4.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02e6122e753d3039eccdd63032986cc9736ffcb972018b94ed0728db85935b18
-  data.tar.gz: 4937737349d54e5c7c58ddf3f5c03c51f9384188a18cc38b307c93da990f136d
+  metadata.gz: 96a4cd91def79d6e98d59849112ee43979d9dd518e252ca693d12c0e71003463
+  data.tar.gz: 5d82aa51b9f049b7655f0e7243ede43df3029011fd5e1f62637fdf193ba2cec3
 SHA512:
-  metadata.gz: a17d7eac17cfde7e5d1157cb3724c5ee86d9c8b13acf453408eb567df117872bd9846320427fdda333cb530971f89b50526642e7326fd98327f826c1067010fd
-  data.tar.gz: 12d760ca409707c4d5521f0ba80d3db48cd54ce96c219b465db4d920d0aea87471830e3f98c17cacb32cde2f309a4149e945823293b5a464e7d1e9b440862785
+  metadata.gz: 9301c67f9223407df170c9d8b9c93859d274f6affb36afb2fe948e81f1b704d7d8215510ad1491cf86f83fafecd5cd94a2394f8a793cf995b28f41a326d75086
+  data.tar.gz: 4b6ae502d9030ef467e9c7579ec2da0ccde6ccf35176d7a7a50e1fee13c0463030b9d725c0cd916439cdf58c32c3cf2d0a7bb1bea5c5e790c23110c670c510cf

data/CHANGELOG.md

@@ -1,5 +1,45 @@
 # Changelog
 
+## [v4.20.0](https://github.com/bensheldon/good_job/tree/v4.20.0) (2026-10-03)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v4.19.4...v4.20.0)
+
+**Implemented enhancements:**
+
+- Match identifier-like strings in dashboard search [\#1831](https://github.com/bensheldon/good_job/pull/1831) ([shiaho777](https://github.com/shiaho777))
+- Add a queue-scoped index for the dequeue candidate query [\#1810](https://github.com/bensheldon/good_job/pull/1810) ([a-abdellatif98](https://github.com/a-abdellatif98))
+- Add cluster mode [\#1803](https://github.com/bensheldon/good_job/pull/1803) ([bensheldon](https://github.com/bensheldon))
+
+**Fixed bugs:**
+
+- \[dashboard\] Mismatch between page header vs graph headers [\#1601](https://github.com/bensheldon/good_job/issues/1601)
+- Add dashboard and batch indexes, remove redundant indexes, and reorder the cron index [\#1840](https://github.com/bensheldon/good_job/pull/1840) ([bensheldon](https://github.com/bensheldon))
+- Detect Puma worker boot hooks and Puma 8 requests in `in_webserver?` [\#1836](https://github.com/bensheldon/good_job/pull/1836) ([amanfredi](https://github.com/amanfredi))
+- Keep both SharedExecutor threads available on JRuby [\#1835](https://github.com/bensheldon/good_job/pull/1835) ([amanfredi](https://github.com/amanfredi))
+- Pass `cron_graceful_restart_period` to the CronManager so it takes effect [\#1833](https://github.com/bensheldon/good_job/pull/1833) ([amanfredi](https://github.com/amanfredi))
+- Wrap Notifier's NOTIFY recipient dispatch in the Rails executor [\#1830](https://github.com/bensheldon/good_job/pull/1830) ([shiaho777](https://github.com/shiaho777))
+- Preserve active backtrace tabs across live poll refreshes [\#1824](https://github.com/bensheldon/good_job/pull/1824) ([shiaho777](https://github.com/shiaho777))
+- Refetch async navbar values after a live poll refresh [\#1823](https://github.com/bensheldon/good_job/pull/1823) ([shiaho777](https://github.com/shiaho777))
+- Truncate long strings when displaying job params on the dashboard [\#1822](https://github.com/bensheldon/good_job/pull/1822) ([shiaho777](https://github.com/shiaho777))
+- Bound all search\_text documents under the tsvector size limit [\#1820](https://github.com/bensheldon/good_job/pull/1820) ([shiaho777](https://github.com/shiaho777))
+- Finish a job's unfinished executions when it is discarded [\#1819](https://github.com/bensheldon/good_job/pull/1819) ([shiaho777](https://github.com/shiaho777))
+
+**Closed issues:**
+
+- Dequeue candidate indexes don't cover queue-filtered workers — one queue's backlog degrades every other queue's claim query [\#1790](https://github.com/bensheldon/good_job/issues/1790)
+- PG: ProgramLimitExceeded during search when a job has a huge error message [\#1785](https://github.com/bensheldon/good_job/issues/1785)
+- Very large `serialized_params` caused dashboard timeout on Heroku [\#1629](https://github.com/bensheldon/good_job/issues/1629)
+- \[dashboard\] Viewing a job & live poll resets the Full Trace vs Application Trace [\#1606](https://github.com/bensheldon/good_job/issues/1606)
+- \[GoodJob\] Notifier errored: NameError: uninitialized constant GoodJob::Job in develpment [\#1571](https://github.com/bensheldon/good_job/issues/1571)
+- Bug: calling GoodJob.restart in Puma on\_worker\_boot still starts GoodJob regardless of it being in async mode or not [\#1531](https://github.com/bensheldon/good_job/issues/1531)
+- Discarding a job via the dashboard should also update the discrete\_execution [\#1093](https://github.com/bensheldon/good_job/issues/1093)
+- A copy of GoodJob::Execution has been removed from the module tree but is still active! [\#954](https://github.com/bensheldon/good_job/issues/954)
+
+**Merged pull requests:**
+
+- Wait for Turbo navigation before reading the URL in performance specs [\#1838](https://github.com/bensheldon/good_job/pull/1838) ([amanfredi](https://github.com/amanfredi))
+- Bump github/codeql-action from 4.37.9 to 4.38.2 [\#1837](https://github.com/bensheldon/good_job/pull/1837) ([dependabot[bot]](https://github.com/apps/dependabot))
+
 ## [v4.19.4](https://github.com/bensheldon/good_job/tree/v4.19.4) (2026-10-02)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v4.19.3...v4.19.4)

data/README.md

@@ -308,7 +308,7 @@ Available configuration options are:
 - `max_cache` (integer) sets the maximum number of scheduled jobs that will be stored in memory to reduce execution latency when also polling for scheduled jobs. Caching 10,000 scheduled jobs uses approximately 20MB of memory. You can also set this with the environment variable `GOOD_JOB_MAX_CACHE`.
 - `shutdown_timeout` (integer) number of seconds to wait for jobs to finish when shutting down before stopping the thread. Defaults to forever: `-1`. You can also set this with the environment variable `GOOD_JOB_SHUTDOWN_TIMEOUT`.
 - `enable_cron` (boolean) whether to run cron process. Defaults to `false`. You can also set this with the environment variable `GOOD_JOB_ENABLE_CRON`.
-- `cron_graceful_restart_period` (integer) when restarting cron, attempt to re-enqueue jobs that would have been enqueued by cron within this time period (e.g. `1.minute`). This should match the expected downtime during deploys.
+- `cron_graceful_restart_period` (integer seconds or `ActiveSupport::Duration`) when cron starts, attempt to re-enqueue jobs that would have been enqueued by cron within this time period (e.g. `1.minute`). This should match the expected downtime during deploys. Like enabling cron on multiple processes, this relies on cron-created job records being preserved to avoid re-enqueuing jobs that already ran, so it is ignored when `preserve_job_records` is `false` or `:on_unhandled_error`. It does not apply to a `cron` proc that returns a time, which already enqueues the runs it missed since its last job. Defaults to `nil` (disabled). You can also set this with the environment variable `GOOD_JOB_CRON_GRACEFUL_RESTART_PERIOD`.
 - `enable_listen_notify` (boolean) whether to enqueue and read jobs with Postgres LISTEN/NOTIFY. Defaults to `true`. You can also set this with the environment variable `GOOD_JOB_ENABLE_LISTEN_NOTIFY`.
 - `cron` (hash) cron configuration. Defaults to `{}`. You can also set this as a JSON string with the environment variable `GOOD_JOB_CRON`
 - `cleanup_discarded_jobs` (boolean) whether to destroy discarded jobs when cleaning up preserved jobs using the `$ good_job cleanup_preserved_jobs` CLI command or calling `GoodJob.cleanup_preserved_jobs`. Defaults to `true`. Can also be set with the environment variable `GOOD_JOB_CLEANUP_DISCARDED_JOBS`.

data/app/filters/good_job/base_filter.rb

@@ -13,15 +13,17 @@ module GoodJob
     end
 
     def records
-      after_id = params[:after_id]
-      after_at = params[:after_at].present? ? Time.zone.parse(params[:after_at]) : nil
-      limit = params.fetch(:limit, DEFAULT_LIMIT)
-
-      query_for_records.display_all(
-        ordered_by: ordered_by,
-        after_at: after_at,
-        after_id: after_id
-      ).limit(limit)
+      @_records ||= begin
+        after_id = params[:after_id]
+        after_at = params[:after_at].present? ? Time.zone.parse(params[:after_at]) : nil
+        limit = params.fetch(:limit, DEFAULT_LIMIT)
+
+        query_for_records.display_all(
+          ordered_by: ordered_by,
+          after_at: after_at,
+          after_id: after_id
+        ).limit(limit)
+      end
     end
 
     def last
@@ -76,7 +78,7 @@ module GoodJob
 
     def next_page_params
       order_column = ordered_by.first
-      last_record = records.last
+      last_record = last
 
       {
         after_at: last_record&.send(order_column)&.iso8601(6),

data/app/filters/good_job/batches_filter.rb

@@ -2,16 +2,26 @@
 
 module GoodJob
   class BatchesFilter < BaseFilter
+    def job_count(batch)
+      job_counts.fetch(batch.id, 0)
+    end
+
     def filtered_query(_filtered_params = params)
       base_query
     end
 
     def query_for_records
-      default_base_query
+      base_query
     end
 
     def default_base_query
-      GoodJob::BatchRecord.includes(:jobs)
+      GoodJob::BatchRecord.all
+    end
+
+    private
+
+    def job_counts
+      @_job_counts ||= GoodJob::Job.where(batch_id: records.map(&:id)).group(:batch_id).count
     end
   end
 end

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

@@ -7,8 +7,15 @@ export default class extends Controller {
   }
   static targets = ["value"]
 
+  #onLivePollRefresh = () => this.#fetch();
+
   connect() {
     this.#fetch();
+    document.addEventListener("good_job:live-poll-refreshed", this.#onLivePollRefresh);
+  }
+
+  disconnect() {
+    document.removeEventListener("good_job:live-poll-refreshed", this.#onLivePollRefresh);
   }
 
   async #fetch() {

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

@@ -56,8 +56,23 @@ export default class extends Controller {
       const regionName = newElement.getAttribute('data-live-poll-region')
       const originalElement = document.querySelector(`[data-live-poll-region="${regionName}"]`)
       if (originalElement) {
-        originalElement.replaceWith(newElement)
+        this.#restoreTabs(originalElement, newElement)
       }
     })
   }
+
+  // Re-select any Bootstrap tabs that were active before a region is replaced
+  #restoreTabs(originalElement, newElement) {
+    const activeTargets = [...originalElement.querySelectorAll('.nav-link.active[data-bs-toggle]')]
+      .map((tab) => tab.getAttribute('data-bs-target') || tab.getAttribute('href'))
+    originalElement.replaceWith(newElement)
+    activeTargets.forEach((target) => {
+      const newTab = newElement.querySelector(`[data-bs-target="${target}"], [href="${target}"]`)
+      if (newTab) {
+        bootstrap.Tab.getOrCreateInstance(newTab).show()
+      }
+    })
+
+    document.dispatchEvent(new CustomEvent("good_job:live-poll-refreshed"))
+  }
 }

data/app/helpers/good_job/application_helper.rb

@@ -7,6 +7,10 @@ module GoodJob
     # We can't rely on +config.action_controller.include_all_helpers = true+ in the host app.
     include IconsHelper
 
+    # Maximum length of an individual string rendered inside serialized params
+    # and arguments on the dashboard, so very large payloads cannot stall the page.
+    MAX_DISPLAY_STRING_LENGTH = 1_000
+
     def job_action_states
       {
         reschedule: %w[scheduled retried queued],
@@ -17,6 +21,20 @@ module GoodJob
       }
     end
 
+    # Truncates long strings within a JSON-like structure for dashboard display.
+    def truncate_display_value(value, limit: MAX_DISPLAY_STRING_LENGTH)
+      case value
+      when String
+        value.length > limit ? "#{value.first(limit)}… [#{value.length} characters total]" : value
+      when Array
+        value.map { |element| truncate_display_value(element, limit: limit) }
+      when Hash
+        value.transform_values { |element| truncate_display_value(element, limit: limit) }
+      else
+        value
+      end
+    end
+
     def format_duration(sec)
       return unless sec
       return "" if sec.is_a?(String) # pg interval support added in Rails 6.1

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

@@ -5,9 +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").
+    # Bounds every document fed to to_tsvector() so the combined tsvector stays
+    # under PG's ~1 MB limit (PG::ProgramLimitExceeded: "string is too long for
+    # tsvector"). Free-form columns (arguments, error, labels) are truncated, and
+    # arguments are excluded from the full serialized_params document since they
+    # are covered by their own truncated term.
     MAX_SEARCH_COLUMN_CHARS = 262_144
 
     included do
@@ -74,14 +76,25 @@ module GoodJob
           (
             to_tsvector('english', id::text) ||
             to_tsvector('english', COALESCE(active_job_id::text, '')) ||
-            to_tsvector('english', serialized_params) ||
+            to_tsvector('english', serialized_params - 'arguments') ||
             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, ' '), ''))
+            to_tsvector('english', COALESCE(LEFT(array_to_string(labels, ' '), #{MAX_SEARCH_COLUMN_CHARS}), ''))
           )
         SQL
         to_tsquery_function = database_supports_websearch_to_tsquery? ? 'websearch_to_tsquery' : 'plainto_tsquery'
-        where("#{tsvector} @@ #{to_tsquery_function}('english', CAST(? AS text))", query)
+        # Full-text tokenization does not preserve identifier-like strings (URLs, globs of
+        # numbers and letters), so also match the raw text columns as a substring.
+        text_match = <<~SQL.squish
+          (
+            id::text ILIKE :like_pattern OR
+            COALESCE(active_job_id::text, '') ILIKE :like_pattern OR
+            serialized_params::text ILIKE :like_pattern OR
+            COALESCE(error, '') ILIKE :like_pattern OR
+            COALESCE(array_to_string(labels, ' '), '') ILIKE :like_pattern
+          )
+        SQL
+        where("#{tsvector} @@ #{to_tsquery_function}('english', CAST(:query AS text)) OR #{text_match}", query: query, like_pattern: "%#{sanitize_sql_like(query)}%")
           .order(sanitize_sql_for_order([Arel.sql("ts_rank(#{tsvector}, #{to_tsquery_function}('english', CAST(? AS text)))"), query]) => 'DESC')
       end)
     end

data/app/models/good_job/cron_entry.rb

@@ -110,7 +110,9 @@ module GoodJob # :nodoc:
         if result.is_a?(String)
           Fugit.parse(result).within(period).map(&:to_t)
         else
-          result
+          # A proc that returns a Time is called with the previous run's time, so when cron starts,
+          # CronManager#create_task already enqueues every run missed since the last job.
+          []
         end
       else
         fugit.within(period).map(&:to_t)

data/app/models/good_job/job.rb

@@ -287,14 +287,20 @@ module GoodJob
       end
 
       def historic_finished_at_index_migrated?
-        return true if connection.index_name_exists?(table_name, "index_good_jobs_on_queue_name_priority_scheduled_at_unfinished")
+        index_exists = connection_pool.with_connection do |connection|
+          connection.index_name_exists?(table_name, "index_good_jobs_on_queue_name_priority_scheduled_at_unfinished")
+        end
+        return true if index_exists
 
         migration_pending_warning!
         false
       end
 
       def lock_type_migrated?
-        return true if connection.index_name_exists?(table_name, :index_good_jobs_for_candidate_dequeue_unlocked)
+        index_exists = connection_pool.with_connection do |connection|
+          connection.index_name_exists?(table_name, :index_good_jobs_for_candidate_dequeue_unlocked)
+        end
+        return true if index_exists
 
         migration_pending_warning!
         false
@@ -957,11 +963,24 @@ module GoodJob
       job_error = GoodJob::Job::DiscardJobError.new(message)
 
       update_record = proc do
-        update(
-          finished_at: Time.current,
-          error: self.class.format_error(job_error),
-          error_event: :discarded
-        )
+        now = Time.current
+        error = self.class.format_error(job_error)
+
+        transaction do
+          update(
+            finished_at: now,
+            error: error,
+            error_event: :discarded
+          )
+          executions.where(finished_at: nil).find_each do |execution|
+            execution.update!(
+              finished_at: now,
+              error: error,
+              error_event: :discarded,
+              duration: (now - execution.created_at).seconds
+            )
+          end
+        end
       end
 
       if active_job.respond_to?(:instrument)

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

@@ -109,7 +109,7 @@
             </div>
           </div>
           <%= tag.div id: dom_id(job, "params"), class: "job-params list-group-item collapse small bg-dark text-light" do %>
-            <%= tag.pre JSON.pretty_generate(job.display_serialized_params) %>
+            <%= tag.pre JSON.pretty_generate(truncate_display_value(job.display_serialized_params)) %>
           <% end %>
         <% end %>
       <% else %>

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

@@ -56,7 +56,7 @@
               </div>
               <div class="col-6 col-lg-1">
                 <div class="d-lg-none small text-muted mt-1"><%= t "good_job.models.batch.jobs" %></div>
-                <%= batch.jobs.size %>
+                <%= filter.job_count(batch) %>
               </div>
               <div class="col text-end d-flex flex-row justify-content-end">
                 <% if batch.discarded? %>

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

@@ -70,7 +70,7 @@
       <% end %>
       <%= render 'good_job/custom_execution_details', execution: execution, job: @job %>
       <%= tag.div id: dom_id(execution, "params"), class: "list-group-item collapse small bg-dark text-light" do %>
-        <%= tag.pre JSON.pretty_generate(execution.display_serialized_params) %>
+        <%= tag.pre JSON.pretty_generate(truncate_display_value(execution.display_serialized_params)) %>
       <% end %>
     <% end %>
   </div>

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

@@ -190,7 +190,7 @@
             </div>
           <% end %>
           <%= tag.div id: dom_id(job, "params"), class: "job-params list-group-item collapse small bg-dark text-light" do %>
-            <%= tag.pre JSON.pretty_generate(job.display_serialized_params) %>
+            <%= tag.pre JSON.pretty_generate(truncate_display_value(job.display_serialized_params)) %>
           <% end %>
         <% end %>
       <% else %>

data/app/views/good_job/jobs/show.html.erb

@@ -78,10 +78,10 @@
     <% end %>
   </h5>
 </div>
-<%= tag.pre @job.serialized_params["arguments"].map(&:inspect).join(', '), class: 'text-wrap text-break' %>
+<%= tag.pre @job.serialized_params["arguments"].map { |argument| truncate_display_value(argument).inspect }.join(', '), class: 'text-wrap text-break' %>
 
 <%= tag.div id: dom_id(@job, "params"), class: "list-group-item collapse small bg-dark text-light" do %>
-  <%= tag.pre JSON.pretty_generate(@job.display_serialized_params) %>
+  <%= tag.pre JSON.pretty_generate(truncate_display_value(@job.display_serialized_params)) %>
 <% end %>
 
 <%= render 'executions', executions: @job.executions.sort_by(&:number).reverse %>

data/config/brakeman.ignore

@@ -1,26 +1,5 @@
 {
   "ignored_warnings": [
-    {
-      "warning_type": "SQL Injection",
-      "warning_code": 0,
-      "fingerprint": "e3cc5489d3e3e81f35347b7530d5743fbac8491ab612ceec0d034e22656269ed",
-      "check_name": "SQL",
-      "message": "Possible SQL injection",
-      "file": "app/models/good_job/job/lockable.rb",
-      "line": 103,
-      "link": "https://brakemanscanner.org/docs/warning_types/sql_injection/",
-      "code": "unscoped.find_by_sql([\"WITH candidate AS #{(\"MATERIALIZED \" or \"\")}(#{select(:id).lock(\"FOR NO KEY UPDATE SKIP LOCKED\").to_sql})\\nUPDATE #{quoted_table_name}\\nSET locked_by_id = ?,\\n    locked_at = ?,\\n    lock_type = ?\\nFROM (\\n  SELECT id FROM candidate\\n  WHERE pg_try_advisory_lock(#{\"('x' || substr(md5(#{_quoted_table_name_string} || '-' || id::text), 1, 16))::bit(64)::bigint\"})\\n) AS locked\\nWHERE #{quoted_table_name}.id = locked.id\\nRETURNING #{quoted_table_name}.*\\n\".squish, locked_by_id, locked_at, lock_types[lock_type.to_s]])",
-      "render_path": null,
-      "location": {
-        "type": "method",
-        "class": "GoodJob::Job",
-        "method": "with_hybrid_lock_claim"
-      },
-      "user_input": "_quoted_table_name_string",
-      "confidence": "Weak",
-      "cwe_id": [89],
-      "note": "Table name is quoted via quoted_table_name (Rails); advisory lock expression uses _quoted_table_name_string (escaped); candidate SQL is Rails-generated; values are parameterized bindings."
-    },
     {
       "warning_type": "SQL Injection",
       "warning_code": 0,
@@ -28,18 +7,20 @@
       "check_name": "SQL",
       "message": "Possible SQL injection",
       "file": "app/models/concerns/good_job/advisory_lockable.rb",
-      "line": 123,
+      "line": 254,
       "link": "https://brakemanscanner.org/docs/warning_types/sql_injection/",
-      "code": "joins(\"LEFT JOIN pg_locks ON pg_locks.locktype = 'advisory'\\n  AND pg_locks.objsubid = 1\\n  AND pg_locks.classid = #{advisory_lock_classid_sql(...)}\\n  AND pg_locks.objid = #{advisory_lock_objid_sql(...)}\\n\".squish)",
+      "code": "joins(\"LEFT JOIN pg_locks ON pg_locks.locktype = 'advisory'\\n  AND pg_locks.objsubid = 1\\n  AND pg_locks.classid = #{advisory_lock_classid_sql(\"#{_quoted_table_name_string} || '-' || #{quoted_table_name}.#{adapter_class.quote_column_name(_advisory_lockable_column)}::text\")}\\n  AND pg_locks.objid = #{advisory_lock_objid_sql(\"#{_quoted_table_name_string} || '-' || #{quoted_table_name}.#{adapter_class.quote_column_name(_advisory_lockable_column)}::text\")}\\n\".squish)",
       "render_path": null,
       "location": {
         "type": "method",
         "class": "GoodJob",
         "method": null
       },
-      "user_input": "advisory_lock_classid_sql(...)",
+      "user_input": "advisory_lock_classid_sql(\"#{_quoted_table_name_string} || '-' || #{quoted_table_name}.#{adapter_class.quote_column_name(_advisory_lockable_column)}::text\")",
       "confidence": "Medium",
-      "cwe_id": [89],
+      "cwe_id": [
+        89
+      ],
       "note": "Values are quoted identifiers and an escaped table name string; not user input."
     },
     {
@@ -49,30 +30,32 @@
       "check_name": "SQL",
       "message": "Possible SQL injection",
       "file": "app/models/concerns/good_job/advisory_lockable.rb",
-      "line": 123,
+      "line": 254,
       "link": "https://brakemanscanner.org/docs/warning_types/sql_injection/",
-      "code": "joins(\"LEFT JOIN pg_locks ON pg_locks.locktype = 'advisory'\\n  AND pg_locks.objsubid = 1\\n  AND pg_locks.classid = #{advisory_lock_classid_sql(...)}\\n  AND pg_locks.objid = #{advisory_lock_objid_sql(...)}\\n\".squish)",
+      "code": "joins(\"LEFT JOIN pg_locks ON pg_locks.locktype = 'advisory'\\n  AND pg_locks.objsubid = 1\\n  AND pg_locks.classid = #{advisory_lock_classid_sql(\"#{_quoted_table_name_string} || '-' || #{quoted_table_name}.#{adapter_class.quote_column_name(_advisory_lockable_column)}::text\")}\\n  AND pg_locks.objid = #{advisory_lock_objid_sql(\"#{_quoted_table_name_string} || '-' || #{quoted_table_name}.#{adapter_class.quote_column_name(_advisory_lockable_column)}::text\")}\\n\".squish)",
       "render_path": null,
       "location": {
         "type": "method",
         "class": "GoodJob::AdvisoryLockable",
         "method": null
       },
-      "user_input": "advisory_lock_classid_sql(...)",
+      "user_input": "advisory_lock_classid_sql(\"#{_quoted_table_name_string} || '-' || #{quoted_table_name}.#{adapter_class.quote_column_name(_advisory_lockable_column)}::text\")",
       "confidence": "Medium",
-      "cwe_id": [89],
+      "cwe_id": [
+        89
+      ],
       "note": "Values are quoted identifiers and an escaped table name string; not user input."
     },
     {
       "warning_type": "Dangerous Eval",
       "warning_code": 13,
-      "fingerprint": "c01ff32ee40cc694540aaa76e3fdab8f330babd9d6dbf2564c32aef1cfd877fa",
+      "fingerprint": "54b7ac445eea2aa1735ae97fab1d841e15405a747ba0fdb577cf779286647534",
       "check_name": "Evaluation",
       "message": "Dynamic string evaluated as code",
       "file": "lib/good_job/log_subscriber.rb",
-      "line": 278,
+      "line": 356,
       "link": "https://brakemanscanner.org/docs/warning_types/dangerous_eval/",
-      "code": "class_eval(\"        def #{level}(progname = nil, tags: [], &block)   # def info(progname = nil, tags: [], &block)\\n          return unless logger                           #   return unless logger\\n                                                         #\\n          tag_logger(*tags) do                           #   tag_logger(*tags) do\\n            logger.#{level}(progname, &block)            #     logger.info(progname, &block)\\n          end                                            #   end\\n        end                                              #\\n\", \"lib/good_job/log_subscriber.rb\", (278 + 1))",
+      "code": "class_eval(\"        def #{level}(progname = nil, tags: [], &block)   # def info(progname = nil, tags: [], &block)\\n          return unless logger                           #   return unless logger\\n                                                         #\\n          tag_logger(*tags) do                           #   tag_logger(*tags) do\\n            logger.#{level}(progname, &block)            #     logger.info(progname, &block)\\n          end                                            #   end\\n        end                                              #\\n\", \"lib/good_job/log_subscriber.rb\", (356 + 1))",
       "render_path": null,
       "location": {
         "type": "method",
@@ -132,6 +115,29 @@
         77
       ],
       "note": ""
+    },
+    {
+      "warning_type": "SQL Injection",
+      "warning_code": 0,
+      "fingerprint": "e3cc5489d3e3e81f35347b7530d5743fbac8491ab612ceec0d034e22656269ed",
+      "check_name": "SQL",
+      "message": "Possible SQL injection",
+      "file": "app/models/good_job/job/lockable.rb",
+      "line": 102,
+      "link": "https://brakemanscanner.org/docs/warning_types/sql_injection/",
+      "code": "unscoped.find_by_sql([\"WITH candidate AS #{(\"MATERIALIZED \" or \"\")}(#{select(:id).lock(\"FOR NO KEY UPDATE SKIP LOCKED\").to_sql})\\nUPDATE #{quoted_table_name}\\nSET locked_by_id = ?,\\n    locked_at = ?,\\n    lock_type = ?\\nFROM (\\n  SELECT id FROM candidate\\n  WHERE pg_try_advisory_lock(#{\"('x' || substr(md5(#{_quoted_table_name_string} || '-' || id::text), 1, 16))::bit(64)::bigint\"})\\n) AS locked\\nWHERE #{quoted_table_name}.id = locked.id\\nRETURNING #{quoted_table_name}.*\\n\".squish, locked_by_id, locked_at, lock_types[lock_type.to_s]])",
+      "render_path": null,
+      "location": {
+        "type": "method",
+        "class": "GoodJob::Job",
+        "method": "with_hybrid_lock_claim"
+      },
+      "user_input": "_quoted_table_name_string",
+      "confidence": "Weak",
+      "cwe_id": [
+        89
+      ],
+      "note": "Table name is quoted via quoted_table_name (Rails); advisory lock expression uses _quoted_table_name_string (escaped); candidate SQL is Rails-generated; values are parameterized bindings."
     }
   ],
   "brakeman_version": "8.0.4"

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

@@ -80,25 +80,26 @@ class CreateGoodJobs < ActiveRecord::Migration<%= migration_version %>
     end
 
     add_index :good_jobs, :scheduled_at, where: "(finished_at IS NULL)", name: :index_good_jobs_on_scheduled_at
-    add_index :good_jobs, [:queue_name, :scheduled_at], where: "(finished_at IS NULL)", name: :index_good_jobs_on_queue_name_and_scheduled_at
     add_index :good_jobs, [:active_job_id, :created_at], name: :index_good_jobs_on_active_job_id_and_created_at
     add_index :good_jobs, :concurrency_key, where: "(finished_at IS NULL)", name: :index_good_jobs_on_concurrency_key_when_unfinished
     add_index :good_jobs, [:concurrency_key, :created_at], name: :index_good_jobs_on_concurrency_key_and_created_at
     add_index :good_jobs, [:cron_key, :created_at], where: "(cron_key IS NOT NULL)", name: :index_good_jobs_on_cron_key_and_created_at_cond
-    add_index :good_jobs, [:cron_key, :cron_at], where: "(cron_key IS NOT NULL)", unique: true, name: :index_good_jobs_on_cron_key_and_cron_at_cond
+    add_index :good_jobs, [:cron_key, :cron_at], order: { cron_at: "DESC NULLS LAST" },
+      where: "(cron_key IS NOT NULL)", unique: true, name: :index_good_jobs_on_cron_key_and_cron_at_cond
     add_index :good_jobs, [:finished_at], where: "finished_at IS NOT NULL", name: :index_good_jobs_jobs_on_finished_at_only
-    add_index :good_jobs, [:priority, :created_at], order: { priority: "DESC NULLS LAST", created_at: :asc },
-      where: "finished_at IS NULL", name: :index_good_jobs_jobs_on_priority_created_at_when_unfinished
     add_index :good_jobs, [:priority, :created_at], order: { priority: "ASC NULLS LAST", created_at: :asc },
       where: "finished_at IS NULL", name: :index_good_job_jobs_for_candidate_lookup
     add_index :good_jobs, [:batch_id], where: "batch_id IS NOT NULL"
     add_index :good_jobs, [:batch_callback_id], where: "batch_callback_id IS NOT NULL"
+    add_index :good_jobs, :batch_id,
+      where: "batch_id IS NOT NULL AND finished_at IS NULL", name: :index_good_jobs_on_batch_id_unfinished
+    add_index :good_jobs, :batch_callback_id,
+      where: "batch_callback_id IS NOT NULL AND finished_at IS NULL", name: :index_good_jobs_on_batch_callback_id_unfinished
     add_index :good_jobs, :job_class, name: :index_good_jobs_on_job_class
     add_index :good_jobs, :labels, using: :gin, where: "(labels IS NOT NULL)", name: :index_good_jobs_on_labels
 
     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_jobs, [:priority, :scheduled_at], order: { priority: "ASC NULLS LAST", scheduled_at: :asc },
-      where: "finished_at IS NULL AND locked_by_id IS NULL", name: :index_good_jobs_on_priority_scheduled_at_unfinished_unlocked
+    add_index :good_job_executions, :scheduled_at, name: :index_good_job_executions_on_scheduled_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],
@@ -107,11 +108,24 @@ class CreateGoodJobs < ActiveRecord::Migration<%= migration_version %>
     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_job_executions, [:process_id, :created_at], name: :index_good_job_executions_on_process_id_and_created_at
+    add_index :good_job_batches, :finished_at,
+      where: "finished_at IS NOT NULL", name: :index_good_job_batches_on_finished_at
+    add_index :good_job_batches, [:created_at, :id],
+      order: { created_at: :desc, id: :desc }, name: :index_good_job_batches_on_created_at_and_id
     add_index :good_jobs, [:priority, :scheduled_at, :id],
       name: :index_good_jobs_for_candidate_dequeue_unlocked,
       order: { priority: "ASC NULLS LAST", scheduled_at: :asc, id: :asc },
       where: "finished_at IS NULL AND locked_by_id IS NULL"
 
+    add_index :good_jobs, [:queue_name, :priority, :created_at],
+      name: :index_good_jobs_dequeue_by_queue,
+      order: { priority: "ASC NULLS LAST", created_at: :asc },
+      where: "finished_at IS NULL AND locked_by_id IS NULL"
+    add_index :good_jobs, [:queue_name, :priority, :scheduled_at],
+      name: :index_good_jobs_dequeue_by_queue_scheduled_at,
+      order: { priority: "ASC NULLS LAST", scheduled_at: :asc },
+      where: "finished_at IS NULL AND locked_by_id IS NULL"
+
     add_index :good_jobs, :queue_name, name: :index_good_jobs_on_queue_name
     add_index :good_jobs, :created_at, name: :index_good_jobs_on_created_at
     add_index :good_jobs, :finished_at,

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

@@ -79,23 +79,24 @@ class CreateGoodJobs < ActiveRecord::Migration<%= migration_version %>
     end
 
     add_index :good_jobs, :scheduled_at, where: "(finished_at IS NULL)", name: :index_good_jobs_on_scheduled_at
-    add_index :good_jobs, [:queue_name, :scheduled_at], where: "(finished_at IS NULL)", name: :index_good_jobs_on_queue_name_and_scheduled_at
     add_index :good_jobs, [:active_job_id, :created_at], name: :index_good_jobs_on_active_job_id_and_created_at
     add_index :good_jobs, :concurrency_key, where: "(finished_at IS NULL)", name: :index_good_jobs_on_concurrency_key_when_unfinished
     add_index :good_jobs, [:cron_key, :created_at], where: "(cron_key IS NOT NULL)", name: :index_good_jobs_on_cron_key_and_created_at_cond
-    add_index :good_jobs, [:cron_key, :cron_at], where: "(cron_key IS NOT NULL)", unique: true, name: :index_good_jobs_on_cron_key_and_cron_at_cond
+    add_index :good_jobs, [:cron_key, :cron_at], order: { cron_at: "DESC NULLS LAST" },
+      where: "(cron_key IS NOT NULL)", unique: true, name: :index_good_jobs_on_cron_key_and_cron_at_cond
     add_index :good_jobs, [:finished_at], where: "retried_good_job_id IS NULL AND finished_at IS NOT NULL", name: :index_good_jobs_jobs_on_finished_at
-    add_index :good_jobs, [:priority, :created_at], order: { priority: "DESC NULLS LAST", created_at: :asc },
-      where: "finished_at IS NULL", name: :index_good_jobs_jobs_on_priority_created_at_when_unfinished
     add_index :good_jobs, [:priority, :created_at], order: { priority: "ASC NULLS LAST", created_at: :asc },
       where: "finished_at IS NULL", name: :index_good_job_jobs_for_candidate_lookup
     add_index :good_jobs, [:batch_id], where: "batch_id IS NOT NULL"
     add_index :good_jobs, [:batch_callback_id], where: "batch_callback_id IS NOT NULL"
+    add_index :good_jobs, :batch_id,
+      where: "batch_id IS NOT NULL AND finished_at IS NULL", name: :index_good_jobs_on_batch_id_unfinished
+    add_index :good_jobs, :batch_callback_id,
+      where: "batch_callback_id IS NOT NULL AND finished_at IS NULL", name: :index_good_jobs_on_batch_callback_id_unfinished
     add_index :good_jobs, :labels, using: :gin, where: "(labels IS NOT NULL)", name: :index_good_jobs_on_labels
 
     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_jobs, [:priority, :scheduled_at], order: { priority: "ASC NULLS LAST", scheduled_at: :asc },
-      where: "finished_at IS NULL AND locked_by_id IS NULL", name: :index_good_jobs_on_priority_scheduled_at_unfinished_unlocked
+    add_index :good_job_executions, :scheduled_at, name: :index_good_job_executions_on_scheduled_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],
@@ -103,5 +104,9 @@ class CreateGoodJobs < ActiveRecord::Migration<%= migration_version %>
       order: { priority: "ASC NULLS LAST", scheduled_at: :asc, id: :asc },
       where: "finished_at IS NULL AND locked_by_id IS NULL"
     add_index :good_job_executions, [:process_id, :created_at], name: :index_good_job_executions_on_process_id_and_created_at
+    add_index :good_job_batches, :finished_at,
+      where: "finished_at IS NOT NULL", name: :index_good_job_batches_on_finished_at
+    add_index :good_job_batches, [:created_at, :id],
+      order: { created_at: :desc, id: :desc }, name: :index_good_job_batches_on_created_at_and_id
   end
 end

data/lib/generators/good_job/templates/update/migrations/16_add_index_good_jobs_dequeue_by_queue.rb.erb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class AddIndexGoodJobsDequeueByQueue < ActiveRecord::Migration<%= migration_version %>
+  disable_ddl_transaction!
+
+  def change
+    add_index :good_jobs, [:queue_name, :priority, :created_at],
+      name: :index_good_jobs_dequeue_by_queue,
+      order: { priority: "ASC NULLS LAST", created_at: :asc },
+      where: "finished_at IS NULL AND locked_by_id IS NULL",
+      algorithm: :concurrently,
+      if_not_exists: true
+
+    add_index :good_jobs, [:queue_name, :priority, :scheduled_at],
+      name: :index_good_jobs_dequeue_by_queue_scheduled_at,
+      order: { priority: "ASC NULLS LAST", scheduled_at: :asc },
+      where: "finished_at IS NULL AND locked_by_id IS NULL",
+      algorithm: :concurrently,
+      if_not_exists: true
+  end
+end