scatter_gather 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1226dbbaeb58d454646982ccecd8bc3512efd45b5ae51a22031ea744b061768b
-  data.tar.gz: a75ecd0241e1556d8b060321b9e0d3a46f18c070c4d85efe9d80239a5c5f4eae
+  metadata.gz: 97e842d4c2d232e8b3230e0fc7139190af57d3495ccc43dde441e7e873788546
+  data.tar.gz: f542418d42fd82919da4efc41624e5a6855bbaf55fc007cf7bbe2891a461090f
 SHA512:
-  metadata.gz: 8a44383f3f3d215668122e7a262059c891fff87f2892c30a5bf72630eaad2d2ab6008f2abacbb831c72bf9e66647ffbc9d340d988e056effc75b5f7826704e97
-  data.tar.gz: d60c239b73a6f988c195194bdb26d9c0e6458eff9c11e4c387cfd7607fe13f5461086c7f210acc32ec6b540d50bf8536197f3964e8e5002b534ac4c0328fa4cb
+  metadata.gz: 6e73aad981d7f03948b71b7ee87ceba00a8e53d4864456f4f3a4ba7254d66b54450e5d305975af27535fa59c430e669043694a6fc8216cd3457cd9664099ff53
+  data.tar.gz: c25cd3dcac36b969e2eb8d9131c710ee582e97623d2617ab5c98e0f2a7e9f2ba2daef543d4670f6f14dd7c63a07fa833cce64907a26defd8b63e2ff6be1e86c4

data/lib/generators/scatter_gather/install_generator.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module ScatterGather
+  module Generators
+    # The generator is used to install ScatterGather. It adds the migration that creates
+    # the scatter_gather_completions table.
+    # Run it with `bin/rails g scatter_gather:install` in your console.
+    class InstallGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      source_paths << File.dirname(__FILE__)
+
+      # Generates migration file that creates the scatter_gather_completions table.
+      def create_migration_file
+        # Migration files are named "...migration_001.rb" etc. This allows them to be emitted
+        # as they get added, and the order of the migrations can be controlled using predictable sorting.
+        # Adding a new migration to the gem is then just adding a file.
+        migration_file_paths_in_order = Dir.glob(__dir__ + "/*_migration_*.rb.erb").sort
+        migration_file_paths_in_order.each do |migration_template_path|
+          untemplated_migration_filename = File.basename(migration_template_path).gsub(/\.erb$/, "")
+          migration_template(migration_template_path, File.join(db_migrate_path, untemplated_migration_filename))
+        end
+      end
+
+      private
+
+      def migration_version
+        ActiveRecord::VERSION::STRING.split(".").take(2).join(".")
+      end
+    end
+  end
+end

data/lib/generators/scatter_gather/scatter_gather_migration_001.rb.erb

@@ -0,0 +1,59 @@
+class ScatterGatherMigration001 < ActiveRecord::Migration[<%= migration_version %>]
+  def up
+    # Detect dominant ID type by scanning existing tables
+    id_type = detect_dominant_id_type
+    
+    # Only specify id: :uuid if UUID is dominant, otherwise use Rails defaults
+    table_options = (id_type == :uuid) ? {id: :uuid} : {}
+    
+    create_table :scatter_gather_completions, **table_options do |t|
+      t.string :active_job_id, null: false
+      t.string :active_job_class_name
+      t.string :status, default: "unknown"
+      t.timestamps
+    end
+    add_index :scatter_gather_completions, [:active_job_id], unique: true # For lookups
+    add_index :scatter_gather_completions, [:created_at] # For cleanup
+  end
+
+  private
+
+  # Scans existing tables to detect whether UUID or serial ID is dominant
+  # @return [Symbol] :uuid or :serial based on dominant ID type
+  def detect_dominant_id_type
+    return :serial if table_count == 0
+
+    uuid_count = 0
+    serial_count = 0
+
+    connection.tables.each do |table_name|
+      next if table_name == "schema_migrations" || table_name == "ar_internal_metadata"
+      
+      begin
+        columns = connection.columns(table_name)
+        id_column = columns.find { |col| col.name == "id" }
+        next unless id_column
+
+        if id_column.type == :uuid
+          uuid_count += 1
+        elsif id_column.type == :integer || id_column.type == :bigint
+          serial_count += 1
+        end
+      rescue => e
+        # Skip tables that can't be inspected (e.g., views, system tables)
+        Rails.logger.debug "Could not inspect table #{table_name}: #{e.message}"
+      end
+    end
+
+    # Default to serial if no clear preference or equal counts
+    (uuid_count > serial_count) ? :uuid : :serial
+  end
+
+  def table_count
+    @table_count ||= connection.tables.count
+  end
+
+  def down
+    drop_table :scatter_gather_completions
+  end
+end

data/lib/scatter_gather/completion.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# ActiveJob itself does not maintain a "one record per job" database entry where we could reliably track job completion.
+# The underlying job storage (e.g., Sidekiq, Que, DelayedJob) is determined by the ActiveJob adapter, and their implementation details vary.
+# As a result, to enable reliable scatter-gather orchestration, we create our own completion tracking records.
+# Each job that is meant to be gathered later inserts a record into the scatter_gather_completions table when it is enqueued,
+# and marks it as completed upon finishing. This ensures adapter-independent, uniform dependency tracking.
+class ScatterGather::Completion < ActiveRecord::Base
+  self.table_name = "scatter_gather_completions"
+
+  # Collect status information for the given active job IDs
+  # @param active_job_ids [Array<String>] Array of ActiveJob IDs to check
+  # @return [Array<DependencyStatus>] Array of DependencyStatus objects
+  def self.collect_statuses(active_job_ids)
+    # Initialize all job IDs with unknown status
+    statuses = active_job_ids.map { |id| [id, :unknown] }.to_h
+
+    # Get statuses from completion records
+    completions = where(active_job_id: active_job_ids)
+      .pluck(:active_job_id, :active_job_class_name, :status)
+      .map do |(id, class_name, status)|
+        [id, {class_name: class_name, status: status.to_sym}]
+      end.to_h
+
+    # Update statuses with completion data
+    completions.each do |id, data|
+      statuses[id] = data[:status]
+    end
+
+    # Create DependencyStatus objects
+    dependency_statuses = active_job_ids.map do |id|
+      completion_data = completions[id]
+      class_name = completion_data&.dig(:class_name)
+      status = statuses[id]
+
+      ScatterGather::DependencyStatus.new(id, class_name, status)
+    end
+
+    # Sort by status first (unknown, pending, completed), then by active_job_id
+    dependency_statuses.sort_by do |ds|
+      status_order = case ds.status
+      when :unknown then 0
+      when :pending then 1
+      when :completed then 2
+      else 3
+      end
+      [status_order, ds.active_job_id.to_s]
+    end
+  end
+
+  # Check if all dependencies are completed
+  # @param dependency_statuses [Array<DependencyStatus>] Array of dependency statuses
+  # @return [Boolean] true if all dependencies are completed
+  def self.all_dependencies_completed?(dependency_statuses)
+    dependency_statuses.all? { |ds| ds.status == :completed }
+  end
+end

