good_job 4.13.3 → 4.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2993eeb7c69f566b281456e5d7122dbbc685de9efc5ce56ae7b62edbec5e9d1a
-  data.tar.gz: 9528654eca760b6bcb2bf18890263c4213c0e4df71174e9ab5a55ac55982182b
+  metadata.gz: 5eb23908b9969829cfe7d7eec72e7cb9eaac26ee20786e5778c291fccf768532
+  data.tar.gz: 0b49c31b04c2d1b9c447a25ddaa74ca13a6434c984a79e1b47204bdf8f15192a
 SHA512:
-  metadata.gz: 1d293a78adc12d75fde3473c84a65c7a4c7cabc6d9e35bb39d9e9c9547d376fd1ff41877b92ceba3a1e87d906a1242d224ed4f61cf9e790146ab56b01111c183
-  data.tar.gz: 1ded68b5610c971520b7f515566d4def597cfca9dfb85e4d099422b756f40720ccba94864a2998bf7b7f86bb7d6588b59e86e5ec93e62672b899b12d2cbcba7b
+  metadata.gz: d05ad24c88ef9f7a396b8f3f6a966c5683eb3b984ad853075c11368dd4d9412264e33e76da8cbe62f207dd05fbfc265dbf5c3f20b3c80a4c031a12f44c3126ba
+  data.tar.gz: 0e30892a4f9ad554c15ab7be7c11c2e04f5f87f49963826a4d4e21188b79e5b7b6d89ac9c06906793c259b4ca792aee8072d927efd135cc5a5f81fa6abff2a13

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [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/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/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.0'
 
   # 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.0
 platform: ruby
 authors:
 - Ben Sheldon