good_job 3.9.0 → 3.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69560b4af2d1cab2a3783fb80573794066c3704aacafa7bd315a9dc6e1b75441
-  data.tar.gz: 55dff98e3c8ebbcebd5f09664d02f4ddd23b298c0ee2bc7cb163e43f6963de96
+  metadata.gz: 22496fe725c6ad616c39f243cf8f53381dee64a5402d3a199c8c604bff2c4eb3
+  data.tar.gz: 6d9791dd28f28ddf9317f2770029323754fa32c60403f336f23db8020cdecc51
 SHA512:
-  metadata.gz: dd4763e6d473a22ea7b0f6f7b501249c7e5e29d06c1fdd9b3d028c923ba407fb485eea748fd37857a5eb09f5b26659d67f4792f4a66848542bfc1f47f7384577
-  data.tar.gz: 89e165d003d156fa16450762b8a8a269172509557ab59be60e7d54794d079c9963f8c11f45047ecfdea8e0963d901c8d9e1c297743392a05817d21d417c78dab
+  metadata.gz: e182b3aa78b38fd75baa5e0c14704baa99b7aa98f34ff011006543ce7a356e6eae8ac45e605d65d985b8631f6f185666f78e5bb1be1f39feebd62c159535a7e5
+  data.tar.gz: acf8a1f601e07142b0dbaea2f2e229fa3d9b7f8c50dd6232531f8ff50cf888d61f88f2a02ae423ffaa8a9a6533bd1cd0522e7cfa849abb20db8dc538adf75ae3

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [v3.10.0](https://github.com/bensheldon/good_job/tree/v3.10.0) (2023-02-04)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v3.9.0...v3.10.0)
+
+**Implemented enhancements:**
+
+- Implement `GoodJob::Batch` [\#712](https://github.com/bensheldon/good_job/pull/712) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- Support for Ruby 3.2 [\#785](https://github.com/bensheldon/good_job/issues/785)
+- Custom table names [\#748](https://github.com/bensheldon/good_job/issues/748)
+- Health check issue with cron scheduler job [\#741](https://github.com/bensheldon/good_job/issues/741)
+
 ## [v3.9.0](https://github.com/bensheldon/good_job/tree/v3.9.0) (2023-01-31)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v3.8.0...v3.9.0)

data/README.md

@@ -41,9 +41,11 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
     - [Dashboard](#dashboard)
         - [API-only Rails applications](#api-only-rails-applications)
         - [Live Polling](#live-polling)
-    - [ActiveJob concurrency](#activejob-concurrency)
+    - [Concurrency controls](#concurrency-controls)
         - [How concurrency controls work](#how-concurrency-controls-work)
     - [Cron-style repeating/recurring jobs](#cron-style-repeatingrecurring-jobs)
+    - [Bulk enqueue](#bulk-enqueue)
+    - [Batches](#batches)
     - [Updating](#updating)
         - [Upgrading minor versions](#upgrading-minor-versions)
         - [Upgrading v2 to v3](#upgrading-v2-to-v3)
@@ -58,7 +60,6 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
     - [Database connections](#database-connections)
         - [Production setup](#production-setup)
         - [Queue performance with Queue Select Limit](#queue-performance-with-queue-select-limit)
-    - [Bulk enqueue](#bulk-enqueue)
     - [Execute jobs async / in-process](#execute-jobs-async--in-process)
     - [Migrate to GoodJob from a different ActiveJob backend](#migrate-to-goodjob-from-a-different-activejob-backend)
     - [Monitor and preserve worked jobs](#monitor-and-preserve-worked-jobs)
@@ -392,7 +393,7 @@ end
 
 The Dashboard can be set to automatically refresh by checking "Live Poll" in the Dashboard header, or by setting `?poll=10` with the interval in seconds (default 30 seconds).
 
-### ActiveJob concurrency
+### Concurrency controls
 
 GoodJob can extend ActiveJob to provide limits on concurrently running jobs, either at time of _enqueue_ or at _perform_. Limiting concurrency can help prevent duplicate, double or unnecessary jobs from being enqueued, or race conditions when performing, for example when interacting with 3rd-party APIs.
 
@@ -485,6 +486,196 @@ config.good_job.cron = {
 }
 ```
 
+### Bulk enqueue
+
+GoodJob's Bulk-enqueue functionality can buffer and enqueue multiple jobs at once, using a single INSERT statement. This can more performant when enqueuing a large number of jobs.
+
+```ruby
+# Capture jobs using `.perform_later`:
+active_jobs = GoodJob::Bulk.enqueue do
+  MyJob.perform_later
+  AnotherJob.perform_later
+  # If an exception is raised within this block, no jobs will be inserted.
+end
+
+# All ActiveJob instances are returned from GoodJob::Bulk.enqueue.
+# Jobs that have been successfully enqueued have a `provider_job_id` set.
+active_jobs.all?(&:provider_job_id)
+
+# Bulk enqueue ActiveJob instances directly without using `.perform_later`:
+GoodJob::Bulk.enqueue(MyJob.new, AnotherJob.new)
+```
+
+### Batches
+
+Batches track a set of jobs, and enqueue an optional callback job when all of the jobs have finished (succeeded or discarded).
+
+- A simple example that enqueues your `MyBatchCallbackJob` after the two jobs have finished, and passes along the current user as a batch property:
+
+    ```ruby
+    GoodJob::Batch.enqueue(on_finish: MyBatchCallbackJob, user: current_user) do
+      MyJob.perform_later
+      OtherJob.perform_later
+    end
+
+    # When these jobs have finished, it will enqueue your `MyBatchCallbackJob.perform_later(batch, options)`
+    class MyBatchCallbackJob < ApplicationJob
+      # Callback jobs must accept a `batch` and `options` argument
+      def perform(batch, params)
+        # The batch object will contain the Batch's properties, which are mutable
+        batch.properties[:user] # => <User id: 1, ...>
+
+        # Params is a hash containing additional context (more may be added in the future)
+        params[:event] # => :finish, :success, :discard
+      end
+    end
+    ```
+
+- Jobs can be added to an existing batch. Jobs in a batch are enqueued and performed immediately/asynchronously. The final callback job will not be enqueued until `GoodJob::Batch#enqueue` is called.
+
+    ```ruby
+    batch = GoodJob::Batch.add do
+      10.times { MyJob.perform_later }
+    end
+    batch.add do
+      10.times { OtherJob.perform_later }
+    end
+    batch.enqueue(on_finish: MyBatchCallbackJob, age: 42)
+    ```
+
+- If you need to access the batch within a job that is part of the batch, include [`GoodJob::ActiveJobExtensions::Batches`](lib/good_job/active_job_extensions/batches.rb) in your job class:
+
+  ```ruby
+    class MyJob < ApplicationJob
+      include GoodJob::ActiveJobExtensions::Batches
+
+      def perform
+        self.batch # => <GoodJob::Batch id: 1, ...>
+      end
+    end
+    ```
+
+- [`GoodJob::Batch`](app/models/good_job/batch.rb) has a number of assignable attributes and methods:
+
+```ruby
+batch = GoodJob::Batch.new
+batch.description = "My batch"
+batch.on_finish = "MyBatchCallbackJob" # Callback job when all jobs have finished
+batch.on_success = "MyBatchCallbackJob" # Callback job when/if all jobs have succeeded
+batch.on_discard = "MyBatchCallbackJob" # Callback job when the first job in the batch is discarded
+batch.callback_queue_name = "special_queue" # Optional queue for callback jobs, otherwise will defer to job class
+batch.callback_priority = 10 # Optional priority name for callback jobs, otherwise will defer to job class
+batch.properties = { age: 42 } # Custom data and state to attach to the batch
+batch.add do
+  MyJob.perform_later
+end
+batch.enqueue
+
+batch.discarded? # => Boolean
+batch.discarded_at # => <DateTime>
+batch.finished? # => Boolean
+batch.finished_at # => <DateTime>
+batch.succeeded? # => Boolean
+batch.active_jobs # => Array of ActiveJob::Base-inherited jobs that are part of the batch
+
+batch = GoodJob::Batch.find(batch.id)
+batch.description = "Updated batch description"
+batch.save
+batch.reload
+```
+
+### Batch callback jobs
+
+Batch callbacks are Active Job jobs that are enqueued at certain events during the execution of jobs within the batch:
+
+- `:finish` - Enqueued when all jobs in the batch have finished, after all retries. Jobs will either be discarded or succeeded.
+- `:success` - Enqueued only when all jobs in the batch have finished and succeeded.
+- `:discard` - Enqueued immediately the first time a job in the batch is discarded.
+
+Callback jobs must accept a `batch` and `params` argument in their `perform` method:
+
+```ruby
+class MyBatchCallbackJob < ApplicationJob
+  def perform(batch, params)
+    # The batch object will contain the Batch's properties
+    batch.properties[:user] # => <User id: 1, ...>
+    # Batches are mutable
+    batch.properties[:user] = User.find(2)
+    batch.save
+
+    # Params is a hash containing additional context (more may be added in the future)
+    params[:event] # => :finish, :success, :discard
+  end
+end
+```
+
+#### Complex batches
+
+Consider a multi-stage batch with both parallel and serial job steps:
+
+```mermaid
+graph TD
+    0{"BatchJob\n{ stage: nil }"}
+    0 --> a["WorkJob]\n{ step: a }"]
+    0 --> b["WorkJob]\n{ step: b }"]
+    0 --> c["WorkJob]\n{ step: c }"]
+    a --> 1
+    b --> 1
+    c --> 1
+    1{"BatchJob\n{ stage: 1 }"}
+    1 --> d["WorkJob]\n{ step: d }"]
+    1 --> e["WorkJob]\n{ step: e }"]
+    e --> f["WorkJob]\n{ step: f }"]
+    d --> 2
+    f --> 2
+    2{"BatchJob\n{ stage: 2 }"}
+```
+
+This can be implemented with a single, mutable batch job:
+
+```ruby
+class WorkJob < ApplicationJob
+  include GoodJob::ActiveJobExtensions::Batches
+
+  def perform(step)
+    # ...
+    if step == 'e'
+      batch.add { WorkJob.perform_later('f') }
+    end
+  end
+end
+
+class BatchJob < ApplicationJob
+  def perform(batch, options)
+    if batch.properties[:stage].nil?
+      batch.enqueue(stage: 1) do
+        WorkJob.perform_later('a')
+        WorkJob.perform_later('b')
+        WorkJob.perform_later('c')
+      end
+    elsif batch.properties[:stage] == 1
+      batch.enqueue(stage: 2) do
+        WorkJob.perform_later('d')
+        WorkJob.perform_later('e')
+      end
+    elsif batch.properties[:stage] == 2
+      # ...
+    end
+  end
+end
+
+GoodJob::Batch.enqueue(on_finish: BatchJob)
+```
+
+#### Other batch details
+
+- Whether to enqueue a callback job is evaluated once the batch is in an `enqueued?`-state by using `GoodJob::Batch.enqueue` or `batch.enqueue`.
+- Callback job enqueueing will be re-triggered if additional jobs are `enqueue`'d to the batch; use `add` to add jobs to the batch without retriggering callback jobs.
+- Callback jobs will be enqueued even if the batch contains no jobs.
+- Callback jobs perform asynchronously. It's possible that `:finish` and `:success` or `:discard` callback jobs perform at the same time. Keep this in mind when updating batch properties.
+- Batch properties are serialized using Active Job serialization. This is flexible, but can lead to deserialization errors if a GlobalID record is directly referenced but is subsequently deleted and thus unloadable.
+- 🚧Batches are a work in progress. Please let us know what would be helpful to improve their functionality and usefulness.
+
 ### Updating
 
 GoodJob follows semantic versioning, though updates may be encouraged through deprecation warnings in minor versions.
@@ -794,26 +985,6 @@ To explain where this value is used, here is the pseudo-query that GoodJob uses
   )
 ```
 
-### Bulk enqueue
-
-GoodJob's Bulk-enqueue functionality can buffer and enqueue multiple jobs at once, using a single INSERT statement. This can more performant when enqueuing a large number of jobs.
-
-```ruby
-# Capture jobs using `.perform_later`:
-active_jobs = GoodJob::Bulk.enqueue do
-  MyJob.perform_later
-  AnotherJob.perform_later
-  # If an exception is raised within this block, no jobs will be inserted.
-end
-
-# All ActiveJob instances are returned from GoodJob::Bulk.enqueue.
-# Jobs that have been successfully enqueued have a `provider_job_id` set.
-active_jobs.all?(&:provider_job_id)
-
-# Bulk enqueue ActiveJob instances directly without using `.perform_later`:
-GoodJob::Bulk.enqueue(MyJob.new, AnotherJob.new)
-```
-
 ### Execute jobs async / in-process
 
 GoodJob can execute jobs "async" in the same process as the web server (e.g. `bin/rails s`). GoodJob's async execution mode offers benefits of economy by not requiring a separate job worker process, but with the tradeoff of increased complexity. Async mode can be configured in two ways:

data/app/controllers/good_job/batches_controller.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module GoodJob
+  class BatchesController < GoodJob::ApplicationController
+    def index
+      @filter = BatchesFilter.new(params)
+    end
+
+    def show
+      @batch = GoodJob::BatchRecord.find(params[:id])
+    end
+  end
+end

data/app/filters/good_job/batches_filter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module GoodJob
+  class BatchesFilter < BaseFilter
+    def records
+      after_created_at = params[:after_created_at].present? ? Time.zone.parse(params[:after_created_at]) : nil
+
+      filtered_query.display_all(
+        after_created_at: after_created_at,
+        after_id: params[:after_id]
+      ).limit(params.fetch(:limit, DEFAULT_LIMIT))
+    end
+
+    def filtered_query(_filtered_params = params)
+      base_query
+    end
+
+    def default_base_query
+      GoodJob::BatchRecord.all.includes(:jobs)
+    end
+  end
+end

data/app/models/good_job/batch.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module GoodJob
+  # NOTE: This class delegates to {GoodJob::BatchRecord} and is intended to be the public interface for Batches.
+  class Batch
+    include GlobalID::Identification
+
+    thread_cattr_accessor :current_batch_id
+    thread_cattr_accessor :current_batch_callback_id
+
+    PROTECTED_PROPERTIES = %i[
+      on_finish
+      on_success
+      on_discard
+      callback_queue_name
+      callback_priority
+      description
+      properties
+    ].freeze
+
+    delegate(
+      :id,
+      :created_at,
+      :updated_at,
+      :persisted?,
+      :enqueued_at,
+      :finished_at,
+      :discarded_at,
+      :enqueued?,
+      :finished?,
+      :succeeded?,
+      :discarded?,
+      :description,
+      :description=,
+      :on_finish,
+      :on_finish=,
+      :on_success,
+      :on_success=,
+      :on_discard,
+      :on_discard=,
+      :callback_queue_name,
+      :callback_queue_name=,
+      :callback_priority,
+      :callback_priority=,
+      :properties,
+      :properties=,
+      :save,
+      :reload,
+      to: :record
+    )
+
+    # Create a new batch and enqueue it
+    # @param on_finish [String, Object] The class name of the callback job to be enqueued after the batch is finished
+    # @param properties [Hash] Additional properties to be stored on the batch
+    # @param block [Proc] Enqueue jobs within the block to add them to the batch
+    # @return [GoodJob::BatchRecord]
+    def self.enqueue(active_jobs = [], **properties, &block)
+      new.tap do |batch|
+        batch.enqueue(active_jobs, **properties, &block)
+      end
+    end
+
+    def self.find(id)
+      new _record: BatchRecord.find(id)
+    end
+
+    # Helper method to enqueue jobs and assign them to a batch
+    def self.within_thread(batch_id: nil, batch_callback_id: nil)
+      original_batch_id = current_batch_id
+      original_batch_callback_id = current_batch_callback_id
+
+      self.current_batch_id = batch_id
+      self.current_batch_callback_id = batch_callback_id
+
+      yield
+    ensure
+      self.current_batch_id = original_batch_id
+      self.current_batch_callback_id = original_batch_callback_id
+    end
+
+    def initialize(_record: nil, **properties) # rubocop:disable Lint/UnderscorePrefixedVariableName
+      self.record = _record || BatchRecord.new
+      assign_properties(properties)
+    end
+
+    # @return [Array<ActiveJob::Base>] Active jobs added to the batch
+    def enqueue(active_jobs = [], **properties, &block)
+      assign_properties(properties)
+      record.save!
+
+      active_jobs = add(active_jobs, &block)
+
+      record.finished_at = nil
+      record.enqueued_at = Time.current if enqueued_at.nil?
+      record.save!
+
+      record._continue_discard_or_finish
+      active_jobs
+    end
+
+    # Enqueue jobs and add them to the batch
+    # @param block [Proc] Enqueue jobs within the block to add them to the batch
+    # @return [Array<ActiveJob::Base>] Active jobs added to the batch
+    def add(active_jobs = nil, &block)
+      record.save if record.new_record?
+
+      buffer = Bulk::Buffer.new
+      buffer.add(active_jobs)
+      buffer.capture(&block) if block
+
+      self.class.within_thread(batch_id: id) do
+        buffer.enqueue
+      end
+
+      buffer.active_jobs
+    end
+
+    def active_jobs
+      record.jobs.map(&:head_execution).map(&:active_job)
+    end
+
+    def callback_active_jobs
+      record.callback_jobs.map(&:head_execution).map(&:active_job)
+    end
+
+    def assign_properties(properties)
+      properties = properties.dup
+      batch_attrs = PROTECTED_PROPERTIES.index_with { |key| properties.delete(key) }.compact
+      record.assign_attributes(batch_attrs)
+      self.properties.merge!(properties)
+    end
+
+    def _record
+      record
+    end
+
+    private
+
+    attr_accessor :record
+  end
+end

data/app/models/good_job/batch_record.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module GoodJob
+  class BatchRecord < BaseRecord
+    include Lockable
+
+    self.table_name = 'good_job_batches'
+
+    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
+    has_many :callback_jobs, class_name: 'GoodJob::Job', foreign_key: :batch_callback_id, dependent: nil # rubocop:disable Rails/InverseOf
+
+    scope :finished, -> { where.not(finished_at: nil) }
+    scope :discarded, -> { where.not(discarded_at: nil) }
+    scope :not_discarded, -> { where(discarded_at: nil) }
+    scope :succeeded, -> { finished.not_discarded }
+
+    alias_attribute :enqueued?, :enqueued_at
+    alias_attribute :discarded?, :discarded_at
+    alias_attribute :finished?, :finished_at
+
+    scope :display_all, (lambda do |after_created_at: nil, after_id: nil|
+      query = order(created_at: :desc, id: :desc)
+      if after_created_at.present? && after_id.present?
+        query = query.where(Arel.sql('(created_at, id) < (:after_created_at, :after_id)'), after_created_at: after_created_at, after_id: after_id)
+      elsif after_created_at.present?
+        query = query.where(Arel.sql('(after_created_at) < (:after_created_at)'), after_created_at: after_created_at)
+      end
+      query
+    end)
+
+    # Whether the batch has finished and no jobs were discarded
+    # @return [Boolean]
+    def succeeded?
+      !discarded? && finished?
+    end
+
+    def to_batch
+      Batch.new(_record: self)
+    end
+
+    def display_attributes
+      attributes.except('serialized_properties').merge(properties: properties)
+    end
+
+    def _continue_discard_or_finish(execution = nil)
+      execution_discarded = execution && execution.error.present? && execution.retried_good_job_id.nil?
+      with_advisory_lock(function: "pg_advisory_lock") do
+        Batch.within_thread(batch_id: nil, batch_callback_id: id) do
+          if execution_discarded && discarded_at.blank?
+            update(discarded_at: Time.current)
+            on_discard.constantize.set(priority: callback_priority, queue: callback_queue_name).perform_later(to_batch, { event: :discard }) if on_discard.present?
+          end
+
+          if !finished_at && enqueued_at && jobs.where(finished_at: nil).count.zero?
+            update(finished_at: Time.current)
+            on_success.constantize.set(priority: callback_priority, queue: callback_queue_name).perform_later(to_batch, { event: :success }) if !discarded_at && on_success.present?
+            on_finish.constantize.set(priority: callback_priority, queue: callback_queue_name).perform_later(to_batch, { event: :finish }) if on_finish.present?
+          end
+        end
+      end
+    end
+
+    class PropertySerializer
+      def self.dump(value)
+        ActiveJob::Arguments.serialize([value]).first
+      end
+
+      def self.load(value)
+        ActiveJob::Arguments.deserialize([value]).first
+      end
+    end
+
+    attribute :serialized_properties, :json, default: -> { {} } # Can be set as default value in `serialize` as of Rails v6.1
+    serialize :serialized_properties, PropertySerializer
+    alias_attribute :properties, :serialized_properties
+
+    def properties=(value)
+      raise ArgumentError, "Properties must be a Hash" unless value.is_a?(Hash)
+
+      self.serialized_properties = value
+    end
+  end
+end

data/app/models/good_job/execution.rb

@@ -20,8 +20,12 @@ module GoodJob
     self.table_name = 'good_jobs'
     self.advisory_lockable_column = 'active_job_id'
 
+    define_model_callbacks :perform
     define_model_callbacks :perform_unlocked, only: :after
 
+    set_callback :perform, :around, :reset_batch_values
+    set_callback :perform_unlocked, :after, :continue_discard_or_finish_batch
+
     # Parse a string representing a group of queues into a more readable data
     # structure.
     # @param string [String] Queue string
@@ -65,6 +69,9 @@ module GoodJob
       end
     end
 
+    belongs_to :batch, class_name: 'GoodJob::BatchRecord', optional: true, inverse_of: :executions
+    belongs_to :batch_callback, class_name: 'GoodJob::Batch', optional: true
+
     belongs_to :job, class_name: 'GoodJob::Job', foreign_key: 'active_job_id', primary_key: 'active_job_id', optional: true, inverse_of: :executions
     after_destroy -> { self.class.active_job_id(active_job_id).delete_all }, if: -> { @_destroy_job }
 
@@ -206,14 +213,24 @@ module GoodJob
         serialized_params: active_job.serialize,
         scheduled_at: active_job.scheduled_at,
       }
-
       execution_args[:concurrency_key] = active_job.good_job_concurrency_key if active_job.respond_to?(:good_job_concurrency_key)
 
-      if CurrentThread.cron_key
+      reenqueued_current_execution = CurrentThread.active_job_id && CurrentThread.active_job_id == active_job.job_id
+      current_execution = CurrentThread.execution
+
+      if reenqueued_current_execution
+        if GoodJob::BatchRecord.migrated?
+          execution_args[:batch_id] = current_execution.batch_id
+          execution_args[:batch_callback_id] = current_execution.batch_callback_id
+        end
+        execution_args[:cron_key] = current_execution.cron_key
+      else
+        if GoodJob::BatchRecord.migrated?
+          execution_args[:batch_id] = GoodJob::Batch.current_batch_id
+          execution_args[:batch_callback_id] = GoodJob::Batch.current_batch_callback_id
+        end
         execution_args[:cron_key] = CurrentThread.cron_key
         execution_args[:cron_at] = CurrentThread.cron_at
-      elsif CurrentThread.active_job_id && CurrentThread.active_job_id == active_job.job_id
-        execution_args[:cron_key] = CurrentThread.execution.cron_key
       end
 
       new(**execution_args.merge(overrides))
@@ -283,7 +300,6 @@ module GoodJob
 
         execution.save!
         active_job.provider_job_id = execution.id
-
         CurrentThread.execution.retried_good_job_id = execution.id if CurrentThread.active_job_id && CurrentThread.active_job_id == active_job.job_id
 
         execution
@@ -296,27 +312,29 @@ module GoodJob
     #   exception raised by the job, if any. If the job completed successfully,
     #   the second array entry (the exception) will be +nil+ and vice versa.
     def perform
-      raise PreviouslyPerformedError, 'Cannot perform a job that has already been performed' if finished_at
+      run_callbacks(:perform) do
+        raise PreviouslyPerformedError, 'Cannot perform a job that has already been performed' if finished_at
 
-      self.performed_at = Time.current
-      save! if GoodJob.preserve_job_records
+        self.performed_at = Time.current
+        save! if GoodJob.preserve_job_records
 
-      result = execute
+        result = execute
 
-      job_error = result.handled_error || result.unhandled_error
-      self.error = [job_error.class, ERROR_MESSAGE_SEPARATOR, job_error.message].join if job_error
+        job_error = result.handled_error || result.unhandled_error
+        self.error = [job_error.class, ERROR_MESSAGE_SEPARATOR, job_error.message].join if job_error
 
-      reenqueued = result.retried? || retried_good_job_id.present?
-      if result.unhandled_error && GoodJob.retry_on_unhandled_error
-        save!
-      elsif GoodJob.preserve_job_records == true || reenqueued || (result.unhandled_error && GoodJob.preserve_job_records == :on_unhandled_error) || cron_key.present?
-        self.finished_at = Time.current
-        save!
-      else
-        destroy_job
-      end
+        reenqueued = result.retried? || retried_good_job_id.present?
+        if result.unhandled_error && GoodJob.retry_on_unhandled_error
+          save!
+        elsif GoodJob.preserve_job_records == true || reenqueued || (result.unhandled_error && GoodJob.preserve_job_records == :on_unhandled_error) || cron_key.present?
+          self.finished_at = Time.current
+          save!
+        else
+          destroy_job
+        end
 
-      result
+        result
+      end
     end
 
     # Tests whether this job is safe to be executed by this thread.
@@ -411,5 +429,13 @@ module GoodJob
         end
       end
     end
+
+    def reset_batch_values(&block)
+      GoodJob::Batch.within_thread(batch_id: nil, batch_callback_id: nil, &block)
+    end
+
+    def continue_discard_or_finish_batch
+      batch._continue_discard_or_finish(self) if GoodJob::BatchRecord.migrated? && batch.present?
+    end
   end
 end

data/app/models/good_job/job.rb

@@ -28,6 +28,7 @@ module GoodJob
     self.primary_key = 'active_job_id'
     self.advisory_lockable_column = 'active_job_id'
 
+    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
 
     # Only the most-recent unretried execution represents a "Job"

data/app/views/good_job/batches/_jobs.erb

@@ -0,0 +1,108 @@
+  <div class="my-3 card" data-gj-poll-replace id="jobs-table">
+    <div class="list-group list-group-flush text-nowrap table-jobs" role="table">
+      <header class="list-group-item bg-light">
+        <div class="row small text-muted text-uppercase align-items-center">
+          <div class="col-4">Jobs</div>
+          <div class="col-1">Queue</div>
+          <div class="col-1">Priority</div>
+          <div class="col-1 text-end">Attempts</div>
+          <div class="col text-end">
+            <%= tag.button type: "button", class: "btn btn-sm text-muted", role: "button",
+                           data: { bs_toggle: "collapse", bs_target: ".job-params" },
+                           aria: { expanded: false, controls: jobs.map { |job| "##{dom_id(job, "params")}" }.join(" ") } do %>
+              <%= render_icon "info" %>
+              <span class="visually-hidden">Inspect</span>
+            <% end %>
+          </div>
+        </div>
+      </header>
+
+      <% if jobs.present? %>
+        <% jobs.each do |job| %>
+          <div role="row" class="list-group-item list-group-item-action py-3">
+            <div class="row align-items-center">
+              <div class="col-4">
+                <%= tag.code link_to(job.id, job_path(job), class: "small text-muted text-decoration-none") %>
+                <%= tag.h5 tag.code(link_to(job.job_class, job_path(job), class: "text-reset text-decoration-none")), class: "text-reset mb-0" %>
+              </div>
+              <div class="col-1">
+                <span class="badge bg-primary bg-opacity-25 text-dark font-monospace"><%= job.queue_name %></span>
+              </div>
+              <div class="col-1 small text-center">
+                <span class="font-monospace fw-bold"><%= job.priority %></span>
+              </div>
+              <div class="col-1 text-center">
+                <% if job.executions_count > 0 && job.status != :finished %>
+                  <%= tag.span job.executions_count, class: "badge rounded-pill bg-danger", data: {
+                    bs_toggle: "popover",
+                    bs_trigger: "hover focus click",
+                    bs_placement: "bottom",
+                    bs_content: job.recent_error
+                  } %>
+                <% else %>
+                  <span class="badge bg-secondary bg-opacity-50 rounded-pill"><%= job.executions_count %></span>
+                <% end %>
+              </div>
+              <div class="col d-flex gap-3 align-items-center justify-content-end">
+                <%= tag.span relative_time(job.last_status_at), class: "small" %>
+                <%= status_badge job.status %>
+              </div>
+              <div class="col-auto">
+                <div class="dropdown float-end">
+                  <button class="d-flex align-items-center btn btn-sm" type="button" id="<%= dom_id(job, :actions) %>" data-bs-toggle="dropdown" aria-expanded="false">
+                    <%= render "good_job/shared/icons/dots" %>
+                    <span class="visually-hidden">Actions</span>
+                  </button>
+                  <ul class="dropdown-menu shadow" aria-labelledby="<%= dom_id(job, :actions) %>">
+                    <li>
+                      <% job_reschedulable = job.status.in? [:scheduled, :retried, :queued] %>
+                      <%= link_to reschedule_job_path(job.id), method: :put, class: "dropdown-item #{'disabled' unless job_reschedulable}", title: "Reschedule job", data: { confirm: "Confirm reschedule", disable: true } do %>
+                        <%= render "good_job/shared/icons/skip_forward" %>
+                        Reschedule
+                      <% end %>
+                    </li>
+                    <li>
+                      <% job_discardable = job.status.in? [:scheduled, :retried, :queued] %>
+                      <%= link_to discard_job_path(job.id), method: :put, class: "dropdown-item #{'disabled' unless job_discardable}", title: "Discard job", data: { confirm: "Confirm discard", disable: true } do %>
+                        <%= render "good_job/shared/icons/stop" %>
+                        Discard
+                      <% end %>
+                    </li>
+                    <li>
+                      <%= link_to retry_job_path(job.id), method: :put, class: "dropdown-item #{'disabled' unless job.status == :discarded}", title: "Retry job", data: { confirm: "Confirm retry", disable: true } do %>
+                        <%= render "good_job/shared/icons/arrow_clockwise" %>
+                        Retry
+                      <% end %>
+                    </li>
+                    <li>
+                      <%= link_to job_path(job.id), method: :delete, class: "dropdown-item #{'disabled' unless job.status.in? [:discarded, :finished]}", title: "Destroy job", data: { confirm: "Confirm destroy", disable: true } do %>
+                        <%= render_icon "trash" %>
+                        Destroy
+                      <% end %>
+                    </li>
+
+                    <li>
+                      <%= link_to "##{dom_id(job, 'params')}",
+                                  class: "dropdown-item",
+                                  data: { bs_toggle: "collapse" },
+                                  aria: { expanded: false, controls: dom_id(job, "params") } do %>
+                        <%= render_icon "info" %>
+                        Inspect
+                      <% end %>
+                    </li>
+                  </ul>
+                </div>
+              </div>
+            </div>
+          </div>
+          <%= tag.div id: dom_id(job, "params"), class: "job-params list-group-item collapse small bg-dark text-light" do %>
+            <%= tag.pre JSON.pretty_generate(job.display_serialized_params) %>
+          <% end %>
+        <% end %>
+      <% else %>
+        <div class="list-group-item py-4 text-center text-muted">
+          No jobs found.
+        </div>
+      <% end %>
+    </>
+  </div>

data/app/views/good_job/batches/_table.erb

@@ -0,0 +1,61 @@
+  <div class="my-3 card" data-gj-poll-replace id="batches-table">
+    <div class="list-group list-group-flush text-nowrap table-batches" role="table">
+      <header class="list-group-item bg-light">
+        <div class="row small text-muted text-uppercase align-items-center">
+          <div class="col-4">Name</div>
+          <div class="col-1">Created</div>
+          <div class="col-1">Enqueued</div>
+          <div class="col-1">Discarded</div>
+          <div class="col-1">Finished</div>
+          <div class="col">Jobs</div>
+          <div class="col text-end">
+            <%= tag.button type: "button", class: "btn btn-sm text-muted", role: "button",
+                           data: { bs_toggle: "collapse", bs_target: ".batch-properties" },
+                           aria: { expanded: false, controls: batches.map { |batch| "##{dom_id(batch, "params")}" }.join(" ") } do %>
+              <%= render_icon "info" %>
+              <span class="visually-hidden">Inspect</span>
+            <% end %>
+          </div>
+        </div>
+      </header>
+
+      <% if batches.present? %>
+        <% batches.each do |batch| %>
+          <div id="<%= dom_id(batch) %>" class="list-group-item py-3" role="row">
+            <div class="row align-items-center">
+              <div class="col-4">
+                <%= link_to batch_path(batch), class: "text-decoration-none" do %>
+                  <code class="small text-muted">
+                    <%= batch.id %>
+                  </code>
+                  <h5 class=""><code><%= batch.on_finish %></code></h5>
+                  <div class="text-muted"><%= batch.description %></div>
+                <% end %>
+              </div>
+              <div class="col-1 text-wrap"><%= relative_time(batch.created_at)  %></div>
+              <div class="col-1 text-wrap"><%= relative_time(batch.enqueued_at) if batch.enqueued_at %></div>
+              <div class="col-1 text-wrap"><%= relative_time(batch.discarded_at) if batch.discarded_at %></div>
+              <div class="col-1 text-wrap"><%= relative_time(batch.finished_at) if batch.finished_at %></div>
+              <div class="col"><%= batch.jobs.count %></div>
+              <div class="col text-end">
+                <%= tag.button type: "button", class: "btn btn-sm text-muted ms-auto", role: "button",
+                               title: "Inspect",
+                               data: { bs_toggle: "collapse", bs_target: "##{dom_id(batch, 'properties')}" },
+                               aria: { expanded: false, controls: dom_id(batch, "state") } do %>
+                  <%= render_icon "info" %>
+                  <span class="visually-hidden">Inspect</span>
+                <% end %>
+              </div>
+            </div>
+          </div>
+          <%= tag.div id: dom_id(batch, "properties"), class: "batch-properties list-group-item collapse small bg-dark text-light" do %>
+            <%= tag.pre JSON.pretty_generate(batch.properties) %>
+          <% end %>
+        <% end %>
+      <% else %>
+        <div class="list-group-item py-4 text-center text-muted">
+          No batches found.
+        </div>
+      <% end %>
+    </div>
+  </div>

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

@@ -0,0 +1,16 @@
+<% if GoodJob::BatchRecord.migrated? %>
+  <%= render 'good_job/batches/table', batches: @filter.records, filter: @filter %>
+  <% if @filter.records.present? %>
+    <nav aria-label="Batch pagination" class="mt-3">
+      <ul class="pagination">
+        <li class="page-item">
+          <%= link_to(@filter.to_params(after_created_at: @filter.last.created_at, after_id: @filter.last.id), class: "page-link") do %>
+            Older batches <span aria-hidden="true">&raquo;</span>
+          <% end %>
+        </li>
+      </ul>
+    </nav>
+  <% end %>
+<% else %>
+  <h3 class="text-center my-5">GoodJob has pending database migrations.</h3>
+<% end %>

data/app/views/good_job/batches/show.html.erb

@@ -0,0 +1,30 @@
+<div class="break-out bg-light border-bottom py-2 mb-3">
+  <div class="container-fluid pt-2">
+    <div class="row align-items-center">
+      <div class="col-5">
+        <nav aria-label="breadcrumb">
+          <ol class="breadcrumb small mb-0">
+            <li class="breadcrumb-item"><%= link_to "Batches", batches_path %></li>
+            <li class="breadcrumb-item active" aria-current="page"><%= tag.code @batch.id, class: "text-muted" %></li>
+          </ol>
+          <h2 class="h5 mt-2"><%= @batch.description %></h2>
+        </nav>
+      </div>
+    </div>
+  </div>
+</div>
+
+<div class="my-4">
+  <h5>Attributes</h5>
+  <%= tag.pre JSON.pretty_generate @batch.display_attributes, class: 'text-wrap text-break' %>
+</div>
+
+<div class="my-4">
+  <h5>Callback Jobs</h5>
+  <%= render 'jobs', jobs: @batch.callback_jobs.reverse %>
+</div>
+
+<div class="my-4">
+  <h5>Batched Jobs</h5>
+  <%= render 'jobs', jobs: @batch.jobs.reverse %>
+</div>

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

@@ -14,6 +14,13 @@
             <span class="badge bg-secondary rounded-pill"><%= number_to_human(jobs_count) %></span>
         <% end %>
         </li>
+        <li class="nav-item">
+          <%= link_to batches_path, class: ["nav-link", ("active" if controller_name == 'batches')] do %>
+            <%= "Batches" %>
+            <% batches_count = GoodJob::BatchRecord.migrated? ? GoodJob::BatchRecord.all.size : 0 %>
+            <span class="badge bg-secondary rounded-pill"><%= batches_count %></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") %>

data/config/routes.rb

@@ -15,6 +15,8 @@ GoodJob::Engine.routes.draw do
     end
   end
 
+  resources :batches, only: %i[index show]
+
   resources :cron_entries, only: %i[index show], param: :cron_key do
     member do
       post :enqueue

data/lib/generators/good_job/templates/install/migrations/create_good_jobs.rb.erb

@@ -19,6 +19,23 @@ class CreateGoodJobs < ActiveRecord::Migration<%= migration_version %>
       t.text :cron_key
       t.uuid :retried_good_job_id
       t.datetime :cron_at
+
+      t.uuid :batch_id
+      t.uuid :batch_callback_id
+    end
+
+    create_table :good_job_batches, id: :uuid do |t|
+      t.timestamps
+      t.text :description
+      t.jsonb :serialized_properties
+      t.text :on_finish
+      t.text :on_success
+      t.text :on_discard
+      t.text :callback_queue_name
+      t.integer :callback_priority
+      t.datetime :enqueued_at
+      t.datetime :discarded_at
+      t.datetime :finished_at
     end
 
     create_table :good_job_processes, id: :uuid do |t|
@@ -43,5 +60,7 @@ class CreateGoodJobs < ActiveRecord::Migration<%= migration_version %>
     add_index :good_jobs, [:finished_at], where: "retried_good_job_id IS NULL AND finished_at IS NOT NULL", name: :index_good_jobs_jobs_on_finished_at
     add_index :good_jobs, [:priority, :created_at], order: { priority: "DESC NULLS LAST", created_at: :asc },
       where: "finished_at IS NULL", name: :index_good_jobs_jobs_on_priority_created_at_when_unfinished
+    add_index :good_jobs, [:batch_id], where: "batch_id IS NOT NULL"
+    add_index :good_jobs, [:batch_callback_id], where: "batch_callback_id IS NOT NULL"
   end
 end

data/lib/generators/good_job/templates/update/migrations/04_create_good_job_batches.rb.erb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+class CreateGoodJobBatches < ActiveRecord::Migration<%= migration_version %>
+  def change
+    reversible do |dir|
+      dir.up do
+        # Ensure this incremental update migration is idempotent
+        # with monolithic install migration.
+        return if connection.table_exists?(:good_job_batches)
+      end
+    end
+
+    create_table :good_job_batches, id: :uuid do |t|
+      t.timestamps
+      t.text :description
+      t.jsonb :serialized_properties
+      t.text :on_finish
+      t.text :on_success
+      t.text :on_discard
+      t.text :callback_queue_name
+      t.integer :callback_priority
+      t.datetime :enqueued_at
+      t.datetime :discarded_at
+      t.datetime :finished_at
+    end
+
+    change_table :good_jobs do |t|
+      t.uuid :batch_id
+      t.uuid :batch_callback_id
+
+      t.index :batch_id, where: "batch_id IS NOT NULL"
+      t.index :batch_callback_id, where: "batch_callback_id IS NOT NULL"
+    end
+  end
+end

data/lib/good_job/active_job_extensions/batches.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module GoodJob
+  module ActiveJobExtensions
+    module Batches
+      extend ActiveSupport::Concern
+
+      def batch
+        @_batch ||= CurrentThread.execution&.batch&.to_batch
+      end
+      alias batch? batch
+    end
+  end
+end

data/lib/good_job/bulk.rb

@@ -15,19 +15,14 @@ module GoodJob
     # @param active_jobs [Array<ActiveJob::Base>] Active Jobs to be buffered.
     # @param queue_adapter Override the jobs implict queue adapter with an explicit one.
     # @return [nil, Array<ActiveJob::Base>] The ActiveJob instances that have been buffered; nil if no active buffer
-    def self.capture(active_jobs = nil, queue_adapter: nil)
-      raise(ArgumentError, "Use either the block form or the argument form, not both") if block_given? && active_jobs
-
-      if block_given?
-        begin
-          original_buffer = current_buffer
-          self.current_buffer = Buffer.new
-          yield
-          current_buffer.active_jobs
-        ensure
-          self.current_buffer = original_buffer
-        end
-      else
+    def self.capture(active_jobs = nil, queue_adapter: nil, &block)
+      raise(ArgumentError, "Use either the block form or the argument form, not both") if block && active_jobs
+
+      if block
+        buffer = Buffer.new
+        buffer.capture(&block)
+        buffer.active_jobs
+      elsif current_buffer
         current_buffer&.add(active_jobs, queue_adapter: queue_adapter)
       end
     end
@@ -35,16 +30,15 @@ module GoodJob
     # Capture jobs to a buffer and enqueue them all at once; or enqueue the current buffer.
     # @param active_jobs [Array<ActiveJob::Base>] Active Jobs to be enqueued.
     # @return [Array<ActiveJob::Base>] The ActiveJob instances that have been captured; check provider_job_id to confirm enqueued.
-    def self.enqueue(active_jobs = nil)
-      raise(ArgumentError, "Use either the block form or the argument form, not both") if block_given? && active_jobs
+    def self.enqueue(active_jobs = nil, &block)
+      raise(ArgumentError, "Use either the block form or the argument form, not both") if block && active_jobs
 
-      if block_given?
-        capture do
-          yield
-          current_buffer&.enqueue
-        end
+      buffer = Buffer.new
+      if block
+        buffer.capture(&block)
+        buffer.enqueue
+        buffer.active_jobs
       elsif active_jobs.present?
-        buffer = Buffer.new
         buffer.add(active_jobs)
         buffer.enqueue
         buffer.active_jobs
@@ -69,8 +63,18 @@ module GoodJob
         @values = []
       end
 
+      def capture
+        original_buffer = Bulk.current_buffer
+        Bulk.current_buffer = self
+        yield
+      ensure
+        Bulk.current_buffer = original_buffer
+      end
+
       def add(active_jobs, queue_adapter: nil)
         new_pairs = Array(active_jobs).map do |active_job|
+          raise ArgumentError, "Expected an ActiveJob::Base instance, got #{active_job.class}" unless active_job.is_a?(ActiveJob::Base)
+
           adapter = queue_adapter || active_job.class.queue_adapter
           raise Error, "Jobs must have a Queue Adapter" unless adapter
 

data/lib/good_job/log_subscriber.rb

@@ -156,7 +156,7 @@ module GoodJob
       destroyed_records_count = event.payload[:destroyed_records_count]
 
       info do
-        "GoodJob destroyed #{destroyed_records_count} preserved #{'job'.pluralize(destroyed_records_count)} finished before #{timestamp}."
+        "GoodJob destroyed #{destroyed_records_count} preserved job execution #{'records'.pluralize(destroyed_records_count)} finished before #{timestamp}."
       end
     end
 

data/lib/good_job/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module GoodJob
   # GoodJob gem version.
-  VERSION = '3.9.0'
+  VERSION = '3.10.0'
 end

data/lib/good_job.rb

@@ -8,6 +8,7 @@ require "good_job/engine"
 require "good_job/adapter"
 require "active_job/queue_adapters/good_job_adapter"
 require "good_job/active_job_extensions/concurrency"
+require "good_job/active_job_extensions/batches"
 
 require "good_job/assignable_connection"
 require "good_job/bulk"
@@ -143,7 +144,7 @@ module GoodJob
     end
   end
 
-  # Destroys preserved job records.
+  # Destroys preserved job and batch records.
   # By default, GoodJob destroys job records when the job is performed and this
   # method is not necessary. However, when `GoodJob.preserve_job_records = true`,
   # the jobs will be preserved in the database. This is useful when wanting to
@@ -151,7 +152,7 @@ module GoodJob
   # If you are preserving job records this way, use this method regularly to
   # destroy old records and preserve space in your database.
   # @params older_than [nil,Numeric,ActiveSupport::Duration] Jobs older than this will be destroyed (default: +86400+).
-  # @return [Integer] Number of jobs that were destroyed.
+  # @return [Integer] Number of job execution records and batches that were destroyed.
   def self.cleanup_preserved_jobs(older_than: nil)
     older_than ||= GoodJob.configuration.cleanup_preserved_jobs_before_seconds_ago
     timestamp = Time.current - older_than
@@ -160,10 +161,19 @@ module GoodJob
     ActiveSupport::Notifications.instrument("cleanup_preserved_jobs.good_job", { older_than: older_than, timestamp: timestamp }) do |payload|
       old_jobs = GoodJob::Job.where('finished_at <= ?', timestamp)
       old_jobs = old_jobs.succeeded unless include_discarded
-      old_jobs_count = old_jobs.count
-
-      GoodJob::Execution.where(job: old_jobs).delete_all
-      payload[:destroyed_records_count] = old_jobs_count
+      deleted_executions_count = GoodJob::Execution.where(job: old_jobs).delete_all
+
+      if GoodJob::BatchRecord.migrated?
+        old_batches = GoodJob::BatchRecord.where('finished_at <= ?', timestamp)
+        old_batches = old_batches.succeeded unless include_discarded
+        deleted_batches_count = old_batches.delete_all
+      else
+        deleted_batches_count = 0
+      end
+
+      payload[:destroyed_executions_count] = deleted_executions_count
+      payload[:destroyed_batches_count] = deleted_batches_count
+      payload[:destroyed_records_count] = deleted_executions_count + deleted_batches_count
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 3.9.0
+  version: 3.10.0
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-01-31 00:00:00.000000000 Z
+date: 2023-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -334,16 +334,20 @@ files:
 - app/charts/good_job/scheduled_by_queue_chart.rb
 - app/controllers/good_job/application_controller.rb
 - app/controllers/good_job/assets_controller.rb
+- app/controllers/good_job/batches_controller.rb
 - app/controllers/good_job/cron_entries_controller.rb
 - app/controllers/good_job/jobs_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/helpers/good_job/application_helper.rb
 - app/models/concerns/good_job/filterable.rb
 - app/models/concerns/good_job/reportable.rb
 - app/models/good_job/active_job_job.rb
 - app/models/good_job/base_record.rb
+- app/models/good_job/batch.rb
+- app/models/good_job/batch_record.rb
 - app/models/good_job/cron_entry.rb
 - app/models/good_job/execution.rb
 - app/models/good_job/execution_result.rb
@@ -351,6 +355,10 @@ files:
 - app/models/good_job/lockable.rb
 - app/models/good_job/process.rb
 - app/models/good_job/setting.rb
+- app/views/good_job/batches/_jobs.erb
+- app/views/good_job/batches/_table.erb
+- app/views/good_job/batches/index.html.erb
+- app/views/good_job/batches/show.html.erb
 - app/views/good_job/cron_entries/index.html.erb
 - app/views/good_job/cron_entries/show.html.erb
 - app/views/good_job/jobs/_executions.erb
@@ -390,8 +398,10 @@ files:
 - lib/generators/good_job/templates/update/migrations/01_create_good_jobs.rb.erb
 - lib/generators/good_job/templates/update/migrations/02_create_good_job_settings.rb.erb
 - lib/generators/good_job/templates/update/migrations/03_create_index_good_jobs_jobs_on_priority_created_at_when_unfinished.rb.erb
+- lib/generators/good_job/templates/update/migrations/04_create_good_job_batches.rb.erb
 - lib/generators/good_job/update_generator.rb
 - lib/good_job.rb
+- lib/good_job/active_job_extensions/batches.rb
 - lib/good_job/active_job_extensions/concurrency.rb
 - lib/good_job/adapter.rb
 - lib/good_job/assignable_connection.rb