data/lib/scatter_gather/dependency_status.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Struct to represent the status of a dependency job
+# @param active_job_id [String] The ActiveJob ID
+# @param active_job_class [String] The ActiveJob class name
+# @param status [Symbol] The status of the job (:completed, :pending, :unknown)
+ScatterGather::DependencyStatus = Struct.new(:active_job_id, :active_job_class, :status) do
+  # Get a display-friendly class name for unknown jobs
+  # @return [String] The class name or "(unknown)" for unknown jobs
+  def display_class
+    active_job_class || "(unknown)"
+  end
+
+  # Get a checkmark for completed jobs
+  # @return [String] "✓" for completed jobs, " " for others
+  def checkmark
+    (status == :completed) ? "✓" : " "
+  end
+end

data/lib/scatter_gather/dependency_timeout_error.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# Custom exception for when gather job exhausts attempts
+class ScatterGather::DependencyTimeoutError < StandardError
+  attr_reader :dependency_statuses, :max_attempts
+
+  def initialize(max_attempts, dependency_statuses)
+    @max_attempts = max_attempts
+    @dependency_statuses = dependency_statuses
+    super(<<~MSG)
+      Gather failed after #{max_attempts} attempts. Dependencies:
+      
+      #{format_dependency_table(dependency_statuses)}
+    MSG
+  end
+
+  private
+
+  # Format dependency statuses as a plaintext table
+  # @param dependency_statuses [Array<DependencyStatus>] Array of dependency statuses
+  # @return [String] Formatted table string
+  def format_dependency_table(dependency_statuses)
+    return "No dependencies" if dependency_statuses.empty?
+
+    # Calculate column widths
+    max_id_width = dependency_statuses.map { |ds| ds.active_job_id.length }.max || 0
+    max_class_width = dependency_statuses.map { |ds| ds.display_class.length }.max || 0
+    max_status_width = dependency_statuses.map { |ds| ds.status.to_s.length }.max || 0
+
+    # Ensure minimum widths
+    id_width = [max_id_width, 6].max # "Job ID".length = 6
+    class_width = [max_class_width, 5].max # "Class".length = 5
+    status_width = [max_status_width, 5].max # "Status".length = 5
+
+    # Build table
+    lines = []
+
+    # Header
+    header = "| ✓ | %-#{id_width}s | %-#{class_width}s | %-#{status_width}s |" % ["Job ID", "Class", "Status"]
+    lines << header
+    lines << "|---|#{"-" * (id_width + 2)}|#{"-" * (class_width + 2)}|#{"-" * (status_width + 2)}|"
+
+    # Rows (dependency_statuses are already sorted from collect_statuses)
+    dependency_statuses.each do |ds|
+      row = "| %s | %-#{id_width}s | %-#{class_width}s | %-#{status_width}s |" % [
+        ds.checkmark,
+        ds.active_job_id,
+        ds.display_class,
+        ds.status.to_s
+      ]
+      lines << row
+    end
+
+    lines.join("\n")
+  end
+end

data/lib/scatter_gather/gather_job.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# Internal job class for polling and coordinating gather operations
+class ScatterGather::GatherJob < ActiveJob::Base
+  include ScatterGather
+  discard_on ScatterGather::DependencyTimeoutError
+
+  def logger = ActiveSupport::TaggedLogging.new(super).tagged("ScatterGather")
+
+  def perform(wait_for_active_job_ids:, target_job:, gather_config:, remaining_attempts:)
+    dependency_statuses = ScatterGather::Completion.collect_statuses(wait_for_active_job_ids)
+    logger.info { "Gathered completions #{tally_in_logger_format(dependency_statuses)}" }
+
+    if ScatterGather::Completion.all_dependencies_completed?(dependency_statuses)
+      logger.info { "Dependencies done, enqueueing #{target_job.fetch(:cn)}" }
+      perform_target_later_from_args(target_job)
+      ScatterGather::Completion.where(active_job_id: wait_for_active_job_ids).delete_all
+    elsif remaining_attempts < 1
+      max_attempts = gather_config.fetch(:max_attempts)
+      error = ScatterGather::DependencyTimeoutError.new(max_attempts, dependency_statuses)
+      logger.warn { "Failed to gather dependencies after #{max_attempts} attempts" }
+      ScatterGather::Completion.where(active_job_id: wait_for_active_job_ids).delete_all
+
+      # We configure our job to discard on timeout, and discard does not report the error by default
+      Rails.error.report(error)
+      raise error
+    else
+      # Re-enqueue with delay. We could poll only for dependencies which are still remaining,
+      # but for debugging this is actually worse because for hanging stuff there will be one
+      # job that hangs in the end. Knowing which jobs were part of the batch is useful!
+      args = {
+        wait_for_active_job_ids:,
+        target_job:,
+        gather_config:,
+        remaining_attempts: remaining_attempts - 1
+      }
+      wait = gather_config.fetch(:poll_interval).seconds
+      self.class.set(wait:).perform_later(**args)
+    end
+  end
+
+  private
+
+  def tally_in_logger_format(dependency_statuses)
+    dependency_statuses.map(&:status).tally.map do |status, count|
+      "#{status}=#{count}"
+    end.join(" ")
+  end
+
+  def perform_target_later_from_args(target_job)
+    # The only purpose of this is to pass all variations
+    # of `perform_later` argument shapes correctly
+    job_class = target_job.fetch(:cn).constantize
+    if target_job[:p].any? && target_job[:k] # Both
+      job_class.perform_later(*target_job[:p], **target_job[:k])
+    elsif target_job[:k] # Just kwargs
+      job_class.perform_later(**target_job[:k])
+    elsif target_job[:p] # Just posargs
+      job_class.perform_later(*target_job[:p])
+    else
+      job_class.perform_later # No args
+    end
+  end
+end

