good_job 3.26.2 → 3.27.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd8ee28330829da54e9a3aa54e26b346c5a36749cadbe957871e800d7cd896fd
-  data.tar.gz: 42fd6406fafafff7a8635908db73c8a4159db1e86178551e1245d81c6485e943
+  metadata.gz: 6f6e4655250d166696f48733e756d69164f1c1b6371d925fa5333fd538c7850c
+  data.tar.gz: c65cd8ace06f23e8647ff6747eb754151a39a732a7ac9cb79534573016f20b87
 SHA512:
-  metadata.gz: 1b63f85473716cc66d12ff3886c3968606c0e6eff11d43b9ea49524419ba6f55841d3662660169712a5aca1b7715c9c50a9927626bc3416d495634864082effd
-  data.tar.gz: 83d2f99ca7aa3357af7625adbf05ab970b64fa9d6145d865ae045c737e7c8637e31b2da878e710db29feb2cf04a9dc63388663067bb096a6e2495e3d16b03367
+  metadata.gz: 1bb8b51381b2e61dcb024d15fd555f2cc36a5dbd1abb0439b20e8db182c332f136be433108a07cc0fdfcc7a2321035f1136676833a81387783694db5a9c6ea32
+  data.tar.gz: 1054014eb0dea19141fde93ef3a99b6533804f9f5714a97be43bb9bf57183297371df458f7ac55c0c77fd3bf7d8504d49c980d9ed5f5b94f378f1468356d6c68

data/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## [v3.27.1](https://github.com/bensheldon/good_job/tree/v3.27.1) (2024-03-24)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v3.27.0...v3.27.1)
+
+**Fixed bugs:**
+
+- Start async adapters `after_initialize` instead of once Active Job and Active Record are loaded and Rails initialized? [\#1297](https://github.com/bensheldon/good_job/pull/1297) ([bensheldon](https://github.com/bensheldon))
+
+## [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)

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

@@ -16,10 +16,20 @@ module GoodJob
       }
     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/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

@@ -73,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

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

@@ -17,6 +17,7 @@ GoodJob::Engine.routes.draw do
     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/adapter.rb

@@ -30,7 +30,7 @@ module GoodJob
       GoodJob::Configuration.validate_execution_mode(@_execution_mode_override) if @_execution_mode_override
       @capsule = _capsule
 
-      start_async if GoodJob.async_ready?
+      start_async if GoodJob._async_ready?
       self.class.instances << self
     end
 

data/lib/good_job/engine.rb

@@ -49,22 +49,17 @@ module GoodJob
     end
 
     initializer "good_job.start_async" do
-      # This hooks into the hookable places during Rails boot, which is unfortunately not Rails.application.initialized?
-      # If an Adapter is initialized during boot, we want to want to start async executors once the framework dependencies have loaded.
-      # When exactly that happens is out of our control because gems or application code may touch things earlier than expected.
-      # For example, as of Rails 6.1, if an ActiveRecord model is touched during boot, that triggers ActiveRecord to load,
-      # which touches DestroyAssociationAsyncJob, which loads ActiveJob, which may initialize a GoodJob::Adapter, all of which
-      # happens _before_ ActiveRecord finishes loading. GoodJob will deadlock if an async executor is started in the middle of
-      # ActiveRecord loading.
       config.after_initialize do
-        ActiveSupport.on_load(:active_record) do
-          ActiveSupport.on_load(:active_job) do
-            GoodJob._framework_ready = true
-            GoodJob._start_async_adapters
-          end
-          GoodJob._start_async_adapters
-        end
-        GoodJob._start_async_adapters
+        GoodJob._async_ready = true
+
+        # Ensure Active Record and Active Job are fully loaded
+        ActiveRecord::Base # rubocop:disable Lint/Void
+        ActiveJob::Base.queue_adapter
+
+        GoodJob::Adapter.instances
+                        .select(&:execute_async?)
+                        .reject(&:async_started?)
+                        .each(&:start_async)
       end
     end
   end

data/lib/good_job/version.rb

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

data/lib/good_job.rb

@@ -25,7 +25,6 @@ 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"
@@ -46,7 +45,6 @@ require_relative "good_job/thread_status"
 #
 # +GoodJob+ is the top-level namespace and exposes configuration attributes.
 module GoodJob
-  include GoodJob::Dependencies
   include GoodJob::ThreadStatus
 
   # Default, null, blank value placeholder.
@@ -114,6 +112,11 @@ module GoodJob
   #   @return [GoodJob::Capsule, nil]
   mattr_accessor :capsule, default: GoodJob::Capsule.new(configuration: configuration)
 
+  mattr_accessor :_async_ready, default: false
+  def self._async_ready?
+    _async_ready
+  end
+
   # Called with exception when a GoodJob thread raises an exception
   # @param exception [Exception] Exception that was raised
   # @return [void]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 3.26.2
+  version: 3.27.1
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-15 00:00:00.000000000 Z
+date: 2024-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -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
@@ -390,7 +404,6 @@ files:
 - lib/good_job/cron_manager.rb
 - lib/good_job/current_thread.rb
 - lib/good_job/daemon.rb
-- lib/good_job/dependencies.rb
 - lib/good_job/engine.rb
 - lib/good_job/interrupt_error.rb
 - lib/good_job/job_performer.rb
@@ -444,7 +457,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

data/lib/good_job/dependencies.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module GoodJob # :nodoc:
-  # Extends GoodJob module to track Rails boot dependencies.
-  module Dependencies
-    extend ActiveSupport::Concern
-
-    included do
-      mattr_accessor :_framework_ready, default: false
-    end
-
-    class_methods do
-      # Whether Rails framework has sufficiently initialized to enable Async execution.
-      def async_ready?
-        Rails.application.initialized? || _framework_ready
-      end
-
-      def _start_async_adapters
-        return unless async_ready?
-
-        ActiveJob::Base.queue_adapter # Ensure Active Job is initialized
-        GoodJob::Adapter.instances
-                        .select(&:execute_async?)
-                        .reject(&:async_started?)
-                        .each(&:start_async)
-      end
-    end
-  end
-end