good_job 4.22.1 → 4.23.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ce4bd5cfbb7e4fcc44f90099bc1aa892ef59e1294c69eac5d4279c3968db9c0
-  data.tar.gz: '093ba2cc69d8d51f38bbf4cd93d9bf97aa65d995768f00a6b0d27dbe1aacdd08'
+  metadata.gz: 62018fa8fb4313f6aa3e6ef7531ac3073adc80449fd28a03f655014ce0c1922b
+  data.tar.gz: 478315a41ea1d69a9d15781b4b57ecd099504c3da754605b12fd752a10cb3ad0
 SHA512:
-  metadata.gz: bcbcad67274883a3cb3d4405d7d43015c5c154241dab9c1d136ccbcae7ea53bf9e6606d4713761b7c565826487f042c0e869ecc14eafacfa46ce3bfb9de6dc26
-  data.tar.gz: 56b86db61ba722ebbe770f0f0be2f20eaea6a132af9a3d9e5f688a2c2138d3782d92a3a425ff47b0e1881539c7bfe8135c18444b887665105edc385d3f3aa3a7
+  metadata.gz: 2f3f11b6633b90116e2cbe15057032cdd49609c074a80c21ef496ec250dea79f9ce5f3b3eda27db5c36bfd4cd1c262fda7b41301a168772148d70d35ca3f7dc7
+  data.tar.gz: 33ef016c46794b39cd7006b16073849c76d62116ab2c42030087b91286ebfd20887bf8735c7f0183fcd8a5acb4c599ae7eabbddcb36420f3a2484044301fc231

data/CHANGELOG.md

@@ -1,5 +1,51 @@
 # Changelog
 