data/lib/scatter_gather/gather_job_proxy.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# Proxy class that mimics ActiveJob behavior for gather jobs
+class ScatterGather::GatherJobProxy
+  def initialize(target_class, ids, config)
+    @target_class = target_class
+    @ids = ids
+    @config = config.with_indifferent_access
+  end
+
+  # Mimic ActiveJob's perform_later method
+  # @param args [Array] Positional arguments to pass to the target job's perform method
+  # @param kwargs [Hash] Keyword arguments to pass to the target job's perform method
+  # @return [void] Enqueues the gather job
+  def perform_later(*args, **kwargs)
+    job_arguments = {cn: @target_class.name, p: args, k: kwargs}
+    gather_job_params = {
+      wait_for_active_job_ids: @ids,
+      target_job: job_arguments,
+      gather_config: @config,
+      remaining_attempts: @config.fetch(:max_attempts) - 1
+    }
+    tagged = ActiveSupport::TaggedLogging.new(Rails.logger).tagged("ScatterGather")
+    tagged.info { "Enqueueing gather job waiting for #{@ids.inspect} to run a #{@target_class.name} after" }
+    ScatterGather::GatherJob.perform_later(**gather_job_params)
+  end
+end

data/lib/scatter_gather/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ScatterGather
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/scatter_gather.rb

@@ -4,6 +4,7 @@ require "active_support"
 require "active_record"
 require "active_job"
 require "json"
+require_relative "scatter_gather/version"
 
 # Scatter-Gather Pattern for ActiveJob
 #
@@ -35,130 +36,19 @@ require "json"
 module ScatterGather
   extend ActiveSupport::Concern
 
-  class Completion < ActiveRecord::Base
-    self.table_name = "scatter_gather_completions"
-
-    def self.collect_statuses(active_job_ids)
-      statuses = active_job_ids.map { |it| [it, :unknown] }.to_h
-      statuses_from_completions = where(active_job_id: active_job_ids)
-        .pluck(:active_job_id, :status)
-        .map do |(id, st)|
-          [id, st.to_sym]
-        end.to_h
-      statuses.merge!(statuses_from_completions)
-    end
-  end
+  # Autoload sub-modules
+  autoload :DependencyStatus, "scatter_gather/dependency_status"
+  autoload :Completion, "scatter_gather/completion"
+  autoload :GatherJobProxy, "scatter_gather/gather_job_proxy"
+  autoload :DependencyTimeoutError, "scatter_gather/dependency_timeout_error"
+  autoload :GatherJob, "scatter_gather/gather_job"
 
   # Default configuration for gather jobs
   DEFAULT_GATHER_CONFIG = {
     max_attempts: 10,
-    poll_interval: 2.seconds
+    poll_interval: 2
   }.freeze
 
-  # Proxy class that mimics ActiveJob behavior for gather jobs
-  class GatherJobProxy
-    def initialize(target_class, ids, config)
-      @target_class = target_class
-      @ids = ids
-      @config = config.with_indifferent_access
-    end
-
-    # Mimic ActiveJob's perform_later method
-    # @param args [Array] Positional arguments to pass to the target job's perform method
-    # @param kwargs [Hash] Keyword arguments to pass to the target job's perform method
-    # @return [void] Enqueues the gather job
-    def perform_later(*args, **kwargs)
-      job_arguments = {cn: @target_class.name, p: args, k: kwargs}
-      gather_job_params = {
-        wait_for_active_job_ids: @ids,
-        target_job: job_arguments,
-        gather_config: @config,
-        remaining_attempts: @config.fetch(:max_attempts) - 1
-      }
-      tagged = ActiveSupport::TaggedLogging.new(Rails.logger).tagged("ScatterGather")
-      tagged.info { "Enqueueing gather job waiting for #{@ids.inspect} to run a #{@target_class.name} after" }
-      GatherJob.perform_later(**gather_job_params)
-    end
-  end
-
-  # Custom exception for when gather job exhausts attempts
-  class DependencyTimeoutError < StandardError
-    attr_reader :dependency_status
-
-    def initialize(max_attempts, dependency_status)
-      @dependency_status = dependency_status
-      super(<<~MSG)
-        Gather failed after #{max_attempts} attempts. Dependencies:
-        
-        #{JSON.pretty_generate(dependency_status)}
-      MSG
-    end
-  end
-
-  # Internal job class for polling and coordinating gather operations
-  class GatherJob < ActiveJob::Base
-    include ScatterGather
-    discard_on DependencyTimeoutError
-
-    def logger = ActiveSupport::TaggedLogging.new(super).tagged("ScatterGather")
-
-    def perform(wait_for_active_job_ids:, target_job:, gather_config:, remaining_attempts:)
-      deps = ScatterGather::Completion.collect_statuses(wait_for_active_job_ids)
-      logger.info { "Gathered completions #{tally_in_logger_format(deps)}" }
-
-      all_done = deps.values.all? { |it| it == :completed }
-      if all_done
-        logger.info { "Dependencies done, enqueueing #{target_job.fetch(:cn)}" }
-        perform_target_later_from_args(target_job)
-        Completion.where(active_job_id: wait_for_active_job_ids).delete_all
-      elsif remaining_attempts < 1
-        max_attempts = gather_config.fetch(:max_attempts)
-        error = DependencyTimeoutError.new(max_attempts, deps)
-        logger.warn { "Failed to gather dependencies after #{max_attempts} attempts" }
-        Completion.where(active_job_id: wait_for_active_job_ids).delete_all
-
-        # We configure our job to discard on timeout, and discard does not report the error by default
-        Rails.error.report(error)
-        raise error
-      else
-        # Re-enqueue with delay. We could poll only for dependencies which are still remaining,
-        # but for debugging this is actually worse because for hanging stuff there will be one
-        # job that hangs in the end. Knowing which jobs were part of the batch is useful!
-        args = {
-          wait_for_active_job_ids:,
-          target_job:,
-          gather_config:,
-          remaining_attempts: remaining_attempts - 1
-        }
-        wait = gather_config.fetch(:poll_interval)
-        self.class.set(wait:).perform_later(**args)
-      end
-    end
-
-    private
-
-    def tally_in_logger_format(hash)
-      hash.values.tally.map do |k, count|
-        "#{k}=#{count}"
-      end.join(" ")
-    end
-
-    def perform_target_later_from_args(target_job)
-      # The only purpose of this is to pass all variations
-      # of `perform_later` argument shapes correctly
-      job_class = target_job.fetch(:cn).constantize
-      if target_job[:p].any? && target_job[:k] # Both
-        job_class.perform_later(*target_job[:p], **target_job[:k])
-      elsif target_job[:k] # Just kwargs
-        job_class.perform_later(**target_job[:k])
-      elsif target_job[:p] # Just posargs
-        job_class.perform_later(*target_job[:p])
-      else
-        job_class.perform_later # No args
-      end
-    end
-  end
-
   included do
     after_perform :register_completion_for_gathering
     discard_on ScatterGather::DependencyTimeoutError

