good_job 3.26.1 → 3.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eedb4c5defcfa2e25d62147f5021bb868ee0a93b74ae680c46ea4e852212d0dc
-  data.tar.gz: d0124daaa3d93e7ace5b0764031c44cc06b03559286ebf1e5a36936e414bb50d
+  metadata.gz: 2b3817133850acc5176086af47b774bcb80a6ead4ee11e1121a10b23b5c7adb0
+  data.tar.gz: 0d8d3412835f37b23122a821d7f1ea1f20120a1e1893d29fadcd6e6b8697bce5
 SHA512:
-  metadata.gz: 15c9fbd5228a60caa7a1d13ec9e6165c1a78ea488a9e7dd992cf60339dfb9523ca8cc68efa0588dddf16f491bf065a878837d943355a7bcae8ba80ec998615d4
-  data.tar.gz: aea808fb1eb1ce99c9de4b15c429dc8128d7eee29445a1ca5172498d9f919f8596f28416e2967c41d4bcb6e389e098db90f865e9dce1870229131aaa28212930
+  metadata.gz: 984697d136c831db59efdd76f8ca3fc820263de06bdcfe7650f685d75ee0ef64cc3e4c39aa2919b84273b15bb15689bc1fb47afce99a597035266c70372a7c65
+  data.tar.gz: f6f5942330d621fd89cc951a0f6731aa87578725f5959c9dfcf13c99252952e9c610385afcb03cc17a8bdeeb6a126d607e18c910b66353c01c941eb8e0a6c515

data/CHANGELOG.md

@@ -1,5 +1,48 @@
 # Changelog
 
