good_job 4.19.3 → 4.21.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4d6ba03812a521f55ab70bb95caafb96aba83c049036e9f8cc5d7489f3f8dcc
-  data.tar.gz: 3898461e6eccf9e8c6106b69a41123b82ff2e5a4697205464c60336304b4a5ef
+  metadata.gz: 510354d3834b40133fff5b01cda0ac035f58b327317098467a305ac2ca5372d4
+  data.tar.gz: 0bee2064ac6fc2f6d89c69e22ed3639d07341120a4dfecb0d77e025e94455148
 SHA512:
-  metadata.gz: c924ff049f2b6153f1e7a98f7ff5eb35f68dfecd38079e99d84f535da56628eef67ae453a2b6255759d037f563249f02e4c442eae4a5196fdbf7ca2655f62e39
-  data.tar.gz: a0724d9b3ded29985d5e16958d38ba3cddc90f66d800a0c13e68581f455a338263987ab167e2a8010289786d9917585f1b1627c5657696e84cfd8b90e96f3d9b
+  metadata.gz: ae50900ba6a6db18dc13112a3999a12fc215e1f0f856e761b253fbfa02689ded6a01e3c2bb7aaf776465e822fb7b0ca1d2075dff9c784fc14e62a4ebbec82dcb
+  data.tar.gz: 5b939f61fa88f4dbdfed4ef48bc7ea0d0702e09b01c8e7ca7008e2e9cf4c112568e0a299197eb7985da9fb05e89a81d5d332a4bedbc98aac7dad6268d9f91579

data/CHANGELOG.md

@@ -1,5 +1,92 @@
 # Changelog
 