data/rbi/scatter_gather.rbi

@@ -30,52 +30,38 @@ module ScatterGather
   extend ActiveSupport::Concern
   DEFAULT_GATHER_CONFIG = T.let({
   max_attempts: 10,
-  poll_interval: 2.seconds
+  poll_interval: 2
 }.freeze, T.untyped)
-  VERSION = T.let("0.1.1", T.untyped)
+  VERSION = T.let("0.1.2", T.untyped)
 
   # sord omit - no YARD return type given, using untyped
   # Updates the completions table with the status of this job
   sig { returns(T.untyped) }
   def register_completion_for_gathering; end
 
+  # ActiveJob itself does not maintain a "one record per job" database entry where we could reliably track job completion.
+  # The underlying job storage (e.g., Sidekiq, Que, DelayedJob) is determined by the ActiveJob adapter, and their implementation details vary.
+  # As a result, to enable reliable scatter-gather orchestration, we create our own completion tracking records.
+  # Each job that is meant to be gathered later inserts a record into the scatter_gather_completions table when it is enqueued,
+  # and marks it as completed upon finishing. This ensures adapter-independent, uniform dependency tracking.
   class Completion < ActiveRecord::Base
-    # sord omit - no YARD type given for "active_job_ids", using untyped
-    # sord omit - no YARD return type given, using untyped
-    sig { params(active_job_ids: T.untyped).returns(T.untyped) }
+    # sord warn - DependencyStatus wasn't able to be resolved to a constant in this project
+    # Collect status information for the given active job IDs
+    # 
+    # _@param_ `active_job_ids` — Array of ActiveJob IDs to check
+    # 
+    # _@return_ — Array of DependencyStatus objects
+    sig { params(active_job_ids: T::Array[String]).returns(T::Array[DependencyStatus]) }
     def self.collect_statuses(active_job_ids); end
-  end
 
-  # Proxy class that mimics ActiveJob behavior for gather jobs
-  class GatherJobProxy
-    # sord omit - no YARD type given for "target_class", using untyped
-    # sord omit - no YARD type given for "ids", using untyped
-    # sord omit - no YARD type given for "config", using untyped
-    sig { params(target_class: T.untyped, ids: T.untyped, config: T.untyped).void }
-    def initialize(target_class, ids, config); end
-
-    # Mimic ActiveJob's perform_later method
+    # sord warn - DependencyStatus wasn't able to be resolved to a constant in this project
+    # Check if all dependencies are completed
     # 
-    # _@param_ `args` — Positional arguments to pass to the target job's perform method
+    # _@param_ `dependency_statuses` — Array of dependency statuses
     # 
-    # _@param_ `kwargs` — Keyword arguments to pass to the target job's perform method
-    # 
-    # _@return_ — Enqueues the gather job
-    sig { params(args: T::Array[T.untyped], kwargs: T::Hash[T.untyped, T.untyped]).void }
-    def perform_later(*args, **kwargs); end
-  end
-
-  # Custom exception for when gather job exhausts attempts
-  class DependencyTimeoutError < StandardError
-    # sord omit - no YARD type given for "max_attempts", using untyped
-    # sord omit - no YARD type given for "dependency_status", using untyped
-    sig { params(max_attempts: T.untyped, dependency_status: T.untyped).void }
-    def initialize(max_attempts, dependency_status); end
-
-    # sord omit - no YARD type given for :dependency_status, using untyped
-    # Returns the value of attribute dependency_status.
-    sig { returns(T.untyped) }
-    attr_reader :dependency_status
+    # _@return_ — true if all dependencies are completed
+    sig { params(dependency_statuses: T::Array[DependencyStatus]).returns(T::Boolean) }
+    def self.all_dependencies_completed?(dependency_statuses); end
   end
 
   # Internal job class for polling and coordinating gather operations
@@ -101,10 +87,10 @@ module ScatterGather
     end
     def perform(wait_for_active_job_ids:, target_job:, gather_config:, remaining_attempts:); end
 
-    # sord omit - no YARD type given for "hash", using untyped
+    # sord omit - no YARD type given for "dependency_statuses", using untyped
     # sord omit - no YARD return type given, using untyped
-    sig { params(hash: T.untyped).returns(T.untyped) }
-    def tally_in_logger_format(hash); end
+    sig { params(dependency_statuses: T.untyped).returns(T.untyped) }
+    def tally_in_logger_format(dependency_statuses); end
 
     # sord omit - no YARD type given for "target_job", using untyped
     # sord omit - no YARD return type given, using untyped
@@ -117,19 +103,67 @@ module ScatterGather
     def register_completion_for_gathering; end
   end
 