+## [v3.27.0](https://github.com/bensheldon/good_job/tree/v3.27.0) (2024-03-24)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v3.26.2...v3.27.0)
+
+**Implemented enhancements:**
+
+- Add `enabled_by_default: false` as option for cron configuration [\#1289](https://github.com/bensheldon/good_job/pull/1289) ([bensheldon](https://github.com/bensheldon))
+- Load metrics for job statuses asynchronously [\#1286](https://github.com/bensheldon/good_job/pull/1286) ([binarygit](https://github.com/binarygit))
+- Implement throttling options in concurrency extension [\#1270](https://github.com/bensheldon/good_job/pull/1270) ([marckohlbrugge](https://github.com/marckohlbrugge))
+
+**Fixed bugs:**
+
+- fix\(ui-dropdown\): use dropdown-end on locales dropdown [\#1296](https://github.com/bensheldon/good_job/pull/1296) ([WailanTirajoh](https://github.com/WailanTirajoh))
+
+**Closed issues:**
+
+- Disabling probe [\#1290](https://github.com/bensheldon/good_job/issues/1290)
+- Set an implicit order on models [\#1242](https://github.com/bensheldon/good_job/issues/1242)
+
+**Merged pull requests:**
+
+- docs\(readme\): remove double "using" [\#1295](https://github.com/bensheldon/good_job/pull/1295) ([WailanTirajoh](https://github.com/WailanTirajoh))
+- Set an implicit order on models [\#1293](https://github.com/bensheldon/good_job/pull/1293) ([mec](https://github.com/mec))
+- CI: install gems after loading cache, not before [\#1288](https://github.com/bensheldon/good_job/pull/1288) ([bensheldon](https://github.com/bensheldon))
+- Ensure job execution Advisory Lock query uses bind parameters [\#1287](https://github.com/bensheldon/good_job/pull/1287) ([bensheldon](https://github.com/bensheldon))
+
+## [v3.26.2](https://github.com/bensheldon/good_job/tree/v3.26.2) (2024-03-15)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v3.26.1...v3.26.2)
+
+**Closed issues:**
+
+- Async mode blocks ActionDispatch::Reloader [\#1274](https://github.com/bensheldon/good_job/issues/1274)
+
+**Merged pull requests:**
+
+- Update dependencies and their Sorbet / Tapioca files [\#1284](https://github.com/bensheldon/good_job/pull/1284) ([bensheldon](https://github.com/bensheldon))
+- Use require\_relative and do not modify $LOAD\_PATH in gemspec [\#1283](https://github.com/bensheldon/good_job/pull/1283) ([bensheldon](https://github.com/bensheldon))
+- Tweak rbtrace script [\#1279](https://github.com/bensheldon/good_job/pull/1279) ([bensheldon](https://github.com/bensheldon))
+- Fix for Rails head: Don't try to override connection on connection checkin in tests [\#1277](https://github.com/bensheldon/good_job/pull/1277) ([bensheldon](https://github.com/bensheldon))
+- Tiny improvements to french translation [\#1273](https://github.com/bensheldon/good_job/pull/1273) ([francois-ferrandis](https://github.com/francois-ferrandis))
+- Load metrics for top nav asynchronously [\#1231](https://github.com/bensheldon/good_job/pull/1231) ([binarygit](https://github.com/binarygit))
+
 ## [v3.26.1](https://github.com/bensheldon/good_job/tree/v3.26.1) (2024-03-01)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v3.26.0...v3.26.1)

data/README.md

@@ -127,7 +127,7 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
     - Because of Rails deferred autoloading, jobs enqueued via the `rails console` may not begin executing on a separate server process until the Rails application is fully initialized by loading a web page once.
     - Remember, only Active Job's `perform_later` sends jobs to the queue adapter; Active Job's `perform_now` executes the job immediately and does not invoke the queue adapter. GoodJob is not involved in `perform_now` jobs.
 1. **In Rails' test environment**, by default, GoodJob's Adapter executes jobs `inline` immediately in the current thread.
-    - Future-scheduled jobs can be executed with `GoodJob.perform_inline` using using a tool like Timecop or `ActiveSupport::Testing::TimeHelpers`.
+    - Future-scheduled jobs can be executed with `GoodJob.perform_inline` using a tool like Timecop or `ActiveSupport::Testing::TimeHelpers`.
     - Note that Active Job's TestAdapter, which powers test helpers (e.g. `assert_enqueued_with`), may override GoodJob's Adapter in [some configurations](https://github.com/rails/rails/issues/37270).
 1. **In Rails' production environment**, by default, GoodJob's Adapter enqueues jobs in `external` mode to be executed by a separate execution process:
     - By default, GoodJob separates job enqueuing from job execution so that jobs can be scaled independently of the web server.  Use the GoodJob command-line tool to execute jobs:
@@ -541,6 +541,16 @@ class MyJob < ApplicationJob
     # Can be an Integer or Lambda/Proc that is invoked in the context of the job
     perform_limit: 1,
 
+    # Maximum number of jobs with the concurrency key to be enqueued within
+    # the time period, looking backwards from the current time. Must be an array
+    # with two elements: the number of jobs and the time period.
+    enqueue_throttle: [10, 1.minute],
+
+    # Maximum number of jobs with the concurrency key to be performed within
+    # the time period, looking backwards from the current time. Must be an array
+    # with two elements: the number of jobs and the time period.
+    perform_throttle: [100, 1.hour],
+
     # Note: Under heavy load, the total number of jobs may exceed the
     # sum of `enqueue_limit` and `perform_limit` because of race conditions
     # caused by imperfectly disjunctive states. If you need to constrain
@@ -617,9 +627,10 @@ config.good_job.cron = {
     set: { priority: -10 }, # additional Active Job properties; can also be a lambda/proc e.g. `-> { { priority: [1,2].sample } }`
     description: "Something helpful", # optional description that appears in Dashboard
   },
-  another_task: {
+  production_task: {
     cron: "0 0,12 * * *",
-    class: "AnotherJob",
+    class: "ProductionJob",
+    enabled_by_default: -> { Rails.env.production? } # Only enable in production, otherwise can be enabled manually through Dashboard
   },
   complex_schedule: {
     class: "ComplexScheduleJob",

data/app/controllers/good_job/metrics_controller.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module GoodJob
+  class MetricsController < ApplicationController
+    def primary_nav
+      jobs_count = GoodJob::Job.count
+      batches_count = GoodJob::BatchRecord.migrated? ? GoodJob::BatchRecord.all.size : 0
+      cron_entries_count = GoodJob::CronEntry.all.size
+      processes_count = GoodJob::Process.active.count
+
+      render json: {
+        jobs_count: number_to_human(jobs_count),
+        batches_count: number_to_human(batches_count),
+        cron_entries_count: number_to_human(cron_entries_count),
+        processes_count: number_to_human(processes_count),
+      }
+    end
+
+    def job_status
+      @filter = JobsFilter.new(params)
+
+      render json: @filter.states.transform_values { |count| number_with_delimiter(count) }
+    end
+
+    private
+
+    def number_to_human(count)
+      helpers.number_to_human(count, **helpers.translate_hash("good_job.number.human.decimal_units"))
+    end
+
+    def number_with_delimiter(count)
+      helpers.number_with_delimiter(count, **helpers.translate_hash('good_job.number.format'))
+    end
+  end
+end

data/app/filters/good_job/base_filter.rb

@@ -42,6 +42,10 @@ module GoodJob
       raise NotImplementedError
     end
 
+    def state_names
+      raise NotImplementedError
+    end
+
     def to_params(override = {})
       {
         job_class: params[:job_class],

data/app/filters/good_job/jobs_filter.rb

@@ -2,6 +2,10 @@
 
 module GoodJob
   class JobsFilter < BaseFilter
+    def state_names
+      %w[scheduled retried queued running succeeded discarded]
+    end
+
     def states
       @_states ||= begin
         query = filtered_query(params.except(:state))

data/app/frontend/good_job/application.js

@@ -9,8 +9,10 @@ import LivePoll from "live_poll";
 
 import { Application } from "stimulus";
 import ThemeController from "theme_controller";
+import AsyncValuesController from "async_values_controller";
 window.Stimulus = Application.start();
 Stimulus.register("theme", ThemeController)
+Stimulus.register("async-values", AsyncValuesController)
 
 documentReady(function() {
   renderCharts();

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

@@ -0,0 +1,31 @@
+import {Controller} from "stimulus"
+
+// Fetches JSON values from the server and updates the targets with the response.
+export default class extends Controller {
+  static values = {
+    url: String,
+  }
+  static targets = ["value"]
+
+  connect() {
+    this.#fetch();
+  }
+
+  async #fetch() {
+    const data = await fetch(this.urlValue).then(response => response.json())
+    this.valueTargets.forEach((target) => {
+      target.textContent = data[target.dataset['asyncValuesKey']];
+      target.classList.remove('d-none');
+
+      // When `data-async-values-zero-class="css-class"` is set, add `css-class` to the target if the value is "0"
+      if (target.dataset['asyncValuesZeroClass']) {
+        const className = target.dataset['asyncValuesZeroClass'];
+        if (data[target.dataset['asyncValuesKey']] === "0") {
+          target.classList.add(className);
+        } else {
+          target.classList.remove(className);
+        }
+      }
+    });
+  }
+}

data/app/frontend/good_job/style.css

@@ -38,3 +38,7 @@
 .btn-outline-secondary {
   border-color: #ced4da; /* $gray-400 */
 }
+
+.min-w-auto {
+  min-width: auto;
+}

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

@@ -44,13 +44,8 @@ module GoodJob
         cte_table = Arel::Table.new(:rows)
         cte_query = original_query.select(primary_key, column).except(:limit)
         cte_query = cte_query.limit(select_limit) if select_limit
-        cte_type = if supports_cte_materialization_specifiers?
-                     'MATERIALIZED'
-                   else
-                     ''
-                   end
-
-        composed_cte = Arel::Nodes::As.new(cte_table, Arel::Nodes::SqlLiteral.new([cte_type, "(", cte_query.to_sql, ")"].join(' ')))
+        cte_type = supports_cte_materialization_specifiers? ? :MATERIALIZED : :""
+        composed_cte = Arel::Nodes::As.new(cte_table, Arel::Nodes::UnaryOperation.new(cte_type, cte_query.arel))
         query = cte_table.project(cte_table[:id])
                          .with(composed_cte)
                          .where(Arel.sql("#{function}(('x' || substr(md5(#{connection.quote(table_name)} || '-' || #{connection.quote_table_name(cte_table.name)}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(64)::bigint)"))

data/app/models/good_job/batch_record.rb

@@ -7,6 +7,7 @@ module GoodJob
     include AdvisoryLockable
 
     self.table_name = 'good_job_batches'
+    self.implicit_order_column = 'created_at'
 
     has_many :jobs, class_name: 'GoodJob::Job', inverse_of: :batch, foreign_key: :batch_id, dependent: nil
     has_many :executions, class_name: 'GoodJob::Execution', foreign_key: :batch_id, inverse_of: :batch, dependent: nil

data/app/models/good_job/cron_entry.rb

@@ -74,7 +74,7 @@ module GoodJob # :nodoc:
     def enabled?
       return true unless GoodJob::Setting.migrated?
 
-      GoodJob::Setting.cron_key_enabled?(key)
+      GoodJob::Setting.cron_key_enabled?(key, default: enabled_by_default?)
     end
 
     def enable
@@ -132,6 +132,11 @@ module GoodJob # :nodoc:
 
     private
 
+    def enabled_by_default?
+      value = params.fetch(:enabled_by_default, true)
+      value.respond_to?(:call) ? value.call : value
+    end
+
     def cron
       params.fetch(:cron)
     end

data/app/models/good_job/discrete_execution.rb

@@ -5,6 +5,7 @@ module GoodJob # :nodoc:
     include ErrorEvents
 
     self.table_name = 'good_job_executions'
+    self.implicit_order_column = 'created_at'
 
     belongs_to :execution, class_name: 'GoodJob::Execution', foreign_key: 'active_job_id', primary_key: 'active_job_id', inverse_of: :discrete_executions, optional: true
     belongs_to :job, class_name: 'GoodJob::Job', foreign_key: 'active_job_id', primary_key: 'active_job_id', inverse_of: :discrete_executions, optional: true

data/app/models/good_job/execution.rb

@@ -16,6 +16,7 @@ module GoodJob
 
     self.table_name = 'good_jobs'
     self.advisory_lockable_column = 'active_job_id'
+    self.implicit_order_column = 'created_at'
 
     define_model_callbacks :perform
     define_model_callbacks :perform_unlocked, only: :after
@@ -94,7 +95,7 @@ module GoodJob
     # @!method only_scheduled
     # @!scope class
     # @return [ActiveRecord::Relation]
-    scope :only_scheduled, -> { where(arel_table['scheduled_at'].lteq(Time.current)).or(where(scheduled_at: nil)) }
+    scope :only_scheduled, -> { where(arel_table['scheduled_at'].lteq(Arel::Nodes::BindParam.new(ActiveModel::Attribute.with_cast_value("scheduled_at", Time.current, ActiveModel::Type::DateTime.new)))).or(where(scheduled_at: nil)) }
 
     # Order executions by priority (highest priority first).
     # @!method priority_ordered

data/app/models/good_job/job.rb

@@ -26,6 +26,7 @@ module GoodJob
 
     self.primary_key = 'active_job_id'
     self.advisory_lockable_column = 'active_job_id'
+    self.implicit_order_column = 'created_at'
 
     belongs_to :batch, class_name: 'GoodJob::BatchRecord', inverse_of: :jobs, optional: true
     has_many :executions, -> { order(created_at: :asc) }, class_name: 'GoodJob::Execution', foreign_key: 'active_job_id', inverse_of: :job # rubocop:disable Rails/HasManyOrHasOneDependent

data/app/models/good_job/process.rb

@@ -14,6 +14,7 @@ module GoodJob # :nodoc:
     EXPIRED_INTERVAL = 5.minutes
 
     self.table_name = 'good_job_processes'
+    self.implicit_order_column = 'created_at'
 
     cattr_reader :mutex, default: Mutex.new
     cattr_accessor :_current_id, default: nil

data/app/models/good_job/setting.rb

@@ -2,29 +2,48 @@
 
 module GoodJob
   class Setting < BaseRecord
+    CRON_KEYS_ENABLED = "cron_keys_enabled"
     CRON_KEYS_DISABLED = "cron_keys_disabled"
 
     self.table_name = 'good_job_settings'
+    self.implicit_order_column = 'created_at'
 
-    def self.cron_key_enabled?(key)
-      cron_disabled = find_by(key: CRON_KEYS_DISABLED)&.value || []
-      cron_disabled.exclude?(key.to_s)
+    def self.cron_key_enabled?(key, default: true)
+      if default
+        cron_disabled = find_by(key: CRON_KEYS_DISABLED)&.value || []
+        cron_disabled.exclude?(key.to_s)
+      else
+        cron_enabled = find_by(key: CRON_KEYS_ENABLED)&.value || []
+        cron_enabled.include?(key.to_s)
+      end
     end
 
     def self.cron_key_enable(key)
-      setting = GoodJob::Setting.find_by(key: CRON_KEYS_DISABLED)
-      return unless setting&.value&.include?(key.to_s)
+      enabled_setting = find_or_initialize_by(key: CRON_KEYS_ENABLED) do |record|
+        record.value = []
+      end
+      enabled_setting.value << key unless enabled_setting.value.include?(key)
+      enabled_setting.save!
 
-      setting.value.delete(key.to_s)
-      setting.save!
+      disabled_setting = GoodJob::Setting.find_by(key: CRON_KEYS_DISABLED)
+      return unless disabled_setting&.value&.include?(key.to_s)
+
+      disabled_setting.value.delete(key.to_s)
+      disabled_setting.save!
     end
 
     def self.cron_key_disable(key)
-      setting = find_or_initialize_by(key: CRON_KEYS_DISABLED) do |record|
+      enabled_setting = GoodJob::Setting.find_by(key: CRON_KEYS_ENABLED)
+      if enabled_setting&.value&.include?(key.to_s)
+        enabled_setting.value.delete(key.to_s)
+        enabled_setting.save!
+      end
+
+      disabled_setting = find_or_initialize_by(key: CRON_KEYS_DISABLED) do |record|
         record.value = []
       end
-      setting.value << key
-      setting.save!
+      disabled_setting.value << key unless disabled_setting.value.include?(key)
+      disabled_setting.save!
     end
   end
 end

data/app/views/good_job/shared/_filter.erb

@@ -47,16 +47,16 @@
       </div>
     <% end %>
 
-    <ul data-live-poll-region="filter-tabs" class="nav nav-tabs my-3">
+    <ul data-controller="async-values" data-async-values-url-value="<%= metrics_job_status_path %>" data-live-poll-region="filter-tabs" class="nav nav-tabs my-3">
       <li class="nav-item">
         <%= link_to t(".all"), filter.to_params(state: nil), class: "nav-link #{"active" unless params[:state].present?}" %>
       </li>
 
-      <% filter.states.each do |name, count| %>
+      <% filter.state_names.each do |name| %>
         <li class="nav-item">
           <%= link_to filter.to_params(state: name), class: "nav-link #{"active" if params[:state] == name}" do %>
-            <%= t(name, scope: 'good_job.status', count: count) %>
-            <span class="badge bg-primary rounded-pill <%= "bg-secondary" if count == 0 %>"><%= number_with_delimiter(count, t('good_job.number.format')) %></span>
+            <%= t(name, scope: 'good_job.status') %>
+            <span data-async-values-target="value", data-async-values-key="<%= name %>" data-async-values-zero-class="bg-secondary" class="badge bg-primary rounded-pill d-none"></span>
           <% end %>
         </li>
       <% end %>

data/app/views/good_job/shared/_navbar.erb

@@ -14,33 +14,29 @@
     </button>
 
     <div class="collapse navbar-collapse" id="navbarSupportedContent">
-      <ul class="navbar-nav me-auto">
+      <ul class="navbar-nav me-auto" data-controller="async-values" data-async-values-url-value="<%= metrics_primary_nav_path %>">
         <li class="nav-item">
           <%= link_to jobs_path, class: ["nav-link", ("active" if controller_name == 'jobs')] do %>
             <%= t(".jobs") %>
-            <% jobs_count = GoodJob::Job.count %>
-            <span class="badge bg-secondary rounded-pill"><%= number_to_human(jobs_count, **translate_hash("good_job.number.human.decimal_units")) %></span>
+            <span data-async-values-target="value" data-async-values-key="jobs_count" class="badge bg-secondary rounded-pill d-none"></span>
         <% end %>
         </li>
         <li class="nav-item">
           <%= link_to batches_path, class: ["nav-link", ("active" if controller_name == 'batches')] do %>
             <%=t ".batches" %>
-            <% batches_count = GoodJob::BatchRecord.migrated? ? GoodJob::BatchRecord.all.size : 0 %>
-            <span class="badge bg-secondary rounded-pill"><%= number_to_human(batches_count, **translate_hash("good_job.number.human.decimal_units")) %></span>
+            <span data-async-values-target="value" data-async-values-key="batches_count" class="badge bg-secondary rounded-pill  d-none"></span>
           <% end %>
         </li>
         <li class="nav-item">
           <%= link_to cron_entries_path, class: ["nav-link", ("active" if controller_name == 'cron_entries')] do %>
             <%= t(".cron_schedules") %>
-            <% cron_entries_count = GoodJob::CronEntry.all.size %>
-            <span class="badge bg-secondary rounded-pill"><%= cron_entries_count %></span>
+            <span data-async-values-target="value" data-async-values-key="cron_entries_count" class="badge bg-secondary rounded-pill d-none"></span>
         <% end %>
         </li>
         <li class="nav-item">
           <%= link_to processes_path, class: ["nav-link", ("active" if controller_name == 'processes')] do %>
             <%= t(".processes") %>
-            <% processes_count = GoodJob::Process.active.count %>
-            <span class="badge bg-secondary rounded-pill <%= "bg-danger" if processes_count == 0 %>"><%= processes_count %></span>
+            <span data-async-values-target="value" data-async-values-key="processes_count" data-async-values-zero-class="bg-danger" class="badge bg-secondary rounded-pill d-none"></span>
           <% end %>
         </li>
       </ul>
@@ -77,7 +73,7 @@
             <%= I18n.locale %>
           </a>
 
-          <ul class="dropdown-menu" aria-labelledby="localeOptions">
+          <ul class="dropdown-menu dropdown-menu-end min-w-auto" aria-labelledby="localeOptions">
             <% possible_locales = I18n.available_locales %>
             <% possible_locales.reject { |locale| locale == I18n.locale }.each do |locale| %>
               <li><%= link_to locale, url_for(locale: locale), class: "dropdown-item" %></li>

data/config/locales/de.yml

@@ -34,7 +34,7 @@ de:
     cron_entries:
       actions:
         confirm_disable: Möchten Sie diesen Cron-Eintrag wirklich deaktivieren?
-        confirm_enable: Möchten Sie diesen Cron-Eintrag wirklich bestätigen?
+        confirm_enable: Möchten Sie diesen Cron-Eintrag wirklich aktivieren?
         confirm_enqueue: Möchten Sie diesen Cron-Eintrag wirklich in die Warteschlange stellen?
         disable: Cron-Eintrag deaktivieren
         enable: Cron-Eintrag aktivieren

data/config/locales/en.yml

@@ -34,7 +34,7 @@ en:
     cron_entries:
       actions:
         confirm_disable: Are you sure you want to disable this cron entry?
-        confirm_enable: Are you sure you want to confirm this cron entry?
+        confirm_enable: Are you sure you want to enable this cron entry?
         confirm_enqueue: Are you sure you want to enqueue this cron entry?
         disable: Disable cron entry
         enable: Enable cron entry

data/config/locales/es.yml

@@ -34,7 +34,7 @@ es:
     cron_entries:
       actions:
         confirm_disable: "¿Estás seguro que querés deshabilitar esta tarea programada?"
-        confirm_enable: "¿Estás seguro que querés confirmar esta tarea programada?"
+        confirm_enable: "¿Estás seguro que querés habilitar esta tarea programada?"
         confirm_enqueue: "¿Estás seguro que querés encolar esta tarea programada?"
         disable: Deshabilitar tarea programada
         enable: Habilitar tarea programada

data/config/locales/fr.yml

@@ -33,9 +33,9 @@ fr:
         no_batches_found: Aucun lot trouvé.
     cron_entries:
       actions:
-        confirm_disable: Voulez-vous vraiment désactiver cette entrée cron ?
-        confirm_enable: Voulez-vous vraiment activer cette entrée cron ?
-        confirm_enqueue: Voulez-vous vraiment mettre en file d'attente cette entrée cron ?
+        confirm_disable: Voulez-vous vraiment désactiver cette entrée cron?
+        confirm_enable: Voulez-vous vraiment activer cette entrée cron?
+        confirm_enqueue: Voulez-vous vraiment mettre en file d'attente cette entrée cron?
         disable: Désactiver l'entrée cron
         enable: Activer l'entrée cron
         enqueue: Mettre en file d'attente l'entrée cron maintenant
@@ -214,11 +214,11 @@ fr:
         all: Tous
         all_jobs: Tous les jobs
         all_queues: Toutes les files d'attente
-        clear: Clair
+        clear: Réinitialiser
         job_name: Nom du job
         placeholder: Recherche par classe, ID de job, paramètres de job et texte d'erreur.
         queue_name: Nom de la file d'attente
-        search: Recherche
+        search: Rechercher
       navbar:
         batches: Lots
         cron_schedules: Cron
@@ -232,12 +232,12 @@ fr:
           light: Lumière
           theme: Thème
       secondary_navbar:
-        inspiration: N'oublie pas, toi aussi tu fais du bon boulot !
+        inspiration: N'oublie pas, toi aussi tu fais du bon boulot !
         last_updated: Dernière mise à jour
     status:
       discarded: Mis au rebut
       queued: À la file
       retried: Réessayés
       running: En cours
-      scheduled: Replanifiés
+      scheduled: Planifiés
       succeeded: Réussis

data/config/locales/it.yml

@@ -34,7 +34,7 @@ it:
     cron_entries:
       actions:
         confirm_disable: Sei sicuro di voler disabilitare questa voce cron?
-        confirm_enable: Sei sicuro di voler confermare questa voce cron?
+        confirm_enable: Sei sicuro di voler abilita questa voce cron?
         confirm_enqueue: Sei sicuro di voler mettere in coda questa voce cron?
         disable: Disabilita voce cron
         enable: Abilita voce cron

data/config/locales/nl.yml

@@ -34,7 +34,7 @@ nl:
     cron_entries:
       actions:
         confirm_disable: Weet u zeker dat u deze cron-vermelding wilt uitschakelen?
-        confirm_enable: Weet u zeker dat u deze cron-invoer wilt bevestigen?
+        confirm_enable: Weet u zeker dat u deze cron-invoer wilt inschakelen?
         confirm_enqueue: Weet u zeker dat u deze cron-vermelding in de wachtrij wilt plaatsen?
         disable: Schakel cron-invoer uit
         enable: Schakel cron-invoer in

data/config/locales/ru.yml

@@ -34,7 +34,7 @@ ru:
     cron_entries:
       actions:
         confirm_disable: Вы уверены, что хотите отключить эту задачу cron?
-        confirm_enable: Вы уверены, что хотите подтвердить эту задачу cron?
+        confirm_enable: Вы уверены, что хотите включить это задание cron?
         confirm_enqueue: Вы уверены, что хотите поставить эту задачу cron в очередь?
         disable: Отключить задачу cron
         enable: Включить задачу cron

data/config/routes.rb

@@ -16,6 +16,8 @@ GoodJob::Engine.routes.draw do
       put :retry
     end
   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
 
   resources :batches, only: %i[index show]
 

data/lib/good_job/active_job_extensions/concurrency.rb

@@ -13,6 +13,8 @@ module GoodJob
         end
       end
 
+      ThrottleExceededError = Class.new(ConcurrencyExceededError)
+
       module Prepends
         def deserialize(job_data)
           super
@@ -62,8 +64,13 @@ module GoodJob
             total_limit = nil unless total_limit.present? && (0...Float::INFINITY).cover?(total_limit)
           end
 
+          perform_throttle = job.class.good_job_concurrency_config[:perform_throttle]
+          perform_throttle = instance_exec(&perform_throttle) if perform_throttle.respond_to?(:call)
+          perform_throttle = nil unless GoodJob::DiscreteExecution.migrated? && perform_throttle.present? && perform_throttle.is_a?(Array) && perform_throttle.size == 2
+
           limit = perform_limit || total_limit
-          next unless limit
+          throttle = perform_throttle
+          next unless limit || throttle
 
           key = job.good_job_concurrency_key
           next if key.blank?
@@ -74,9 +81,29 @@ module GoodJob
           end
 
           GoodJob::Execution.advisory_lock_key(key, function: "pg_advisory_lock") do
-            allowed_active_job_ids = GoodJob::Execution.unfinished.where(concurrency_key: key).advisory_locked.order(Arel.sql("COALESCE(performed_at, scheduled_at, created_at) ASC")).limit(limit).pluck(:active_job_id)
-            # The current job has already been locked and will appear in the previous query
-            raise GoodJob::ActiveJobExtensions::Concurrency::ConcurrencyExceededError unless allowed_active_job_ids.include? job.job_id
+            if limit
+              allowed_active_job_ids = GoodJob::Execution.unfinished.where(concurrency_key: key)
+                                                         .advisory_locked
+                                                         .order(Arel.sql("COALESCE(performed_at, scheduled_at, created_at) ASC"))
+                                                         .limit(limit).pluck(:active_job_id)
+              # The current job has already been locked and will appear in the previous query
+              raise GoodJob::ActiveJobExtensions::Concurrency::ConcurrencyExceededError unless allowed_active_job_ids.include?(job.job_id)
+            end
+
+            if throttle
+              throttle_limit = throttle[0]
+              throttle_period = throttle[1]
+
+              query = DiscreteExecution.joins(:job)
+                                       .where(GoodJob::Job.table_name => { concurrency_key: key })
+                                       .where(DiscreteExecution.arel_table[:created_at].gt(throttle_period.ago))
+              allowed_active_job_ids = query.where(error: nil).or(query.where.not(error: "GoodJob::ActiveJobExtensions::Concurrency::ThrottleExceededError: GoodJob::ActiveJobExtensions::Concurrency::ThrottleExceededError"))
+                                            .order(created_at: :asc)
+                                            .limit(throttle_limit)
+                                            .pluck(:active_job_id)
+
+              raise ThrottleExceededError unless allowed_active_job_ids.include?(job.job_id)
+            end
           end
         end
       end
@@ -137,23 +164,45 @@ module GoodJob
           total_limit = nil unless total_limit.present? && (0...Float::INFINITY).cover?(total_limit)
         end
 
+        enqueue_throttle = job.class.good_job_concurrency_config[:enqueue_throttle]
+        enqueue_throttle = instance_exec(&enqueue_throttle) if enqueue_throttle.respond_to?(:call)
+        enqueue_throttle = nil unless enqueue_throttle.present? && enqueue_throttle.is_a?(Array) && enqueue_throttle.size == 2
+
         limit = enqueue_limit || total_limit
-        return on_enqueue&.call unless limit
+        throttle = enqueue_throttle
+        return on_enqueue&.call unless limit || throttle
 
         GoodJob::Execution.advisory_lock_key(key, function: "pg_advisory_lock") do
-          enqueue_concurrency = if enqueue_limit
-                                  GoodJob::Execution.where(concurrency_key: key).unfinished.advisory_unlocked.count
-                                else
-                                  GoodJob::Execution.where(concurrency_key: key).unfinished.count
-                                end
-
-          # The job has not yet been enqueued, so check if adding it will go over the limit
-          if (enqueue_concurrency + 1) > limit
-            logger.info "Aborted enqueue of #{job.class.name} (Job ID: #{job.job_id}) because the concurrency key '#{key}' has reached its limit of #{limit} #{'job'.pluralize(limit)}"
-            on_abort&.call
-          else
-            on_enqueue&.call
+          if limit
+            enqueue_concurrency = if enqueue_limit
+                                    GoodJob::Execution.where(concurrency_key: key).unfinished.advisory_unlocked.count
+                                  else
+                                    GoodJob::Execution.where(concurrency_key: key).unfinished.count
+                                  end
+
+            # The job has not yet been enqueued, so check if adding it will go over the limit
+            if (enqueue_concurrency + 1) > limit
+              logger.info "Aborted enqueue of #{job.class.name} (Job ID: #{job.job_id}) because the concurrency key '#{key}' has reached its enqueue limit of #{limit} #{'job'.pluralize(limit)}"
+              on_abort&.call
+              break
+            end
           end
+
+          if throttle
+            throttle_limit = throttle[0]
+            throttle_period = throttle[1]
+            enqueued_within_period = GoodJob::Job.where(concurrency_key: key)
+                                                 .where(GoodJob::Job.arel_table[:created_at].gt(throttle_period.ago))
+                                                 .count
+
+            if (enqueued_within_period + 1) > throttle_limit
+              logger.info "Aborted enqueue of #{job.class.name} (Job ID: #{job.job_id}) because the concurrency key '#{key}' has reached its throttle limit of #{limit} #{'job'.pluralize(limit)}"
+              on_abort&.call
+              break
+            end
+          end
+
+          on_enqueue&.call
         end
       end
     end

data/lib/good_job/version.rb

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

data/lib/good_job.rb

@@ -3,44 +3,44 @@
 require "active_job"
 require "active_job/queue_adapters"
 
-require "good_job/version"
-require "good_job/engine"
-
-require "good_job/adapter"
-require "active_job/queue_adapters/good_job_adapter"
-require "good_job/active_job_extensions/batches"
-require "good_job/active_job_extensions/concurrency"
-require "good_job/interrupt_error"
-require "good_job/active_job_extensions/interrupt_errors"
-require "good_job/active_job_extensions/labels"
-require "good_job/active_job_extensions/notify_options"
-
-require "good_job/overridable_connection"
-require "good_job/bulk"
-require "good_job/callable"
-require "good_job/capsule"
-require "good_job/cleanup_tracker"
-require "good_job/cli"
-require "good_job/configuration"
-require "good_job/cron_manager"
-require "good_job/current_thread"
-require "good_job/daemon"
-require "good_job/dependencies"
-require "good_job/job_performer"
-require "good_job/job_performer/metrics"
-require "good_job/log_subscriber"
-require "good_job/multi_scheduler"
-require "good_job/notifier"
-require "good_job/poller"
-require "good_job/probe_server"
-require "good_job/probe_server/healthcheck_middleware"
-require "good_job/probe_server/not_found_app"
-require "good_job/probe_server/simple_handler"
-require "good_job/probe_server/webrick_handler"
-require "good_job/scheduler"
-require "good_job/shared_executor"
-require "good_job/systemd_service"
-require "good_job/thread_status"
+require_relative "good_job/version"
+require_relative "good_job/engine"
+
+require_relative "good_job/adapter"
+require_relative "active_job/queue_adapters/good_job_adapter"
+require_relative "good_job/active_job_extensions/batches"
+require_relative "good_job/active_job_extensions/concurrency"
+require_relative "good_job/interrupt_error"
+require_relative "good_job/active_job_extensions/interrupt_errors"
+require_relative "good_job/active_job_extensions/labels"
+require_relative "good_job/active_job_extensions/notify_options"
+
+require_relative "good_job/overridable_connection"
+require_relative "good_job/bulk"
+require_relative "good_job/callable"
+require_relative "good_job/capsule"
+require_relative "good_job/cleanup_tracker"
+require_relative "good_job/cli"
+require_relative "good_job/configuration"
+require_relative "good_job/cron_manager"
+require_relative "good_job/current_thread"
+require_relative "good_job/daemon"
+require_relative "good_job/dependencies"
+require_relative "good_job/job_performer"
+require_relative "good_job/job_performer/metrics"
+require_relative "good_job/log_subscriber"
+require_relative "good_job/multi_scheduler"
+require_relative "good_job/notifier"
+require_relative "good_job/poller"
+require_relative "good_job/probe_server"
+require_relative "good_job/probe_server/healthcheck_middleware"
+require_relative "good_job/probe_server/not_found_app"
+require_relative "good_job/probe_server/simple_handler"
+require_relative "good_job/probe_server/webrick_handler"
+require_relative "good_job/scheduler"
+require_relative "good_job/shared_executor"
+require_relative "good_job/systemd_service"
+require_relative "good_job/thread_status"
 
 # GoodJob is a multithreaded, Postgres-based, ActiveJob backend for Ruby on Rails.
 #

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 3.26.1
+  version: 3.27.0
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-01 00:00:00.000000000 Z
+date: 2024-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -168,16 +168,16 @@ dependencies:
   name: puma
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.6'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.6'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
@@ -206,6 +206,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: webrick
   requirement: !ruby/object:Gem::Requirement
@@ -268,11 +282,13 @@ files:
 - app/controllers/good_job/cron_entries_controller.rb
 - app/controllers/good_job/frontends_controller.rb
 - app/controllers/good_job/jobs_controller.rb
+- app/controllers/good_job/metrics_controller.rb
 - app/controllers/good_job/processes_controller.rb
 - app/filters/good_job/base_filter.rb
 - app/filters/good_job/batches_filter.rb
 - app/filters/good_job/jobs_filter.rb
 - app/frontend/good_job/application.js
+- app/frontend/good_job/modules/async_values_controller.js
 - app/frontend/good_job/modules/charts.js
 - app/frontend/good_job/modules/checkbox_toggle.js
 - app/frontend/good_job/modules/document_ready.js
@@ -442,7 +458,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.4
 signing_key:
 specification_version: 4
 summary: A multithreaded, Postgres-based ActiveJob backend for Ruby on Rails