good_job 4.20.0 → 4.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96a4cd91def79d6e98d59849112ee43979d9dd518e252ca693d12c0e71003463
-  data.tar.gz: 5d82aa51b9f049b7655f0e7243ede43df3029011fd5e1f62637fdf193ba2cec3
+  metadata.gz: 735c92664371a084ca36ef44ba7622fabdea3027abe19e64cfd5b39f58bac250
+  data.tar.gz: bd64cac0a29019fa695a54ef7f9d6f6a8ca7f90aa2ecfd0a0da2d59dec0d52bf
 SHA512:
-  metadata.gz: 9301c67f9223407df170c9d8b9c93859d274f6affb36afb2fe948e81f1b704d7d8215510ad1491cf86f83fafecd5cd94a2394f8a793cf995b28f41a326d75086
-  data.tar.gz: 4b6ae502d9030ef467e9c7579ec2da0ccde6ccf35176d7a7a50e1fee13c0463030b9d725c0cd916439cdf58c32c3cf2d0a7bb1bea5c5e790c23110c670c510cf
+  metadata.gz: 23355961d770066f2cba918976485a8557a13b3f714a0b636e63719f3600bb4ad3cc6ad0f78515225a3ff5896befaed5067d87e38efec365190f42e2d4013da0
+  data.tar.gz: 4f53fa0a1efe24d90d91fbf16f42e092e824ac1bff72b3117b2da794896af90c04a1f65aa292ea96346cecb3d5b4fb442c87eef6b186647c6182bacbd706e2c1

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## [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)

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)
@@ -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/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;

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

@@ -207,6 +207,7 @@ module GoodJob
     end
 
     ADVISORY_LOCK_COUNTS = AdvisoryLockCounter.new
+    private_constant :ADVISORY_LOCK_COUNTS
     AREL_TABLE_NEW_KWARGS = Arel::Table.instance_method(:initialize).parameters.any? { |type, name| type == :key && name == :name }
 
     included do
@@ -735,6 +736,18 @@ module GoodJob
       self.class.owns_advisory_lock_key?(key)
     end
 
+    # Tests whether +connection+ currently holds the advisory lock for this record.
+    # Checks both that the connection is still active and that the local bookkeeping
+    # records a lock acquired on it. Does not query the database.
+    # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter, nil]
+    # @param key [String, Symbol] Advisory lock key to check
+    # @return [Boolean]
+    def advisory_lock_active_on?(connection, key: lockable_key)
+      return false unless connection&.active?
+
+      ADVISORY_LOCK_COUNTS.counts_for(connection, key).first.positive?
+    end
+
     # Releases all advisory locks on the record that are held by the current
     # database session.
     # @param key [String, Symbol] Key to lock against

data/app/models/good_job/batch.rb

@@ -390,10 +390,8 @@ module GoodJob
           # Jobs with concurrency limits must be enqueued individually so the
           # before_enqueue concurrency check runs. Mirrors Bulk::Buffer#enqueue
           # partitioning (bulk.rb:95-98).
-          if active_job.respond_to?(:good_job_concurrency_key) &&
-             active_job.good_job_concurrency_key.present? &&
-             (active_job.class.good_job_concurrency_config[:enqueue_limit] ||
-               active_job.class.good_job_concurrency_config[:total_limit])
+          if active_job.respond_to?(:good_job_enqueue_concurrency_controlled?) &&
+             active_job.good_job_enqueue_concurrency_controlled?
             unbulkable << { batch: batch, active_job: active_job }
           else
             good_job = Job.build_for_enqueue(active_job)