-  # The generator is used to install ScatterGather. It adds the migration that creates
-  # the scatter_gather_completions table.
-  # Run it with `bin/rails g scatter_gather:install` in your console.
-  class InstallGenerator < Rails::Generators::Base
-    include ActiveRecord::Generators::Migration
+  # Proxy class that mimics ActiveJob behavior for gather jobs
+  class GatherJobProxy
+    # sord omit - no YARD type given for "target_class", using untyped
+    # sord omit - no YARD type given for "ids", using untyped
+    # sord omit - no YARD type given for "config", using untyped
+    sig { params(target_class: T.untyped, ids: T.untyped, config: T.untyped).void }
+    def initialize(target_class, ids, config); end
+
+    # Mimic ActiveJob's perform_later method
+    # 
+    # _@param_ `args` — Positional arguments to pass to the target job's perform method
+    # 
+    # _@param_ `kwargs` — Keyword arguments to pass to the target job's perform method
+    # 
+    # _@return_ — Enqueues the gather job
+    sig { params(args: T::Array[T.untyped], kwargs: T::Hash[T.untyped, T.untyped]).void }
+    def perform_later(*args, **kwargs); end
+  end
+
+  # Custom exception for when gather job exhausts attempts
+  class DependencyTimeoutError < StandardError
+    # sord omit - no YARD type given for "max_attempts", using untyped
+    # sord omit - no YARD type given for "dependency_statuses", using untyped
+    sig { params(max_attempts: T.untyped, dependency_statuses: T.untyped).void }
+    def initialize(max_attempts, dependency_statuses); end
 
-    # sord omit - no YARD return type given, using untyped
-    # Generates migration file that creates the scatter_gather_completions table.
+    # sord warn - DependencyStatus wasn't able to be resolved to a constant in this project
+    # Format dependency statuses as a plaintext table
+    # 
+    # _@param_ `dependency_statuses` — Array of dependency statuses
+    # 
+    # _@return_ — Formatted table string
+    sig { params(dependency_statuses: T::Array[DependencyStatus]).returns(String) }
+    def format_dependency_table(dependency_statuses); end
+
+    # sord omit - no YARD type given for :dependency_statuses, using untyped
+    # Returns the value of attribute dependency_statuses.
     sig { returns(T.untyped) }
-    def create_migration_file; end
+    attr_reader :dependency_statuses
 
-    # sord omit - no YARD return type given, using untyped
+    # sord omit - no YARD type given for :max_attempts, using untyped
+    # Returns the value of attribute max_attempts.
     sig { returns(T.untyped) }
-    def migration_version; end
+    attr_reader :max_attempts
+  end
+
+  module Generators
+    # The generator is used to install ScatterGather. It adds the migration that creates
+    # the scatter_gather_completions table.
+    # Run it with `bin/rails g scatter_gather:install` in your console.
+    class InstallGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      # sord omit - no YARD return type given, using untyped
+      # Generates migration file that creates the scatter_gather_completions table.
+      sig { returns(T.untyped) }
+      def create_migration_file; end
+
+      # sord omit - no YARD return type given, using untyped
+      sig { returns(T.untyped) }
+      def migration_version; end
+    end
   end
 end

data/sig/scatter_gather.rbs

@@ -34,38 +34,27 @@ module ScatterGather
   # Updates the completions table with the status of this job
   def register_completion_for_gathering: () -> untyped
 
+  # ActiveJob itself does not maintain a "one record per job" database entry where we could reliably track job completion.
+  # The underlying job storage (e.g., Sidekiq, Que, DelayedJob) is determined by the ActiveJob adapter, and their implementation details vary.
+  # As a result, to enable reliable scatter-gather orchestration, we create our own completion tracking records.
+  # Each job that is meant to be gathered later inserts a record into the scatter_gather_completions table when it is enqueued,
+  # and marks it as completed upon finishing. This ensures adapter-independent, uniform dependency tracking.
   class Completion < ActiveRecord::Base
-    # sord omit - no YARD type given for "active_job_ids", using untyped
-    # sord omit - no YARD return type given, using untyped
-    def self.collect_statuses: (untyped active_job_ids) -> untyped
-  end
-
-  # Proxy class that mimics ActiveJob behavior for gather jobs
-  class GatherJobProxy
-    # sord omit - no YARD type given for "target_class", using untyped
-    # sord omit - no YARD type given for "ids", using untyped
-    # sord omit - no YARD type given for "config", using untyped
-    def initialize: (untyped target_class, untyped ids, untyped config) -> void
-
-    # Mimic ActiveJob's perform_later method
-    # 
-    # _@param_ `args` — Positional arguments to pass to the target job's perform method
+    # sord warn - DependencyStatus wasn't able to be resolved to a constant in this project
+    # Collect status information for the given active job IDs
     # 
-    # _@param_ `kwargs` — Keyword arguments to pass to the target job's perform method
+    # _@param_ `active_job_ids` — Array of ActiveJob IDs to check
     # 
-    # _@return_ — Enqueues the gather job
-    def perform_later: (*::Array[untyped] args, **::Hash[untyped, untyped] kwargs) -> void
-  end
+    # _@return_ — Array of DependencyStatus objects
+    def self.collect_statuses: (::Array[String] active_job_ids) -> ::Array[DependencyStatus]
 
-  # Custom exception for when gather job exhausts attempts
-  class DependencyTimeoutError < StandardError
-    # sord omit - no YARD type given for "max_attempts", using untyped
-    # sord omit - no YARD type given for "dependency_status", using untyped
-    def initialize: (untyped max_attempts, untyped dependency_status) -> void
-
-    # sord omit - no YARD type given for :dependency_status, using untyped
-    # Returns the value of attribute dependency_status.
-    attr_reader dependency_status: untyped
+    # sord warn - DependencyStatus wasn't able to be resolved to a constant in this project
+    # Check if all dependencies are completed
+    # 
+    # _@param_ `dependency_statuses` — Array of dependency statuses
+    # 
+    # _@return_ — true if all dependencies are completed
+    def self.all_dependencies_completed?: (::Array[DependencyStatus] dependency_statuses) -> bool
   end
 
   # Internal job class for polling and coordinating gather operations
@@ -87,9 +76,9 @@ module ScatterGather
                    remaining_attempts: untyped
                  ) -> untyped
 
-    # sord omit - no YARD type given for "hash", using untyped
+    # sord omit - no YARD type given for "dependency_statuses", using untyped
     # sord omit - no YARD return type given, using untyped
