good_job 4.13.3 → 4.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2993eeb7c69f566b281456e5d7122dbbc685de9efc5ce56ae7b62edbec5e9d1a
-  data.tar.gz: 9528654eca760b6bcb2bf18890263c4213c0e4df71174e9ab5a55ac55982182b
+  metadata.gz: af515dffcbbdb5c6f3e02ec7a1426b7d59aea355b33791c81cc20d043bcab7f4
+  data.tar.gz: e44f93e479b483af4c3848c7957df934198fb780260c3008c427ff864c3d67a8
 SHA512:
-  metadata.gz: 1d293a78adc12d75fde3473c84a65c7a4c7cabc6d9e35bb39d9e9c9547d376fd1ff41877b92ceba3a1e87d906a1242d224ed4f61cf9e790146ab56b01111c183
-  data.tar.gz: 1ded68b5610c971520b7f515566d4def597cfca9dfb85e4d099422b756f40720ccba94864a2998bf7b7f86bb7d6588b59e86e5ec93e62672b899b12d2cbcba7b
+  metadata.gz: 812281e391af58a897dd119e875be51c7569eaefa021f7fc05d42d69b185819c4077c04e8f40d23c3cf498862e04f8f9285fe9a29931a1d9bba4f1a61650ca37
+  data.tar.gz: 1941b6294d3339c590e2c37188a2f1568a3c32bc5e1f9cb2a76f0c58b94cce6781797d3d86853111a842f435adb8262611eca426dc16001bb6bc1b0a8437bde4

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## [v4.14.1](https://github.com/bensheldon/good_job/tree/v4.14.1) (2026-04-03)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v4.14.0...v4.14.1)
+
+**Fixed bugs:**
+
+- Fix N+1 queries on cron entries dashboard index page [\#1727](https://github.com/bensheldon/good_job/pull/1727) ([clinejj](https://github.com/clinejj))
+
+## [v4.14.0](https://github.com/bensheldon/good_job/tree/v4.14.0) (2026-03-31)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v4.13.3...v4.14.0)
+
+**Implemented enhancements:**
+
+- Consider using pg\_cron for Cron-style repeating/recurring jobs [\#328](https://github.com/bensheldon/good_job/issues/328)
+- Add Batch.enqueue\_all for bulk-enqueuing multiple batches [\#1726](https://github.com/bensheldon/good_job/pull/1726) ([AliOsm](https://github.com/AliOsm))
+- Allow perform\_all\_later to enqueue to Batches [\#1720](https://github.com/bensheldon/good_job/pull/1720) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- perform\_all\_later not intercepted by Batch [\#1719](https://github.com/bensheldon/good_job/issues/1719)
+- Deprecate and drop :on\_unhandled\_error option [\#1706](https://github.com/bensheldon/good_job/issues/1706)
+
+**Merged pull requests:**
+
+- Bump actions/upload-artifact from 6 to 7 [\#1718](https://github.com/bensheldon/good_job/pull/1718) ([dependabot[bot]](https://github.com/apps/dependabot))
+
 ## [v4.13.3](https://github.com/bensheldon/good_job/tree/v4.13.3) (2026-02-18)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v4.13.2...v4.13.3)

data/app/controllers/good_job/cron_entries_controller.rb

@@ -4,6 +4,10 @@ module GoodJob
   class CronEntriesController < GoodJob::ApplicationController
     def index
       @cron_entries = CronEntry.all
+      @last_jobs = CronEntry.last_jobs_by_key(@cron_entries)
+      @enabled_states = GoodJob::Setting.cron_keys_enabled(
+        @cron_entries.map { |entry| [entry.key, entry.enabled_by_default?] }
+      )
     end
 
     def show

data/app/models/good_job/batch.rb

@@ -61,6 +61,104 @@ module GoodJob
       end
     end
 
+    # Bulk-enqueue multiple batches with their jobs in minimal DB round-trips.
+    #
+    # Instead of creating batches one-at-a-time (~7 queries per batch), this method
+    # inserts all batch records and jobs in a fixed number of queries:
+    #   1. INSERT all BatchRecords  (insert_all!)
+    #   2. INSERT all Jobs          (insert_all)
+    #   3. NOTIFY per distinct queue/scheduled_at
+    #
+    # @param batch_job_pairs [Array<Array(GoodJob::Batch, Array<ActiveJob::Base>)>]
+    #   Array of [batch, jobs] pairs. Each batch must be new (not yet persisted).
+    # @return [Array<GoodJob::Batch>] The enqueued batches
+    # @raise [ArgumentError] if any batch is already persisted
+    def self.enqueue_all(batch_job_pairs)
+      batch_job_pairs = Array(batch_job_pairs)
+      return [] if batch_job_pairs.empty?
+
+      batch_job_pairs.each do |(batch, _)|
+        raise ArgumentError, "All batches must be new (not persisted)" if batch.persisted?
+      end
+
+      Rails.application.executor.wrap do
+        current_time = Time.current
+        adapter = ActiveJob::Base.queue_adapter
+        execute_inline = adapter.respond_to?(:execute_inline?) && adapter.execute_inline?
+
+        # Phase 1: Insert all batch records
+        batch_rows = _build_batch_rows(batch_job_pairs, current_time)
+        BatchRecord.insert_all!(batch_rows) # rubocop:disable Rails/SkipsModelValidations
+        _mark_batches_persisted(batch_job_pairs, batch_rows, current_time)
+
+        # Phase 2: Build and partition jobs by concurrency limits
+        build_result = _build_and_partition_jobs(batch_job_pairs, current_time)
+
+        # Phase 3: Insert bulkable jobs
+        persisted_jobs = []
+        inline_jobs = []
+
+        if build_result[:bulkable].any?
+          Job.transaction(requires_new: true, joinable: false) do
+            persisted_jobs = _insert_jobs(build_result[:bulkable], build_result[:active_jobs_by_job_id])
+
+            if execute_inline
+              inline_jobs = persisted_jobs.select { |job| job.scheduled_at.nil? || job.scheduled_at <= Time.current }
+              inline_jobs.each(&:advisory_lock!)
+            end
+          end
+        end
+
+        # Phase 4: Handle empty batches — they need _continue_discard_or_finish
+        # to trigger on_success/on_finish callbacks (batch_record.rb:77).
+        batches_with_jobs = Set.new
+        build_result[:bulkable].each { |entry| batches_with_jobs.add(entry[:batch]) }
+        build_result[:unbulkable].each { |entry| batches_with_jobs.add(entry[:batch]) }
+
+        empty_batches = batch_job_pairs.map(&:first).reject { |batch| batches_with_jobs.include?(batch) }
+        if empty_batches.any?
+          buffer = GoodJob::Adapter::InlineBuffer.capture do
+            empty_batches.each do |batch|
+              batch._record.reload
+              batch._record._continue_discard_or_finish(lock: true)
+            end
+          end
+          buffer.call
+        end
+
+        # Phase 5: Enqueue concurrency-limited jobs individually
+        build_result[:unbulkable].each do |entry|
+          within_thread(batch_id: entry[:batch].id) do
+            entry[:active_job].enqueue
+          end
+        rescue GoodJob::ActiveJobExtensions::Concurrency::ConcurrencyExceededError
+          # ignore — matches Bulk::Buffer behavior (bulk.rb:107-109)
+        end
+
+        # Phase 6: Execute inline jobs
+        if inline_jobs.any?
+          GoodJob::Adapter::InlineBuffer.perform_now_or_defer do
+            GoodJob.capsule.tracker.register do
+              until inline_jobs.empty?
+                inline_job = inline_jobs.shift
+                active_job = build_result[:active_jobs_by_job_id][inline_job.active_job_id]
+                adapter.send(:perform_inline, inline_job, notify: adapter.send(:send_notify?, active_job))
+              end
+            ensure
+              inline_jobs.each(&:advisory_unlock)
+            end
+          end
+        end
+
+        # Phase 7: Send NOTIFY for non-inline jobs
+        non_inline_jobs = persisted_jobs - inline_jobs
+        non_inline_jobs = non_inline_jobs.reject(&:finished_at) if inline_jobs.any?
+        _send_notifications(non_inline_jobs, build_result[:active_jobs_by_job_id], adapter) if non_inline_jobs.any?
+
+        batch_job_pairs.map(&:first)
+      end
+    end
+
     def self.primary_key
       :id
     end
@@ -183,6 +281,131 @@ module GoodJob
       record
     end
 
+    # @!visibility private
+    def self._build_batch_rows(batch_job_pairs, current_time)
+      batch_job_pairs.map do |batch, _jobs|
+        record = batch._record
+        {
+          id: SecureRandom.uuid,
+          created_at: current_time,
+          updated_at: current_time,
+          enqueued_at: current_time,
+          on_finish: record.on_finish,
+          on_success: record.on_success,
+          on_discard: record.on_discard,
+          callback_queue_name: record.callback_queue_name,
+          callback_priority: record.callback_priority,
+          description: record.description,
+          # record.serialized_properties returns the internally-stored form
+          # which already includes _aj_symbol_keys metadata from
+          # PropertySerializer.dump. Pass it directly — insert_all! handles
+          # jsonb encoding, and PropertySerializer.load will deserialize
+          # correctly on read.
+          serialized_properties: record.serialized_properties || {},
+        }
+      end
+    end
+
+    # @!visibility private
+    def self._mark_batches_persisted(batch_job_pairs, batch_rows, current_time)
+      batch_job_pairs.each_with_index do |(batch, _jobs), index|
+        record = batch._record
+        record.id = batch_rows[index][:id]
+        record.created_at = current_time
+        record.updated_at = current_time
+        record.enqueued_at = current_time
+        record.instance_variable_set(:@new_record, false)
+      end
+    end
+
+    # @!visibility private
+    def self._build_and_partition_jobs(batch_job_pairs, current_time)
+      bulkable = []
+      unbulkable = []
+      active_jobs_by_job_id = {}
+
+      batch_job_pairs.each do |batch, jobs|
+        next if jobs.blank?
+
+        jobs.each do |active_job|
+          active_jobs_by_job_id[active_job.job_id] = active_job
+
+          # 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])
+            unbulkable << { batch: batch, active_job: active_job }
+          else
+            good_job = Job.build_for_enqueue(active_job)
+
+            # Normalize timestamps (mirrors Adapter#enqueue_all, adapter.rb:62-65)
+            good_job.scheduled_at = current_time if good_job.scheduled_at == good_job.created_at
+            good_job.created_at = current_time
+            good_job.updated_at = current_time
+
+            # Set batch_id directly — can't use thread-local for multi-batch bulk
+            good_job.batch_id = batch.id
+            good_job.batch_callback_id = nil
+
+            bulkable << { batch: batch, active_job: active_job, good_job: good_job }
+          end
+        end
+      end
+
+      { bulkable: bulkable, unbulkable: unbulkable, active_jobs_by_job_id: active_jobs_by_job_id }
+    end
+
+    # @!visibility private
+    def self._insert_jobs(bulkable_entries, active_jobs_by_job_id)
+      job_attributes = bulkable_entries.map { |entry| entry[:good_job].attributes }
+      results = Job.insert_all(job_attributes, returning: %w[id active_job_id]) # rubocop:disable Rails/SkipsModelValidations
+
+      job_id_map = results.each_with_object({}) { |row, hash| hash[row['active_job_id']] = row['id'] }
+
+      # Set provider_job_id on ActiveJob instances (mirrors adapter.rb:74-76)
+      active_jobs_by_job_id.each_value do |active_job|
+        active_job.provider_job_id = job_id_map[active_job.job_id]
+        active_job.successfully_enqueued = active_job.provider_job_id.present? if active_job.respond_to?(:successfully_enqueued=)
+      end
+
+      # Mark Job AR objects as persisted (mirrors adapter.rb:78-80)
+      bulkable_entries.each do |entry|
+        entry[:good_job].instance_variable_set(:@new_record, false) if job_id_map[entry[:good_job].active_job_id]
+      end
+
+      bulkable_entries.pluck(:good_job).select(&:persisted?)
+    end
+
+    # @!visibility private
+    def self._send_notifications(jobs, active_jobs_by_job_id, adapter)
+      return unless GoodJob.configuration.enable_listen_notify
+
+      jobs.group_by(&:queue_name).each do |queue_name, jobs_by_queue|
+        jobs_by_queue.group_by(&:scheduled_at).each do |scheduled_at, grouped_jobs|
+          state = { queue_name: queue_name, count: grouped_jobs.size }
+          state[:scheduled_at] = scheduled_at if scheduled_at
+
+          executed_locally = adapter.respond_to?(:execute_async?) && adapter.execute_async? && GoodJob.capsule&.create_thread(state)
+          unless executed_locally
+            state[:count] = grouped_jobs.count { |job| _send_notify?(active_jobs_by_job_id[job.active_job_id]) }
+            Notifier.notify(state) unless state[:count].zero?
+          end
+        end
+      end
+    end
+
+    # Mirrors Adapter#send_notify? (adapter.rb:242-247)
+    # @!visibility private
+    def self._send_notify?(active_job)
+      return true unless active_job.respond_to?(:good_job_notify)
+
+      !(active_job.good_job_notify == false ||
+        (active_job.class.good_job_notify == false && active_job.good_job_notify.nil?))
+    end
+
     private
 
     attr_accessor :record

data/app/models/good_job/cron_entry.rb

@@ -18,6 +18,30 @@ module GoodJob # :nodoc:
       configuration.cron_entries
     end
 
+    def self.last_jobs_by_key(cron_entries)
+      cron_keys = cron_entries.map { |entry| entry.key.to_s }
+      return {} if cron_keys.empty?
+
+      from_clause = GoodJob::Job.sanitize_sql_array(
+        ["unnest(ARRAY[?]::text[]) AS cron_keys(cron_key)", cron_keys]
+      )
+
+      join_clause = <<~SQL.squish
+        CROSS JOIN LATERAL (
+          SELECT * FROM good_jobs
+          WHERE good_jobs.cron_key = cron_keys.cron_key
+          ORDER BY cron_at DESC NULLS LAST
+          LIMIT 1
+        ) AS lateral_jobs
+      SQL
+
+      GoodJob::Job
+        .select("lateral_jobs.*")
+        .from(from_clause)
+        .joins(join_clause)
+        .index_by(&:cron_key)
+    end
+
     def self.find(key, configuration: nil)
       all(configuration: configuration).find { |entry| entry.key == key.to_sym }.tap do |cron_entry|
         raise ActiveRecord::RecordNotFound unless cron_entry
@@ -144,13 +168,13 @@ module GoodJob # :nodoc:
       (last_job.cron_at || last_job.created_at).localtime
     end
 
-    private
-
     def enabled_by_default?
       value = params.fetch(:enabled_by_default, true)
       value.respond_to?(:call) ? value.call : value
     end
 
+    private
+
     def cron
       params.fetch(:cron)
     end

data/app/models/good_job/setting.rb

@@ -19,6 +19,16 @@ module GoodJob
       end
     end
 
+    def self.cron_keys_enabled(keys_with_defaults)
+      cron_disabled = find_by(key: CRON_KEYS_DISABLED)&.value || []
+      cron_enabled = find_by(key: CRON_KEYS_ENABLED)&.value || []
+
+      keys_with_defaults.to_h do |key, default|
+        key_s = key.to_s
+        [key_s, default ? cron_disabled.exclude?(key_s) : cron_enabled.include?(key_s)]
+      end
+    end
+
     def self.cron_key_enable(key)
       key_string = key.to_s
       enabled_setting = find_or_initialize_by(key: CRON_KEYS_ENABLED) do |record|

data/app/views/good_job/cron_entries/index.html.erb

@@ -39,14 +39,16 @@
             <%= relative_time cron_entry.next_at %>
           </div>
           <div class="col-6 col-lg-1 text-wrap small">
-            <% if cron_entry.last_job.present? %>
+            <% last_job = @last_jobs[cron_entry.key.to_s] %>
+            <% if last_job.present? %>
+              <% last_job_at = (last_job.cron_at || last_job.created_at).localtime %>
               <div class="d-lg-none small text-muted mt-1"><%= t "good_job.models.cron.last_run" %></div>
-              <%= link_to relative_time(cron_entry.last_job_at), cron_entry_path(cron_entry), title: "Job #{cron_entry.last_job.id}" %>
+              <%= link_to relative_time(last_job_at), cron_entry_path(cron_entry), title: "Job #{last_job.id}" %>
             <% end %>
           </div>
           <div class="col-6 col-lg-1 text-wrap small">
             <div class="d-lg-none small text-muted mt-1"><%= t "good_job.models.cron.status" %></div>
-            <% if cron_entry.enabled? %>
+            <% if @enabled_states[cron_entry.key.to_s] %>
               <span class="text-success"><%= t "good_job.models.cron.states.active" %></span>
             <% else %>
               <span class="text-muted"><%= t "good_job.models.cron.states.paused" %></span>
@@ -57,7 +59,7 @@
               <%= render_icon "skip_forward" %>
             <% end %>
 
-            <% if cron_entry.enabled? %>
+            <% if @enabled_states[cron_entry.key.to_s] %>
               <%= button_to disable_cron_entry_path(cron_entry), method: :put, class: "btn btn-sm btn-outline-primary", form_class: "d-inline-block", aria: { label: t("good_job.cron_entries.actions.disable") }, title: t("good_job.cron_entries.actions.disable"), data: { turbo_confirm: t("good_job.cron_entries.actions.confirm_disable") } do %>
                 <%= render_icon "pause" %>
               <% end %>

data/lib/good_job/adapter.rb

@@ -55,6 +55,10 @@ module GoodJob
       active_jobs = Array(active_jobs)
       return 0 if active_jobs.empty?
 
+      # If there is a currently open Bulk in the current thread, direct the
+      # jobs there to (eventually) be enqueued using enqueue_all
+      return if GoodJob::Bulk.capture(active_jobs, queue_adapter: self)
+
       Rails.application.executor.wrap do
         current_time = Time.current
         jobs = active_jobs.map do |active_job|

data/lib/good_job/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 4.13.3
+  version: 4.14.1
 platform: ruby
 authors:
 - Ben Sheldon