+## [v4.21.1](https://github.com/bensheldon/good_job/tree/v4.21.1) (2026-10-07)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v4.21.0...v4.21.1)
+
+**Fixed bugs:**
+
+- Fix crash on natural language cron schedules \(v4.21.0 regression\) [\#1853](https://github.com/bensheldon/good_job/pull/1853) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- v4.21.0 regression: undefined method 'next\_time' for an instance of EtOrbi::EoTime [\#1852](https://github.com/bensheldon/good_job/issues/1852)
+
+## [v4.21.0](https://github.com/bensheldon/good_job/tree/v4.21.0) (2026-10-06)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v4.20.0...v4.21.0)
+
+**Implemented enhancements:**
+
+- Enqueue jobs with concurrency rules individually in bulk/batch, and support Lambda class-level labels [\#1851](https://github.com/bensheldon/good_job/pull/1851) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- perform\_limit: 1 permits two same-label jobs to execute concurrently [\#1843](https://github.com/bensheldon/good_job/issues/1843)
+
+**Merged pull requests:**
+
+- Fix: Run the enqueue concurrency check always after the job's other enqueue callbacks [\#1850](https://github.com/bensheldon/good_job/pull/1850) ([bensheldon](https://github.com/bensheldon))
+- Add updated\_at to good\_job\_concurrency\_claims [\#1849](https://github.com/bensheldon/good_job/pull/1849) ([bensheldon](https://github.com/bensheldon))
+- Fix Russian/Ukrainian "one" plurals showing "1" for 21, 31, … and Russian apply\_to\_all text [\#1848](https://github.com/bensheldon/good_job/pull/1848) ([owgreen-dev](https://github.com/owgreen-dev))
+- Deprecate combining label: and key: in concurrency rules [\#1847](https://github.com/bensheldon/good_job/pull/1847) ([bensheldon](https://github.com/bensheldon))
+- Run specs in parallel with parallel\_tests [\#1845](https://github.com/bensheldon/good_job/pull/1845) ([bensheldon](https://github.com/bensheldon))
+- Fix perform\_limit race and promote waiting jobs when a concurrency claim is released [\#1844](https://github.com/bensheldon/good_job/pull/1844) ([bensheldon](https://github.com/bensheldon))
+- Fix Ukrainian x\_minutes "few" form showing "1" for every count [\#1842](https://github.com/bensheldon/good_job/pull/1842) ([owgreen-dev](https://github.com/owgreen-dev))
+- Fix flaky CronManager graceful restart spec at minute boundary [\#1841](https://github.com/bensheldon/good_job/pull/1841) ([bensheldon](https://github.com/bensheldon))
+- Validate cron entry keys and schedules instead of raising [\#1832](https://github.com/bensheldon/good_job/pull/1832) ([shiaho777](https://github.com/shiaho777))
+- Fix concurrency label matching and document dynamic labels [\#1827](https://github.com/bensheldon/good_job/pull/1827) ([shiaho777](https://github.com/shiaho777))
+- Add queue and total latency to the Performance dashboard [\#1812](https://github.com/bensheldon/good_job/pull/1812) ([dennispaagman](https://github.com/dennispaagman))
+- Remove connection overrides from process heartbeats [\#1763](https://github.com/bensheldon/good_job/pull/1763) ([bensheldon](https://github.com/bensheldon))
+
+## [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)
+
+**Merged pull requests:**
+
+- fix: Render batch details with JSON 3 [\#1839](https://github.com/bensheldon/good_job/pull/1839) ([luizkowalski](https://github.com/luizkowalski))
+
 ## [v4.19.3](https://github.com/bensheldon/good_job/tree/v4.19.3) (2026-09-21)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v4.19.2...v4.19.3)

data/README.md

@@ -47,6 +47,7 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
         - [Extending dashboard views](#extending-dashboard-views)
     - [Job priority](#job-priority)
     - [Concurrency controls](#concurrency-controls)
+        - [Dynamic labels](#dynamic-labels)
         - [How concurrency controls work](#how-concurrency-controls-work)
     - [Cron-style repeating/recurring jobs](#cron-style-repeatingrecurring-jobs)
     - [Bulk enqueue](#bulk-enqueue)
@@ -308,7 +309,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`.
@@ -561,9 +562,10 @@ class MyJob < ApplicationJob
   # exceeded rule short-circuits the rest.
   good_job_concurrency_rule(
     # A label that scopes this rule. Can be a static String or a Lambda/Proc
-    # invoked in the context of the job instance. The rule only applies to jobs
-    # that were enqueued with this label in `good_job_labels`.
-    label: -> { arguments.first[:user_id] },
+    # invoked in the context of the job instance (see "Dynamic labels" below).
+    # The rule only applies to jobs that were enqueued with this label in
+    # `good_job_labels`.
+    label: "email",
 
     # Maximum number of unfinished jobs with this label to allow.
     # Can be an Integer or Lambda/Proc invoked in the context of the job.
@@ -595,7 +597,7 @@ class MyJob < ApplicationJob
   good_job_concurrency_rule(...)
   good_job_concurrency_rule(...)
 
-  def perform(user_id:)
+  def perform
     # do work
   end
 end
@@ -604,16 +606,71 @@ end
 Jobs must be enqueued with the matching label for rules to take effect:
 
 ```ruby
-MyJob.set(good_job_labels: [current_user.id]).perform_later(user_id: current_user.id)
+MyJob.set(good_job_labels: ["email"]).perform_later
 ```
 
+Supplying both `label:` and `key:` to `good_job_concurrency_rule` is deprecated. For labelled rules, `key:` is ignored: jobs sharing the label use the same advisory lock for concurrency checks. Remove `key:` from these rules. The legacy `good_job_control_concurrency_with(key: ...)` interface remains supported.
+
+#### Dynamic labels
+
+A rule's `label:` can also be a Lambda/Proc that is invoked in the context of the job instance, for example to derive the label from job arguments. The lambda resolves the label to check against; the job's `good_job_labels` must still contain it for the rule to apply. Rule labels and job labels are converted to strings and stripped of surrounding whitespace when matched, consistent with how labels are stored.
+
+To apply a dynamic label to every job of a class, set a Lambda/Proc in the class-level `good_job_labels`. It is invoked in the context of the job when the job is initialized, so the label is present for checks at both enqueue and perform time:
+
+```ruby
+class MyJob < ApplicationJob
+  include GoodJob::ActiveJobExtensions::Concurrency
+
+  self.good_job_labels = [-> { "user-#{arguments.first[:user_id]}" }]
+
+  good_job_concurrency_rule(
+    label: -> { "user-#{arguments.first[:user_id]}" },
+    total_limit: 1
+  )
+
+  def perform(user_id:)
+    # do work
+  end
+end
+```
+
+Labels can also be applied in a `before_enqueue` callback. They are stored on the job record and checked by the rules:
+
+```ruby
+class MyJob < ApplicationJob
+  include GoodJob::ActiveJobExtensions::Concurrency
+
+  before_enqueue do |job|
+    job.good_job_labels = [job.arguments.first[:user_id].to_s]
+  end
+
+  good_job_concurrency_rule(
+    label: -> { arguments.first[:user_id].to_s },
+    perform_limit: 1
+  )
+
+  def perform(user_id:)
+    # do work
+  end
+end
+```
+
+Rules are checked when a job is enqueued and again when it is performed. The enqueue-time check runs after the job's other `before_enqueue` and `around_enqueue` callbacks, regardless of where they are defined, so labels assigned in those callbacks are present for both checks. Labels can also be passed when enqueuing:
+
+```ruby
+MyJob.set(good_job_labels: [user_id.to_s]).perform_later(user_id: user_id)
+```
+
+Rules apply across job classes to jobs carrying the resolved label. `total_limit` counts unfinished jobs, `enqueue_limit` excludes claimed/performing jobs, and `perform_limit` counts running jobs. Throttles count enqueued jobs or executions within their time window, including finished ones.
+
 #### How concurrency controls work
 
 GoodJob's concurrency control strategy for `perform_limit` is "optimistic retry with an incremental backoff".  The [code is readable](https://github.com/bensheldon/good_job/blob/main/lib/good_job/active_job_extensions/concurrency.rb).
 
 - "Optimistic" meaning that the implementation's performance trade-off assumes that collisions are atypical (e.g. two users enqueue the same job at the same time) rather than regular (e.g. the system enqueues thousands of colliding jobs at the same time). Depending on your concurrency requirements, you may also want to manage concurrency through the number of GoodJob threads and processes that are performing a given queue.
 - "Retry with an incremental backoff" means that when `perform_limit` is exceeded, the job will raise a `GoodJob::ActiveJobExtensions::Concurrency::ConcurrencyExceededError` which is caught by a `retry_on` handler which re-schedules the job to execute in the near future with an incremental backoff.
-- First-in-first-out job execution order is not preserved when a job is retried with incremental back-off.
+- When the `good_job_concurrency_claims` table has been migrated, a job that exceeded `perform_limit` waits on the limit's key, and when a job holding that key finishes, the longest-waiting job is re-scheduled to run immediately rather than waiting for its backoff. The incremental backoff remains as a fallback.
+- First-in-first-out job execution order is not strictly preserved: a waiting job that is re-scheduled can be overtaken by a newly enqueued job, and jobs retried with incremental back-off run in backoff order.
 - For pessimistic usecases that collisions are expected, use number of threads/processes (e.g., `good_job --queues "serial:1;-serial:5"`) to control concurrency. It is also a good idea to use `perform_limit` as backstop.
 
 #### Legacy: `good_job_control_concurrency_with`

data/app/charts/good_job/latency_metric/base.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module GoodJob
+  module LatencyMetric
+    # A measurement the Performance charts can plot. Subclasses supply a SQL
+    # expression over +good_job_executions+, the aggregate that summarizes it per
+    # time bucket, and their titles.
+    class Base
+      def expression = self.class::EXPRESSION
+
+      def to_arel = Arel.sql(expression)
+
+      # nil plots an empty bucket as a gap; a summed metric overrides this with a true zero.
+      def empty_value = nil
+
+      def to_params = { PARAMETER_KEY => key.to_s }
+
+      def span_gaps? = empty_value.nil?
+    end
+  end
+end

data/app/charts/good_job/latency_metric/execution.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module GoodJob
+  module LatencyMetric
+    # How long jobs took to run. Summed across a bucket because total execution time
+    # is a measure of load.
+    class Execution < Base
+      EXPRESSION = "duration"
+
+      def key = :execution
+
+      def aggregate = "SUM"
+
+      def presence_sql = "duration IS NOT NULL"
+
+      def empty_value = 0
+
+      # The default metric stays out of navigation URLs.
+      def to_params = {}
+
+      def chart_title = I18n.t("good_job.performance.index.chart_title")
+
+      def histogram_title = I18n.t("good_job.performance.show.execution_chart_title")
+    end
+  end
+end

data/app/charts/good_job/latency_metric/queue.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module GoodJob
+  module LatencyMetric
+    # How long jobs waited between becoming eligible and actually starting, the same
+    # quantity as GoodJob::Execution#queue_latency. Averaged across a bucket because a
+    # summed wait would grow with volume alone.
+    class Queue < Base
+      EXPRESSION = "(created_at - scheduled_at)"
+
+      def key = :queue
+
+      def aggregate = "AVG"
+
+      def presence_sql = "scheduled_at IS NOT NULL"
+
+      def chart_title = I18n.t("good_job.performance.index.chart_title_queue")
+
+      def histogram_title = I18n.t("good_job.performance.show.queue_chart_title")
+    end
+  end
+end

data/app/charts/good_job/latency_metric/total.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module GoodJob
+  module LatencyMetric
+    # How long jobs took end to end: the wait before starting plus the run itself.
+    # Averaged across a bucket for the same reason as Queue.
+    class Total < Base
+      # NULL while an execution is still running, so the aggregates skip it rather than count zero.
+      EXPRESSION = "(#{GoodJob::LatencyMetric::Queue::EXPRESSION} + #{GoodJob::LatencyMetric::Execution::EXPRESSION})".freeze
+
+      def key = :total
+
+      def aggregate = "AVG"
+
+      def presence_sql = "scheduled_at IS NOT NULL AND duration IS NOT NULL"
+
+      def chart_title = I18n.t("good_job.performance.index.chart_title_total")
+
+      def histogram_title = I18n.t("good_job.performance.show.total_chart_title")
+    end
+  end
+end

data/app/charts/good_job/latency_metric.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module GoodJob
+  # The measurements the Performance charts plot and the index tables aggregate.
+  module LatencyMetric
+    PARAMETER_KEY = :chart
+
+    def self.options
+      [
+        GoodJob::LatencyMetric::Execution.new,
+        GoodJob::LatencyMetric::Queue.new,
+        GoodJob::LatencyMetric::Total.new,
+      ]
+    end
+
+    def self.default = options.first
+
+    def self.table_aggregates_sql
+      <<~SQL.squish
+        COUNT(DISTINCT active_job_id) AS jobs_count,
+        COUNT(*) AS executions_count,
+        AVG(#{GoodJob::LatencyMetric::Queue::EXPRESSION}) AS avg_queue,
+        MIN(#{GoodJob::LatencyMetric::Queue::EXPRESSION}) AS min_queue,
+        MAX(#{GoodJob::LatencyMetric::Queue::EXPRESSION}) AS max_queue,
+        AVG(#{GoodJob::LatencyMetric::Execution::EXPRESSION}) AS avg_execution,
+        MIN(#{GoodJob::LatencyMetric::Execution::EXPRESSION}) AS min_execution,
+        MAX(#{GoodJob::LatencyMetric::Execution::EXPRESSION}) AS max_execution,
+        AVG(#{GoodJob::LatencyMetric::Total::EXPRESSION}) AS avg_total,
+        MIN(#{GoodJob::LatencyMetric::Total::EXPRESSION}) AS min_total,
+        MAX(#{GoodJob::LatencyMetric::Total::EXPRESSION}) AS max_total
+      SQL
+    end
+
+    # Compare as strings: the value is whatever the query string held, so array- and
+    # hash-valued input has to fall through to the default rather than be coerced.
+    def self.from_params(params)
+      key = params[PARAMETER_KEY]
+
+      options.find { |metric| metric.key.to_s == key } || default
+    end
+  end
+end

data/app/charts/good_job/performance_index_chart.rb

@@ -2,9 +2,10 @@
 
 module GoodJob
   class PerformanceIndexChart < BaseChart
-    def initialize(range = GoodJob::PerformanceRange.new)
+    def initialize(range = GoodJob::PerformanceRange.new, metric = GoodJob::LatencyMetric.default)
       super()
       @range = range
+      @metric = metric
     end
 
     def data
@@ -14,7 +15,7 @@ module GoodJob
         start_expression: "range_parameters.series_start_time",
         interval_expression: "range_parameters.interval_seconds"
       )
-      inner_sql = @range.apply(GoodJob::Execution).select(:job_class, :scheduled_at, :duration).to_sql
+      inner_sql = @range.apply(GoodJob::Execution).select(:job_class, :scheduled_at, @metric.to_arel.as("metric_value")).to_sql
 
       # Keep each bind placeholder single-use because JDBC binds every converted occurrence.
       sum_query = <<~SQL.squish
@@ -34,7 +35,7 @@ module GoodJob
           SELECT
             #{bucket_sql} AS scheduled_at,
             job_class,
-            SUM(duration) AS sum
+            #{@metric.aggregate}(metric_value) AS value
           FROM (#{inner_sql}) executions
           CROSS JOIN range_parameters
           GROUP BY #{bucket_sql}, job_class
@@ -47,16 +48,16 @@ module GoodJob
 
       executions_data = GoodJob::Job.connection_pool.with_connection { |conn| conn.exec_query(GoodJob::Job.pg_or_jdbc_query(sum_query), "GoodJob Performance Chart", binds) }
 
-      job_names = executions_data.reject { |d| d['sum'].nil? }.map { |d| d['job_class'] || BaseFilter::EMPTY }.uniq
+      job_names = executions_data.reject { |d| d['value'].nil? }.map { |d| d['job_class'] || BaseFilter::EMPTY }.uniq
       timestamp_values = []
       timestamps = []
       jobs_data = executions_data.to_a.group_by { |d| d['timestamp'] }.each_with_object({}) do |(timestamp, values), hash|
         timestamp_values << timestamp
         timestamps << @range.canonical_timestamp(timestamp)
         job_names.each do |job_class|
-          sum = values.find { |d| d['job_class'] == job_class }&.[]('sum')
-          duration = sum ? ActiveSupport::Duration.parse(sum).to_f : 0
-          (hash[job_class] ||= []) << duration
+          value = values.find { |d| d['job_class'] == job_class }&.[]('value')
+          seconds = value ? ActiveSupport::Duration.parse(value).to_f : @metric.empty_value
+          (hash[job_class] ||= []) << seconds
         end
       end
       labels = @range.chart_timestamp_labels(timestamp_values)
@@ -72,6 +73,7 @@ module GoodJob
               data: data,
               backgroundColor: string_to_hsl(label),
               borderColor: string_to_hsl(label),
+              spanGaps: @metric.span_gaps?,
             }
           end,
         },
@@ -79,7 +81,7 @@ module GoodJob
           plugins: {
             title: {
               display: true,
-              text: I18n.t("good_job.performance.index.chart_title"),
+              text: @metric.chart_title,
             },
             legend: {
               vertical: true,

data/app/charts/good_job/performance_show_chart.rb

@@ -12,26 +12,28 @@ module GoodJob
       10**8 # About 3 years
     ].freeze
 
-    def initialize(job_class, range = GoodJob::PerformanceRange.new)
+    def initialize(job_class, range = GoodJob::PerformanceRange.new, metric = GoodJob::LatencyMetric.default)
       super()
       @job_class = job_class
       @range = range
+      @metric = metric
     end
 
     def data
       table_name = GoodJob::Execution.table_name
 
       interval_entries = BUCKET_INTERVALS.map { "interval '#{_1}'" }.join(",")
+      bucket_expression = "WIDTH_BUCKET(#{@metric.expression}, ARRAY[#{interval_entries}])"
       sum_query = <<~SQL.squish
         SELECT
-          WIDTH_BUCKET(duration, ARRAY[#{interval_entries}]) as bucket_index,
-          COUNT(WIDTH_BUCKET(duration, ARRAY[#{interval_entries}])) AS count
+          #{bucket_expression} as bucket_index,
+          COUNT(#{bucket_expression}) AS count
         FROM #{table_name} sources
         WHERE
           scheduled_at >= $1::timestamp
           AND scheduled_at < $2::timestamp
           AND job_class = $3
-          AND duration IS NOT NULL
+          AND #{@metric.presence_sql}
         GROUP BY bucket_index
       SQL
 
@@ -60,6 +62,12 @@ module GoodJob
           }],
         },
         options: {
+          plugins: {
+            title: {
+              display: true,
+              text: @metric.histogram_title,
+            },
+          },
           scales: {
             y: {
               beginAtZero: true,

data/app/controllers/good_job/performance_controller.rb

@@ -6,30 +6,20 @@ module GoodJob
 
     def index
       executions = @performance_range.apply(GoodJob::Execution)
+      aggregates = GoodJob::LatencyMetric.table_aggregates_sql
 
-      @performances = executions.group(:job_class).select("
-        job_class,
-        COUNT(*) AS executions_count,
-        AVG(duration) AS avg_duration,
-        MIN(duration) AS min_duration,
-        MAX(duration) AS max_duration
-      ").order(:job_class)
-
-      @queue_performances = executions.group(:queue_name).select("
-        queue_name,
-        COUNT(*) AS executions_count,
-        AVG(duration) AS avg_duration,
-        MIN(duration) AS min_duration,
-        MAX(duration) AS max_duration
-      ").order(:queue_name)
-
-      @chart_data = GoodJob::PerformanceIndexChart.new(@performance_range).data
+      @performances = executions.group(:job_class).select("job_class, #{aggregates}").order(:job_class)
+      @queue_performances = executions.group(:queue_name).select("queue_name, #{aggregates}").order(:queue_name)
+
+      @chart_data = GoodJob::PerformanceIndexChart.new(@performance_range, @chart_metric).data
     end
 
     def show
       representative_job = GoodJob::Job.find_by!(job_class: request.path_parameters.fetch(:id))
       @job_class = representative_job.job_class
-      @chart_data = GoodJob::PerformanceShowChart.new(@job_class, @performance_range).data
+      @charts = GoodJob::LatencyMetric.options.to_h do |metric|
+        [metric.key, GoodJob::PerformanceShowChart.new(@job_class, @performance_range, metric).data]
+      end
     end
 
     private
@@ -38,10 +28,14 @@ module GoodJob
       locale = request.query_parameters["locale"]
       @performance_range_context = locale.is_a?(String) ? { "locale" => locale } : {}
       @performance_range = GoodJob::PerformanceRange.new(params, query_string: request.query_string)
+      # Only the index chart is metric-switchable; show renders every metric.
+      @chart_metric = GoodJob::LatencyMetric.from_params(params)
+      @chart_metric_params = action_name == "index" ? @chart_metric.to_params : {}
       return if @performance_range.canonical_parameters?(request.query_parameters)
 
       canonical_query = @performance_range.to_params.symbolize_keys
       canonical_query[:locale] = @performance_range_context["locale"]
+      canonical_query.merge!(@chart_metric_params.symbolize_keys)
       canonical_path = if action_name == "show"
                          performance_path(request.path_parameters.fetch(:id), canonical_query)
                        else

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/frontend/good_job/style.css

@@ -88,6 +88,11 @@
   min-width: 14rem;
 }
 
+/* Grid cells default to min-width:auto, so a wide header label would grow its column instead of wrapping. */
+.performance-row > * {
+  min-width: 0;
+}
+
 .performance-name {
   overflow-wrap: anywhere;
   white-space: normal;