-    def tally_in_logger_format: (untyped hash) -> untyped
+    def tally_in_logger_format: (untyped dependency_statuses) -> untyped
 
     # sord omit - no YARD type given for "target_job", using untyped
     # sord omit - no YARD return type given, using untyped
@@ -100,17 +89,59 @@ module ScatterGather
     def register_completion_for_gathering: () -> untyped
   end
 
-  # The generator is used to install ScatterGather. It adds the migration that creates
-  # the scatter_gather_completions table.
-  # Run it with `bin/rails g scatter_gather:install` in your console.
-  class InstallGenerator < Rails::Generators::Base
-    include ActiveRecord::Generators::Migration
+  # Proxy class that mimics ActiveJob behavior for gather jobs
+  class GatherJobProxy
+    # sord omit - no YARD type given for "target_class", using untyped
+    # sord omit - no YARD type given for "ids", using untyped
+    # sord omit - no YARD type given for "config", using untyped
+    def initialize: (untyped target_class, untyped ids, untyped config) -> void
+
+    # Mimic ActiveJob's perform_later method
+    # 
+    # _@param_ `args` — Positional arguments to pass to the target job's perform method
+    # 
+    # _@param_ `kwargs` — Keyword arguments to pass to the target job's perform method
+    # 
+    # _@return_ — Enqueues the gather job
+    def perform_later: (*::Array[untyped] args, **::Hash[untyped, untyped] kwargs) -> void
+  end
+
+  # Custom exception for when gather job exhausts attempts
+  class DependencyTimeoutError < StandardError
+    # sord omit - no YARD type given for "max_attempts", using untyped
+    # sord omit - no YARD type given for "dependency_statuses", using untyped
+    def initialize: (untyped max_attempts, untyped dependency_statuses) -> void
 
-    # sord omit - no YARD return type given, using untyped
-    # Generates migration file that creates the scatter_gather_completions table.
-    def create_migration_file: () -> untyped
+    # sord warn - DependencyStatus wasn't able to be resolved to a constant in this project
+    # Format dependency statuses as a plaintext table
+    # 
+    # _@param_ `dependency_statuses` — Array of dependency statuses
+    # 
+    # _@return_ — Formatted table string
+    def format_dependency_table: (::Array[DependencyStatus] dependency_statuses) -> String
 
-    # sord omit - no YARD return type given, using untyped
-    def migration_version: () -> untyped
+    # sord omit - no YARD type given for :dependency_statuses, using untyped
+    # Returns the value of attribute dependency_statuses.
+    attr_reader dependency_statuses: untyped
+
+    # sord omit - no YARD type given for :max_attempts, using untyped
+    # Returns the value of attribute max_attempts.
+    attr_reader max_attempts: untyped
+  end
+
+  module Generators
+    # The generator is used to install ScatterGather. It adds the migration that creates
+    # the scatter_gather_completions table.
+    # Run it with `bin/rails g scatter_gather:install` in your console.
+    class InstallGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      # sord omit - no YARD return type given, using untyped
+      # Generates migration file that creates the scatter_gather_completions table.
+      def create_migration_file: () -> untyped
+
+      # sord omit - no YARD return type given, using untyped
+      def migration_version: () -> untyped
+    end
   end
 end

data/test/dummy/db/schema.rb

@@ -4,13 +4,13 @@
 #
 # This file is the source Rails uses to define your schema when running `bin/rails
 # db:schema:load`. When creating a new database, `bin/rails db:schema:load` tends to
-# be faster and is less error-prone than running all of your migrations from scratch.
-# Old migrations may fail to apply correctly if those migrations used external
-# dependencies or application code.
+# be faster and is potentially less error prone than running all of your
+# migrations from scratch. Old migrations may fail to apply correctly if those
+# migrations use external dependencies or application code.
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema[7.2].define(version: 2025_01_01_000001) do
+ActiveRecord::Schema[7.2].define(version: 2025_10_01_094223) do
   create_table "scatter_gather_completions", force: :cascade do |t|
     t.string "active_job_id", null: false
     t.string "active_job_class_name"

data/test/scatter_gather_test.rb

@@ -177,4 +177,97 @@ class ScatterGatherTest < ActiveSupport::TestCase
       perform_enqueued_jobs
     end
   end