+## [v4.23.1](https://github.com/bensheldon/good_job/tree/v4.23.1) (2026-10-27)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v4.23.0...v4.23.1)
+
+**Fixed bugs:**
+
+- Release abandoned job claims after database failures [\#1887](https://github.com/bensheldon/good_job/pull/1887) ([ollym](https://github.com/ollym))
+
+## [v4.23.0](https://github.com/bensheldon/good_job/tree/v4.23.0) (2026-10-27)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v4.22.1...v4.23.0)
+
+**Implemented enhancements:**
+
+- Filter sensitive job arguments in the Dashboard [\#1881](https://github.com/bensheldon/good_job/pull/1881) ([bogdan](https://github.com/bogdan))
+
+**Fixed bugs:**
+
+- Respect enable\_listen\_notify when promoting concurrency claims [\#1892](https://github.com/bensheldon/good_job/pull/1892) ([eidam](https://github.com/eidam))
+- Downgrade lock\_type before releasing advisory lock [\#1883](https://github.com/bensheldon/good_job/pull/1883) ([jmsanders](https://github.com/jmsanders))
+
+**Closed issues:**
+
+- ConcurrencyClaim sends NOTIFY even when enable\_listen\_notify is false [\#1891](https://github.com/bensheldon/good_job/issues/1891)
+
+**Merged pull requests:**
+
+- Keep JRuby platform in Gemfile.lock when Bundler re-resolves [\#1893](https://github.com/bensheldon/good_job/pull/1893) ([bensheldon](https://github.com/bensheldon))
+- Make integration specs robust under database load; fix mixed lock strategy specs [\#1890](https://github.com/bensheldon/good_job/pull/1890) ([bensheldon](https://github.com/bensheldon))
+- Pin CI test runners to ubuntu-24.04 [\#1888](https://github.com/bensheldon/good_job/pull/1888) ([bensheldon](https://github.com/bensheldon))
+- Require the concurrent-ruby classes GoodJob uses [\#1885](https://github.com/bensheldon/good_job/pull/1885) ([czj](https://github.com/czj))
+- Add index\_good\_job\_executions\_on\_created\_at [\#1884](https://github.com/bensheldon/good_job/pull/1884) ([clinejj](https://github.com/clinejj))
+- Demo: cap YJIT memory and shrink the Rack::Attack store [\#1880](https://github.com/bensheldon/good_job/pull/1880) ([bensheldon](https://github.com/bensheldon))
+- Demo: enable rbtrace in Puma workers for heap dumps; add sheap [\#1879](https://github.com/bensheldon/good_job/pull/1879) ([bensheldon](https://github.com/bensheldon))
+- Demo: warm up Puma before forking, add Thruster, raise DB pool [\#1878](https://github.com/bensheldon/good_job/pull/1878) ([bensheldon](https://github.com/bensheldon))
+- Return 404 for GET /jobs/mass\_update instead of redirecting [\#1877](https://github.com/bensheldon/good_job/pull/1877) ([bensheldon](https://github.com/bensheldon))
+- Load execution full traces and serialized params on demand [\#1876](https://github.com/bensheldon/good_job/pull/1876) ([bensheldon](https://github.com/bensheldon))
+- Add specs for the demo's Rack::Attack rules [\#1875](https://github.com/bensheldon/good_job/pull/1875) ([bensheldon](https://github.com/bensheldon))
+- Fix demo boot: don't require rails/all in bin/rails [\#1874](https://github.com/bensheldon/good_job/pull/1874) ([bensheldon](https://github.com/bensheldon))
+- Reduce demo app memory and crawler load [\#1873](https://github.com/bensheldon/good_job/pull/1873) ([bensheldon](https://github.com/bensheldon))
+- Fix JRuby flake from inspect in wait\_until predicate expectations [\#1872](https://github.com/bensheldon/good_job/pull/1872) ([bensheldon](https://github.com/bensheldon))
+- Remove Adapter::RUNTIMES so adapters can be garbage collected [\#1870](https://github.com/bensheldon/good_job/pull/1870) ([bensheldon](https://github.com/bensheldon))
+- Add GoodJob.prune to release shut down capsules, schedulers, and notifiers [\#1869](https://github.com/bensheldon/good_job/pull/1869) ([bensheldon](https://github.com/bensheldon))
+- Use resolve\_\[property\] naming for CronEntry configuration resolvers [\#1868](https://github.com/bensheldon/good_job/pull/1868) ([bensheldon](https://github.com/bensheldon))
+- Fix inconsistencies in the Brazilian Portuguese locale [\#1867](https://github.com/bensheldon/good_job/pull/1867) ([tiagoamaro](https://github.com/tiagoamaro))
+
 ## [v4.22.1](https://github.com/bensheldon/good_job/tree/v4.22.1) (2026-10-13)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v4.22.0...v4.22.1)

data/README.md

@@ -44,6 +44,7 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
     - [Dashboard](#dashboard)
         - [API-only Rails applications](#api-only-rails-applications)
         - [Live polling](#live-polling)
+        - [Filtering sensitive arguments](#filtering-sensitive-arguments)
         - [Extending dashboard views](#extending-dashboard-views)
     - [Job priority](#job-priority)
     - [Concurrency controls](#concurrency-controls)
@@ -479,6 +480,15 @@ end
 
 The Dashboard can be set to automatically refresh by checking "Live Poll" in the Dashboard header, or by setting `?poll=10` with the interval in seconds (default 30 seconds).
 
+#### Filtering sensitive arguments
+
+The Dashboard hides job arguments the same way Rails hides them from logs:
+
+- Hash values whose keys match `Rails.application.config.filter_parameters` (e.g. `password:`) are displayed as `[FILTERED]`.
+- All arguments are displayed as `[FILTERED]` for jobs with `log_arguments` disabled, either for every job with `config.active_job.log_arguments = false` or per job class with `self.log_arguments = false`.
+
+Filtering only applies to how arguments are displayed; arguments are still stored unfiltered in the database and are used when the job is performed or retried.
+
 #### Extending dashboard views
 
 GoodJob exposes some views that are intended to be overridden by placing views in your application:
@@ -1215,6 +1225,8 @@ Note that when running jobs in `:inline` execution mode, `GoodJob.current_thread
 
 Jobs will be automatically retried if the process is interrupted while performing a job and the job is unable to finish before the timeout or as the result of a `SIGKILL` or power failure. The interrupted execution's error record will show `GoodJob::InterruptedError` to distinguish it from the rescuable `GoodJob::InterruptError` that is raised when the job is retried.
 
+With `:skiplocked` or `:hybrid` locking, a worker releases its claim even if recording the job's completion fails. If the database connection is unavailable during cleanup, the worker waits and retries every five seconds until it can release the claim, GoodJob begins shutting down, or the worker is forcibly terminated. If the worker stops retrying, the claim is released when the exited process's record is cleaned up. The job can then be recovered as an interrupted execution, which may run it again; external effects should be idempotent.
+
 If you need more control over interrupt-caused retries, include the `GoodJob::ActiveJobExtensions::InterruptErrors` extension in your job class. When an interrupted job is retried, the extension will raise a `GoodJob::InterruptError` exception within the job, which allows you to use Active Job's `retry_on` and `discard_on` to control the behavior of the job.
 
 ```ruby
@@ -1644,7 +1656,7 @@ end
 GOOD_JOB_LOCK_STRATEGY=skiplocked
 ```
 
-All three strategies (`:advisory`, `:skiplocked`, `:hybrid`) can coexist safely during a rolling deploy — each strategy excludes jobs that are already locked by another worker regardless of which strategy that worker uses.
+During a rolling deploy, `:hybrid` workers can safely run alongside either `:advisory` or `:skiplocked` workers. But `:advisory` and `:skiplocked` workers must not run at the same time, because neither sees the other's locks and the same job may be performed twice. To move from `:advisory` to `:skiplocked`, deploy `:hybrid` first, wait until no `:advisory` workers remain, and then deploy `:skiplocked`.
 
 #### PgBouncer configuration
 

data/app/controllers/good_job/executions_controller.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module GoodJob
+  # Renders an execution's heavier details on demand so they aren't included in every job page.
+  class ExecutionsController < GoodJob::ApplicationController
+    def show
+      @execution = Execution.find_by!(id: params[:id], active_job_id: params[:job_id])
+      render layout: false
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module GoodJob
+  # Hides sensitive Active Job arguments when displaying Job/Execution records in the Dashboard.
+  module FilteredArguments
+    # Active Job arguments with sensitive values replaced by +[FILTERED]+.
+    # Every argument is filtered when the job class has +log_arguments+ disabled
+    # (e.g. +config.active_job.log_arguments = false+); otherwise hash values whose
+    # keys match +Rails.application.config.filter_parameters+ are filtered.
+    # @return [Array]
+    def display_arguments
+      arguments = serialized_params.fetch("arguments", [])
+      return arguments.map { ActiveSupport::ParameterFilter::FILTERED } unless log_arguments?
+
+      parameter_filter = ActiveSupport::ParameterFilter.new(Rails.application.config.filter_parameters)
+      parameter_filter.filter("arguments" => arguments)["arguments"]
+    end
+
+    private
+
+    def log_arguments?
+      active_job_class = job_class&.safe_constantize
+      active_job_class = ActiveJob::Base unless active_job_class.respond_to?(:log_arguments?)
+      active_job_class.log_arguments?
+    end
+  end
+end

data/app/models/good_job/concurrency_claim.rb

@@ -172,6 +172,8 @@ module GoodJob
       end
 
       def notify(job_id)
+        return unless GoodJob.configuration.enable_listen_notify
+
         queue_name = GoodJob::Job.where(id: job_id).pick(:queue_name)
         GoodJob::Notifier.notify({ queue_name: queue_name }) if queue_name
       end

data/app/models/good_job/cron_entry.rb

@@ -139,8 +139,10 @@ module GoodJob # :nodoc:
           job_klass = resolve_job_class
           next unless job_klass.is_a?(Class)
 
-          configured_job = job_klass.set(set_value)
-          kwargs_value.present? ? configured_job.perform_later(*args_value, **kwargs_value) : configured_job.perform_later(*args_value)
+          configured_job = job_klass.set(resolve_set)
+          job_args = resolve_args
+          job_kwargs = resolve_kwargs
+          job_kwargs.present? ? configured_job.perform_later(*job_args, **job_kwargs) : configured_job.perform_later(*job_args)
         end
       end
     end
@@ -213,7 +215,8 @@ module GoodJob # :nodoc:
     end
 
     def resolve_job_class
-      value = job_class_value
+      value = job_class
+      value = value.call if value.respond_to?(:call)
       value.is_a?(String) ? value.constantize : value
     end
 
@@ -236,22 +239,17 @@ module GoodJob # :nodoc:
       schedule if schedule.instance_of?(Fugit::Cron)
     end
 
-    def job_class_value
-      value = job_class || nil
-      value.respond_to?(:call) ? value.call : value
-    end
-
-    def set_value
+    def resolve_set
       value = set || {}
       value.respond_to?(:call) ? value.call : value
     end
 
-    def args_value
+    def resolve_args
       value = args || []
       value.respond_to?(:call) ? value.call : value
     end
 
-    def kwargs_value
+    def resolve_kwargs
       value = kwargs || nil
       value.respond_to?(:call) ? value.call : value
     end

data/app/models/good_job/execution.rb

@@ -3,6 +3,7 @@
 module GoodJob # :nodoc:
   class Execution < BaseRecord
     include ErrorEvents
+    include FilteredArguments
 
     self.table_name = 'good_job_executions'
     self.implicit_order_column = 'created_at'
@@ -63,6 +64,7 @@ module GoodJob # :nodoc:
 
     def display_serialized_params
       serialized_params.merge({
+                                "arguments" => display_arguments,
                                 _good_job_execution: attributes.except('serialized_params'),
                               })
     end

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

@@ -8,6 +8,11 @@ module GoodJob
     module Lockable
       extend ActiveSupport::Concern
 
+      # Seconds to wait between attempts to release a claim after a connection failure.
+      RELEASE_CLAIM_RETRY_INTERVAL = 5
+      # Log a warning on the first failed release and then every this many attempts.
+      RELEASE_CLAIM_RETRY_WARNING_EVERY = 10
+
       class_methods do
         # Claims a job by acquiring a session-level advisory lock via the CTE
         # query, and records the lock acquisition for phantom re-entrancy cleanup.
@@ -20,13 +25,17 @@ module GoodJob
         def with_advisory_lock_claim(select_limit: nil, &block)
           raise ArgumentError, "Must provide a block" unless block
 
-          advisory_lock(select_limit: select_limit) do |records|
-            record = records.first
-            begin
+          record = nil
+          begin
+            advisory_lock(select_limit: select_limit) do |records|
+              record = records.first
               yield(record)
-            ensure
-              record&.run_callbacks(:perform_unlocked)
             end
+          ensure
+            # Runs after the advisory lock is released. A failed completion leaves the
+            # row lock in the database and may leave unsaved completion fields on the
+            # record, which batch callbacks would act on.
+            record.run_callbacks(:perform_unlocked) if record && (record.destroyed? || record.locked_by_id_in_database.nil?)
           end
         end
 
@@ -40,30 +49,7 @@ module GoodJob
         # @yield [GoodJob::Job, nil] The claimed record, or nil if none found
         # @return [Object] The return value of the block
         def with_skip_locked_claim(locked_by_id:, locked_at:, lock_type:, &block)
-          raise ArgumentError, "Must provide a block" unless block
-
-          candidate_sql = select(:id).lock("FOR NO KEY UPDATE SKIP LOCKED").to_sql
-          materialized = supports_cte_materialization_specifiers? ? "MATERIALIZED " : ""
-
-          sql = <<~SQL.squish
-            WITH candidate AS #{materialized}(#{candidate_sql})
-            UPDATE #{quoted_table_name}
-            SET locked_by_id = ?,
-                locked_at = ?,
-                lock_type = ?
-            FROM candidate
-            WHERE #{quoted_table_name}.id = candidate.id
-            RETURNING #{quoted_table_name}.*
-          SQL
-
-          record = unscoped.find_by_sql([sql, locked_by_id, locked_at, lock_types[lock_type.to_s]]).first
-
-          begin
-            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)
-          end
+          with_row_lock_claim(locked_by_id: locked_by_id, locked_at: locked_at, lock_type: lock_type, &block)
         end
 
         # Atomically claims a job using SELECT FOR NO KEY UPDATE SKIP LOCKED with an
@@ -77,13 +63,21 @@ module GoodJob
         # @yield [GoodJob::Job, nil] The claimed record, or nil if none found
         # @return [Object] The return value of the block
         def with_hybrid_lock_claim(locked_by_id:, locked_at:, lock_type:, &block)
-          raise ArgumentError, "Must provide a block" unless block
+          with_row_lock_claim(locked_by_id: locked_by_id, locked_at: locked_at, lock_type: lock_type, advisory: true, &block)
+        end
 
-          lease_connection # sticky connection; advisory lock must outlive this statement
+        private
 
+        def with_row_lock_claim(locked_by_id:, locked_at:, lock_type:, advisory: false, &block)
+          raise ArgumentError, "Must provide a block" unless block
+
+          connection = lease_connection if advisory # retain the session holding the advisory lock
           candidate_sql = select(:id).lock("FOR NO KEY UPDATE SKIP LOCKED").to_sql
-          advisory_lock_expr = "('x' || substr(md5(#{_quoted_table_name_string} || '-' || id::text), 1, 16))::bit(64)::bigint"
           materialized = supports_cte_materialization_specifiers? ? "MATERIALIZED " : ""
+          candidate_filter = if advisory
+                               advisory_key = advisory_lock_bigint_sql("#{_quoted_table_name_string} || '-' || id::text")
+                               "WHERE pg_try_advisory_lock(#{advisory_key})"
+                             end
 
           sql = <<~SQL.squish
             WITH candidate AS #{materialized}(#{candidate_sql})
@@ -91,26 +85,57 @@ module GoodJob
             SET locked_by_id = ?,
                 locked_at = ?,
                 lock_type = ?
-            FROM (
-              SELECT id FROM candidate
-              WHERE pg_try_advisory_lock(#{advisory_lock_expr})
-            ) AS locked
+            FROM (SELECT id FROM candidate #{candidate_filter}) AS locked
             WHERE #{quoted_table_name}.id = locked.id
             RETURNING #{quoted_table_name}.*
           SQL
 
           record = unscoped.find_by_sql([sql, locked_by_id, locked_at, lock_types[lock_type.to_s]]).first
-          record_advisory_lock(lease_connection, record.lockable_column_key, cte: true) if record
+          record_advisory_lock(connection, record.lockable_column_key, cte: true) if advisory && record
 
+          completed = false
           begin
-            unscoped { yield(record) }
+            result = unscoped { yield(record) }
+            completed = true
+            result
           ensure
-            if record
-              record.advisory_unlock
-              record.update(locked_by_id: nil, locked_at: nil, lock_type: nil) if !record.destroyed? && record.locked_by_id.present?
+            begin
+              record.advisory_unlock(connection: connection) if advisory && record
+            ensure
+              # A failed completion may have cleared the attributes in memory only.
+              if record && (!completed || (!record.destroyed? && record.locked_by_id_in_database.present?))
+                released = release_lock_claim(record, locked_by_id: locked_by_id, locked_at: locked_at)
+                completed &&= released
+              end
+            end
+            record&.run_callbacks(:perform_unlocked) if completed
+          end
+        end
+
+        def release_lock_claim(record, locked_by_id:, locked_at:)
+          transaction do
+            # Match the original claim, including its time, so a newer execution is untouched.
+            released = unscoped.where(id: record.id, locked_by_id: locked_by_id, locked_at: locked_at)
+                               .update_all(locked_by_id: nil, locked_at: nil, lock_type: nil) # rubocop:disable Rails/SkipsModelValidations
+            if released.positive?
+              GoodJob::ConcurrencyClaim.release_job(record.id) if GoodJob::ConcurrencyClaim.table_exists?
+              record.reload
             end
-            record&.run_callbacks(:perform_unlocked)
+            released.positive?
           end
+        rescue StandardError => e
+          connection_errors = %w[ActiveRecord::ConnectionNotEstablished ActiveRecord::ConnectionFailed PG::ConnectionBad PG::UnableToSend].filter_map(&:safe_constantize)
+          cause = e.is_a?(ActiveRecord::StatementInvalid) ? e.cause : nil # older Rails wraps PG connection errors
+          raise unless connection_errors.any? { |klass| e.is_a?(klass) || cause.is_a?(klass) }
+          # Once the process is exiting, its stale process record lets cleanup release the claim.
+          return false if Thread.current.status == "aborting" || GoodJob.current_thread_shutting_down?
+
+          # Keep the worker registered until its claim can be released. Otherwise a
+          # live process can keep the abandoned job locked indefinitely.
+          attempts = (attempts || 0) + 1
+          GoodJob.logger.warn("GoodJob could not release the claim on job #{record.id} (attempt #{attempts}): #{e.class}: #{e.message}. Retrying every #{RELEASE_CLAIM_RETRY_INTERVAL} seconds.") if attempts == 1 || (attempts % RELEASE_CLAIM_RETRY_WARNING_EVERY).zero?
+          sleep RELEASE_CLAIM_RETRY_INTERVAL
+          retry
         end
       end
     end

data/app/models/good_job/job.rb

@@ -6,6 +6,7 @@ module GoodJob
     include AdvisoryLockable
     include Job::Lockable
     include ErrorEvents
+    include FilteredArguments
     include Filterable
     include Reportable
 
@@ -622,6 +623,7 @@ module GoodJob
     # @return [Hash]
     def display_serialized_params
       serialized_params.merge({
+                                "arguments" => display_arguments,
                                 _good_job: attributes.except('serialized_params', 'locktype', 'owns_advisory_lock'),
                               })
     end

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

@@ -0,0 +1,11 @@
+<%= content_tag "turbo-frame", id: dom_id(@execution, :full_trace) do %>
+  <div class="small">
+    <code class="text-wrap text-break m-0 text-secondary-emphasis">
+      <%= safe_join(@execution.error_backtrace || [], tag.br) %>
+    </code>
+  </div>
+<% end %>
+
+<%= content_tag "turbo-frame", id: dom_id(@execution, :serialized_params) do %>
+  <%= tag.pre JSON.pretty_generate(truncate_display_value(@execution.display_serialized_params)) %>
+<% end %>

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

@@ -58,11 +58,7 @@
                 </div>
               <% end %>
               <%= tag.div class: "tab-pane fade", id: dom_id(execution, :full_pane), role: "tabpane", aria: { labelledby: dom_id(execution, :full) }, tabindex: 0 do %>
-                <div class="small">
-                  <code class="text-wrap text-break m-0 text-secondary-emphasis">
-                    <%= safe_join(execution.error_backtrace, tag.br) %>
-                  </code>
-                </div>
+                <%= content_tag "turbo-frame", "", id: dom_id(execution, :full_trace), src: job_execution_path(@job.id, execution.id), loading: "lazy" %>
               <% end %>
             <% end %>
           <% end %>
@@ -70,7 +66,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(truncate_display_value(execution.display_serialized_params)) %>
+        <%= content_tag "turbo-frame", "", id: dom_id(execution, :serialized_params), src: job_execution_path(@job.id, execution.id), loading: "lazy" %>
       <% end %>
     <% end %>
   </div>

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

@@ -85,7 +85,7 @@
     <% end %>
   </h5>
 </div>
-<%= tag.pre @job.serialized_params["arguments"].map { |argument| truncate_display_value(argument).inspect }.join(', '), class: 'text-wrap text-break' %>
+<%= tag.pre @job.display_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(truncate_display_value(@job.display_serialized_params)) %>

data/config/brakeman.ignore

@@ -119,25 +119,25 @@
     {
       "warning_type": "SQL Injection",
       "warning_code": 0,
-      "fingerprint": "e3cc5489d3e3e81f35347b7530d5743fbac8491ab612ceec0d034e22656269ed",
+      "fingerprint": "3f2f0feed3442f5946899d5884a014ecb86894269ac9685db90eeeb6f3a06f48",
       "check_name": "SQL",
       "message": "Possible SQL injection",
       "file": "app/models/good_job/job/lockable.rb",
-      "line": 102,
+      "line": 80,
       "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]])",
+      "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 (SELECT id FROM candidate #{if advisory then\n  advisory_key = advisory_lock_bigint_sql(\"#{_quoted_table_name_string} || '-' || id::text\")\n  \"WHERE pg_try_advisory_lock(#{advisory_lock_bigint_sql(\"#{_quoted_table_name_string} || '-' || id::text\")})\"\nend}) 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"
+        "method": "with_row_lock_claim"
       },
-      "user_input": "_quoted_table_name_string",
+      "user_input": "if advisory then\n  advisory_key = advisory_lock_bigint_sql(\"#{_quoted_table_name_string} || '-' || id::text\")\n  \"WHERE pg_try_advisory_lock(#{advisory_lock_bigint_sql(\"#{_quoted_table_name_string} || '-' || id::text\")})\"\nend",
       "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."
+      "note": "Claim query refactored into with_row_lock_claim. Table names are Rails-quoted; candidate SQL is Rails-generated; the optional advisory predicate uses only the configured hash and an escaped table name. All varying claim values are bound. No untrusted SQL input."
     }
   ],
   "brakeman_version": "8.0.4"

data/config/locales/pt-BR.yml

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

data/config/routes.rb

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

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

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

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

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