+
+  test "Completion.collect_statuses handles missing job IDs correctly" do
+    # Create some job IDs - some that exist in the database, some that don't
+    existing_job_id_1 = "existing-job-1"
+    existing_job_id_2 = "existing-job-2"
+    missing_job_id_1 = "missing-job-1"
+    missing_job_id_2 = "missing-job-2"
+
+    # Create completion records for some jobs
+    ScatterGather::Completion.create!(
+      active_job_id: existing_job_id_1,
+      active_job_class_name: "TestJob",
+      status: "completed"
+    )
+
+    ScatterGather::Completion.create!(
+      active_job_id: existing_job_id_2,
+      active_job_class_name: "TestJob",
+      status: "pending"
+    )
+
+    # Test with a mix of existing and missing job IDs
+    job_ids = [existing_job_id_1, existing_job_id_2, missing_job_id_1, missing_job_id_2]
+
+    # Call the method and capture the result
+    result = ScatterGather::Completion.collect_statuses(job_ids)
+
+    # Verify the results
+    existing_completed = result.find { |ds| ds.active_job_id == existing_job_id_1 }
+    existing_pending = result.find { |ds| ds.active_job_id == existing_job_id_2 }
+    missing_1 = result.find { |ds| ds.active_job_id == missing_job_id_1 }
+    missing_2 = result.find { |ds| ds.active_job_id == missing_job_id_2 }
+
+    assert_not_nil existing_completed, "Should find existing completed job"
+    assert_equal :completed, existing_completed.status, "Existing completed job should have :completed status"
+    assert_equal "TestJob", existing_completed.active_job_class, "Should have correct class name"
+    assert_equal "✓", existing_completed.checkmark, "Completed job should have checkmark"
+
+    assert_not_nil existing_pending, "Should find existing pending job"
+    assert_equal :pending, existing_pending.status, "Existing pending job should have :pending status"
+    assert_equal "TestJob", existing_pending.active_job_class, "Should have correct class name"
+    assert_equal " ", existing_pending.checkmark, "Pending job should have space"
+
+    assert_not_nil missing_1, "Should find missing job 1"
+    assert_equal :unknown, missing_1.status, "Missing job should have :unknown status"
+    assert_nil missing_1.active_job_class, "Missing job should have nil class name"
+    assert_equal "(unknown)", missing_1.display_class, "Should display (unknown) for missing class"
+    assert_equal " ", missing_1.checkmark, "Unknown job should have space"
+
+    assert_not_nil missing_2, "Should find missing job 2"
+    assert_equal :unknown, missing_2.status, "Missing job should have :unknown status"
+    assert_nil missing_2.active_job_class, "Missing job should have nil class name"
+    assert_equal "(unknown)", missing_2.display_class, "Should display (unknown) for missing class"
+    assert_equal " ", missing_2.checkmark, "Unknown job should have space"
+
+    # Verify all job IDs are present in the result
+    assert_equal job_ids.length, result.length, "Result should contain all job IDs"
+    result_job_ids = result.map(&:active_job_id)
+    job_ids.each do |job_id|
+      assert_includes result_job_ids, job_id, "Result should contain job ID: #{job_id}"
+    end
+  end
+
+  test "DependencyTimeoutError formats dependency table correctly" do
+    # Create some dependency statuses with mixed states
+    dependency_statuses = [
+      ScatterGather::DependencyStatus.new("job-1", "TestJob", :completed),
+      ScatterGather::DependencyStatus.new("job-2", "AnotherJob", :pending),
+      ScatterGather::DependencyStatus.new("job-3", nil, :unknown),
+      ScatterGather::DependencyStatus.new("job-4", "LongClassNameJob", :pending)
+    ]
+
+    # Create the exception
+    error = ScatterGather::DependencyTimeoutError.new(5, dependency_statuses)
+
+    # Verify the exception has the correct attributes
+    assert_equal 5, error.max_attempts
+    assert_equal dependency_statuses, error.dependency_statuses
+
+    # Test the exact table format
+    expected_message = <<~MSG
+      Gather failed after 5 attempts. Dependencies:
+
+      | ✓ | Job ID | Class            | Status    |
+      |---|--------|------------------|-----------|
+      | ✓ | job-1  | TestJob          | completed |
+      |   | job-2  | AnotherJob       | pending   |
+      |   | job-3  | (unknown)        | unknown   |
+      |   | job-4  | LongClassNameJob | pending   |
+    MSG
+
+    assert_equal expected_message, error.message
+  end
 end

data/test/smoke_test.rb

@@ -0,0 +1,114 @@
+require "test_helper"
+require "fileutils"
+
+class SmokeTest < ActiveSupport::TestCase
+  test "smoke test: clean gem installation succeeds" do
+    # Load the generator before changing directories
+    require "scatter_gather"
+    project_root = File.expand_path("../..", __FILE__)
+    require File.join(project_root, "lib", "generators", "scatter_gather", "install_generator")
+
+    # Create a temporary directory for the test
+    temp_dir = Dir.mktmpdir("scatter_gather_smoke_test")
+    dummy_app_source = Rails.root
+    dummy_app_target = File.join(temp_dir, "dummy_app")
+    original_cwd = Dir.pwd
+
+    begin
+      # Step 1: Copy dummy app to temporary directory
+      puts "Step 1: Copying dummy app to temporary directory..."
+      FileUtils.cp_r(dummy_app_source, dummy_app_target)
+
+      # Change to the temporary dummy app directory
+      Dir.chdir(dummy_app_target)
+
+      # Step 2: Clean up any existing migrations and database
+      puts "Step 2: Cleaning up existing migrations and database..."
+
+      # Remove any existing scatter_gather migration files
+      existing_migrations = Dir.glob(File.join(dummy_app_target, "db", "migrate", "*scatter_gather*"))
+      existing_migrations.each { |file| File.delete(file) }
+
+      result = system("bundle exec rails db:drop RAILS_ENV=test", out: File::NULL, err: File::NULL)
+      assert result, "Database drop should succeed"
+
+      # Step 3: Create fresh database
+      puts "Step 3: Creating fresh database..."
+      result = system("bundle exec rails db:create RAILS_ENV=test", out: File::NULL, err: File::NULL)
+      assert result, "Database create should succeed"
+
+      # Step 4: Manually run the generator to create migration
+      puts "Step 4: Running scatter_gather:install generator..."
+
+      # Create a temporary generator instance and run it
+      generator = ScatterGather::Generators::InstallGenerator.new
+      generator.create_migration_file
+
+      # Step 5: Verify migration file was created
+      puts "Step 5: Verifying migration file was created..."
+      migration_files = Dir.glob(File.join(dummy_app_target, "db", "migrate", "*scatter_gather_migration_001.rb"))
+      assert_equal 1, migration_files.length, "Should create exactly one migration file"
+
+      migration_file = migration_files.first
+      assert File.exist?(migration_file), "Migration file should exist"
+
+      # Step 6: Verify migration content includes ID detection logic
+      puts "Step 6: Verifying migration content..."
+      migration_content = File.read(migration_file)
+      assert_includes migration_content, "detect_dominant_id_type", "Migration should include ID detection method"
+      assert_includes migration_content, "table_options =", "Migration should use conditional ID type"
+      assert_includes migration_content, "id_type == :uuid", "Migration should check for UUID type"
+      assert_includes migration_content, "create_table :scatter_gather_completions", "Migration should create the correct table"
+
+      # Step 7: Run migrations
+      puts "Step 7: Running migrations..."
+      result = system("bundle exec rails db:migrate RAILS_ENV=test", out: File::NULL, err: File::NULL)
+      assert result, "Migrations should succeed"
+
+      # Step 8: Verify table was created with correct structure
+      puts "Step 8: Verifying table structure..."
+      table_exists = ActiveRecord::Base.connection.table_exists?(:scatter_gather_completions)
+      assert table_exists, "scatter_gather_completions table should exist"
+
+      # Verify ID column type (should be integer for clean database)
+      id_column = ActiveRecord::Base.connection.columns(:scatter_gather_completions).find { |col| col.name == "id" }
+      assert_not_nil id_column, "ID column should exist"
+      assert_equal :integer, id_column.type, "ID column should be integer type for clean database"
+
+      # Verify other columns exist
+      column_names = ActiveRecord::Base.connection.columns(:scatter_gather_completions).map(&:name)
+      assert_includes column_names, "active_job_id", "active_job_id column should exist"
+      assert_includes column_names, "active_job_class_name", "active_job_class_name column should exist"
+      assert_includes column_names, "status", "status column should exist"
+      assert_includes column_names, "created_at", "created_at column should exist"
+      assert_includes column_names, "updated_at", "updated_at column should exist"
+
+      # Step 9: Verify indexes were created
+      puts "Step 9: Verifying indexes..."
+      indexes = ActiveRecord::Base.connection.indexes(:scatter_gather_completions)
+      active_job_id_index = indexes.find { |idx| idx.columns == ["active_job_id"] }
+      assert_not_nil active_job_id_index, "active_job_id index should exist"
+      assert active_job_id_index.unique, "active_job_id index should be unique"
+
+      created_at_index = indexes.find { |idx| idx.columns == ["created_at"] }
+      assert_not_nil created_at_index, "created_at index should exist"
+
+      # Step 10: Verify Completion model works via Rails runner
+      puts "Step 10: Verifying Completion model via Rails runner..."
+      result = system("bundle exec rails runner 'puts ScatterGather::Completion.count'", out: File::NULL, err: File::NULL)
+      assert result, "Rails runner should succeed"
+
+      # Capture the output to verify count is 0
+      output = `bundle exec rails runner 'puts ScatterGather::Completion.count' 2>/dev/null`.strip
+      assert_equal "0", output, "Completion count should be 0 for fresh installation"
+
+      puts "Smoke test completed successfully!"
+    ensure
+      # Restore original working directory
+      Dir.chdir(original_cwd)
+
+      # Clean up temporary directory
+      FileUtils.rm_rf(temp_dir) if Dir.exist?(temp_dir)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scatter_gather
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Julik Tarkhanov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-09-30 00:00:00.000000000 Z
+date: 2025-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -202,12 +202,16 @@ files:
 - bin/console
 - bin/setup
 - bin/test
-- lib/generators/install_generator.rb
-- lib/generators/scatter_gather_migration_001.rb.erb
+- lib/generators/scatter_gather/install_generator.rb
+- lib/generators/scatter_gather/scatter_gather_migration_001.rb.erb
 - lib/scatter_gather.rb
+- lib/scatter_gather/completion.rb
+- lib/scatter_gather/dependency_status.rb
+- lib/scatter_gather/dependency_timeout_error.rb
+- lib/scatter_gather/gather_job.rb
+- lib/scatter_gather/gather_job_proxy.rb
 - lib/scatter_gather/version.rb
 - rbi/scatter_gather.rbi
-- scatter_gather-0.1.19.gem
 - scatter_gather.gemspec
 - sig/scatter_gather.rbs
 - test/dummy/Rakefile
@@ -243,7 +247,6 @@ files:
 - test/dummy/config/puma.rb
 - test/dummy/config/routes.rb
 - test/dummy/config/storage.yml
-- test/dummy/db/migrate/20250101000001_add_scatter_gather_completions.rb
 - test/dummy/db/schema.rb
 - test/dummy/public/400.html
 - test/dummy/public/404.html
@@ -253,6 +256,7 @@ files:
 - test/dummy/public/icon.png
 - test/dummy/public/icon.svg
 - test/scatter_gather_test.rb
+- test/smoke_test.rb
 - test/test_helper.rb
 homepage: https://github.com/julik/scatter_gather
 licenses:

data/lib/generators/install_generator.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators"
-require "rails/generators/active_record"
-
-module ScatterGather
-  # The generator is used to install ScatterGather. It adds the migration that creates
-  # the scatter_gather_completions table.
-  # Run it with `bin/rails g scatter_gather:install` in your console.
-  class InstallGenerator < Rails::Generators::Base
-    include ActiveRecord::Generators::Migration
-
-    source_paths << File.join(File.dirname(__FILE__, 2))
-
-    # Generates migration file that creates the scatter_gather_completions table.
-    def create_migration_file
-      # Migration files are named "...migration_001.rb" etc. This allows them to be emitted
-      # as they get added, and the order of the migrations can be controlled using predictable sorting.
-      # Adding a new migration to the gem is then just adding a file.
-      migration_file_paths_in_order = Dir.glob(__dir__ + "/*_migration_*.rb.erb").sort
-      migration_file_paths_in_order.each do |migration_template_path|
-        untemplated_migration_filename = File.basename(migration_template_path).gsub(/\.erb$/, "")
-        migration_template(migration_template_path, File.join(db_migrate_path, untemplated_migration_filename))
-      end
-    end
-
-    private
-
-    def migration_version
-      ActiveRecord::VERSION::STRING.split(".").take(2).join(".")
-    end
-  end
-end

data/lib/generators/scatter_gather_migration_001.rb.erb

@@ -1,16 +0,0 @@
-class AddScatterGatherCompletions < ActiveRecord::Migration[<%= migration_version %>]
-  def up
-    create_table :scatter_gather_completions do |t|
-      t.string :active_job_id, null: false
-      t.string :active_job_class_name
-      t.string :status, default: "unknown"
-      t.timestamps
-    end
-    add_index :scatter_gather_completions, [:active_job_id], unique: true # For lookups
-    add_index :scatter_gather_completions, [:created_at] # For cleanup
-  end
-
-  def down
-    drop_table :scatter_gather_completions
-  end
-end

data/test/dummy/db/migrate/20250101000001_add_scatter_gather_completions.rb

@@ -1,16 +0,0 @@
-class AddScatterGatherCompletions < ActiveRecord::Migration[7.2]
-  def up
-    create_table :scatter_gather_completions do |t|
-      t.string :active_job_id, null: false
-      t.string :active_job_class_name
-      t.string :status, default: "unknown"
-      t.timestamps
-    end
-    add_index :scatter_gather_completions, [:active_job_id], unique: true # For lookups
-    add_index :scatter_gather_completions, [:created_at] # For cleanup
-  end
-
-  def down
-    drop_table :scatter_gather_completions
-  end
-end