good_job 3.99.0 → 4.0.0

data/config/locales/nl.yml

@@ -11,7 +11,6 @@ nl:
     batches:
       index:
         older_batches: Oudere partijen
-        pending_migrations: GoodJob heeft databasemigraties in behandeling.
         title: Partijen
       jobs:
         actions:
@@ -48,7 +47,6 @@ nl:
       index:
         no_cron_schedules_found: Geen cron-schema's gevonden.
         title: Cron-schema's
-      pending_migrations: Vereist GoodJob-databasemigratie in afwachting.
       show:
         cron_entry_key: Cron-invoersleutel
     datetime:
@@ -240,6 +238,7 @@ nl:
           dark: Donker
           light: Licht
           theme: Thema
+      pending_migrations: GoodJob heeft databasemigraties in behandeling.
       secondary_navbar:
         inspiration: 'Onthoud: jij levert ook goed werk!'
         last_updated: Laatst bijgewerkt
@@ -250,5 +249,3 @@ nl:
       running: Rennen
       scheduled: Gepland
       succeeded: Geslaagd
-  shared:
-    needs_migration: Voer GoodJob-migraties uit.

data/config/locales/pt-BR.yml

@@ -11,7 +11,6 @@ pt-BR:
     batches:
       index:
         older_batches: Lotes antigos
-        pending_migrations: O GoodJob tem migrações pendentes no banco de dados.
         title: Lotes
       jobs:
         actions:
@@ -48,7 +47,6 @@ pt-BR:
       index:
         no_cron_schedules_found: Nenhuma tarefa programada encontrada.
         title: Tarefas Programadas
-      pending_migrations: Requer migração pendente do GoodJob no banco de dados.
       show:
         cron_entry_key: Chave da Tarefa Programada
     datetime:
@@ -240,6 +238,7 @@ pt-BR:
           dark: Escuro
           light: Claro
           theme: Tema
+      pending_migrations: O GoodJob tem migrações pendentes no banco de dados.
       secondary_navbar:
         inspiration: Lembre-se, você também está fazendo uma Boa Tarefa!
         last_updated: Última atualização
@@ -250,5 +249,3 @@ pt-BR:
       running: Em execução
       scheduled: Agendado
       succeeded: Concluído com sucesso
-  shared:
-    needs_migration: Execute migrações GoodJob.

data/config/locales/ru.yml

@@ -11,7 +11,6 @@ ru:
     batches:
       index:
         older_batches: Старые группы заданий
-        pending_migrations: У GoodJob есть ожидающие миграции базы данных.
         title: Группы заданий
       jobs:
         actions:
@@ -48,7 +47,6 @@ ru:
       index:
         no_cron_schedules_found: Расписания cron не найдены.
         title: Расписания cron
-      pending_migrations: У GoodJob есть ожидающие миграции базы данных.
       show:
         cron_entry_key: Ключ cron-задания
     datetime:
@@ -266,6 +264,7 @@ ru:
           dark: Темный
           light: Светлая
           theme: Тема офрмдления
+      pending_migrations: У GoodJob есть ожидающие миграции базы данных.
       secondary_navbar:
         inspiration: Благодаря вам Good Job становится лучше! Спасибо!
         last_updated: Последнее обновление
@@ -276,5 +275,3 @@ ru:
       running: Исполняется
       scheduled: Запланировано
       succeeded: Успешно
-  shared:
-    needs_migration: Пожалуйста, запустите миграцию GoodJob.

data/config/locales/tr.yml

@@ -11,7 +11,6 @@ tr:
     batches:
       index:
         older_batches: Daha eski toplu işlemler
-        pending_migrations: GoodJob'ın bekleyen veritabanı güncellemeleri bulunuyor.
         title: Toplu İşlemler
       jobs:
         actions:
@@ -48,7 +47,6 @@ tr:
       index:
         no_cron_schedules_found: Planlanmış Cron bulunamadı.
         title: Cron Planları
-      pending_migrations: Bekleyen GoodJob veritabanı güncellemesi var.
       show:
         cron_entry_key: Cron Giriş Anahtarı
     datetime:
@@ -240,6 +238,7 @@ tr:
           dark: Karanlık
           light: Işık
           theme: Tema
+      pending_migrations: GoodJob'ın bekleyen veritabanı güncellemeleri bulunuyor.
       secondary_navbar:
         inspiration: Unutmayın, siz de iyi bir iş yapıyorsunuz!
         last_updated: Son güncelleme
@@ -250,5 +249,3 @@ tr:
       running: Çalışıyor
       scheduled: Planlandı
       succeeded: Başarılı
-  shared:
-    needs_migration: Lütfen GoodJob geçişlerini çalıştırın.

data/config/locales/uk.yml

@@ -11,7 +11,6 @@ uk:
     batches:
       index:
         older_batches: Старі пакети
-        pending_migrations: GoodJob має невиконані міграції бази даних.
         title: Пакети
       jobs:
         actions:
@@ -48,7 +47,6 @@ uk:
       index:
         no_cron_schedules_found: Cron-розклади не знайдені.
         title: Cron-розклади
-      pending_migrations: Вимагає невиконаних міграцій бази даних GoodJob.
       show:
         cron_entry_key: Ключ cron-запису
     datetime:
@@ -266,6 +264,7 @@ uk:
           dark: Темний
           light: світло
           theme: Тема
+      pending_migrations: GoodJob має невиконані міграції бази даних.
       secondary_navbar:
         inspiration: Пам'ятайте, ви теж робите хорошу роботу!
         last_updated: Останнє оновлення
@@ -276,5 +275,3 @@ uk:
       running: Виконується
       scheduled: Заплановано
       succeeded: Успішно виконано
-  shared:
-    needs_migration: Запустіть міграції GoodJob.

data/lib/generators/good_job/templates/update/migrations/01_create_good_jobs.rb.erb

@@ -21,20 +21,82 @@ 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
+
+      t.boolean :is_discrete
+      t.integer :executions_count
+      t.text :job_class
+      t.integer :error_event, limit: 2
+      t.text :labels, array: true
+      t.uuid :locked_by_id
+      t.datetime :locked_at
+    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_executions, id: :uuid do |t|
+      t.timestamps
+
+      t.uuid :active_job_id, null: false
+      t.text :job_class
+      t.text :queue_name
+      t.jsonb :serialized_params
+      t.datetime :scheduled_at
+      t.datetime :finished_at
+      t.text :error
+      t.integer :error_event, limit: 2
+      t.text :error_backtrace, array: true
+      t.uuid :process_id
+      t.interval :duration
     end
 
     create_table :good_job_processes, id: :uuid do |t|
       t.timestamps
       t.jsonb :state
+      t.integer :lock_type, limit: 2
+    end
+
+    create_table :good_job_settings, id: :uuid do |t|
+      t.timestamps
+      t.text :key
+      t.jsonb :value
+      t.index :key, unique: true
     end
 
     add_index :good_jobs, :scheduled_at, where: "(finished_at IS NULL)", name: :index_good_jobs_on_scheduled_at
     add_index :good_jobs, [:queue_name, :scheduled_at], where: "(finished_at IS NULL)", name: :index_good_jobs_on_queue_name_and_scheduled_at
     add_index :good_jobs, [:active_job_id, :created_at], name: :index_good_jobs_on_active_job_id_and_created_at
     add_index :good_jobs, :concurrency_key, where: "(finished_at IS NULL)", name: :index_good_jobs_on_concurrency_key_when_unfinished
-    add_index :good_jobs, [:cron_key, :created_at], name: :index_good_jobs_on_cron_key_and_created_at
-    add_index :good_jobs, [:cron_key, :cron_at], name: :index_good_jobs_on_cron_key_and_cron_at, unique: true
-    add_index :good_jobs, [:active_job_id], name: :index_good_jobs_on_active_job_id
+    add_index :good_jobs, [:cron_key, :created_at], where: "(cron_key IS NOT NULL)", name: :index_good_jobs_on_cron_key_and_created_at_cond
+    add_index :good_jobs, [:cron_key, :cron_at], where: "(cron_key IS NOT NULL)", unique: true, name: :index_good_jobs_on_cron_key_and_cron_at_cond
     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, [:priority, :created_at], order: { priority: "ASC NULLS LAST", created_at: :asc },
+      where: "finished_at IS NULL", name: :index_good_job_jobs_for_candidate_lookup
+    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"
+    add_index :good_jobs, :labels, using: :gin, where: "(labels IS NOT NULL)", name: :index_good_jobs_on_labels
+
+    add_index :good_job_executions, [:active_job_id, :created_at], name: :index_good_job_executions_on_active_job_id_and_created_at
+    add_index :good_jobs, [:priority, :scheduled_at], order: { priority: "ASC NULLS LAST", scheduled_at: :asc },
+      where: "finished_at IS NULL AND locked_by_id IS NULL", name: :index_good_jobs_on_priority_scheduled_at_unfinished_unlocked
+    add_index :good_jobs, :locked_by_id,
+      where: "locked_by_id IS NOT NULL", name: "index_good_jobs_on_locked_by_id"
+    add_index :good_job_executions, [:process_id, :created_at], name: :index_good_job_executions_on_process_id_and_created_at
   end
 end

data/lib/good_job/active_job_extensions/batches.rb

@@ -12,7 +12,7 @@ module GoodJob
       end
 
       def batch
-        @_batch ||= CurrentThread.execution&.batch&.to_batch if CurrentThread.execution.present? && CurrentThread.execution.active_job_id == job_id
+        @_batch ||= CurrentThread.job&.batch&.to_batch if CurrentThread.job.present? && CurrentThread.job.active_job_id == job_id
       end
       alias batch? batch
     end

data/lib/good_job/active_job_extensions/concurrency.rb

@@ -66,7 +66,7 @@ module GoodJob
 
           perform_throttle = job.class.good_job_concurrency_config[:perform_throttle]
           perform_throttle = instance_exec(&perform_throttle) if perform_throttle.respond_to?(:call)
-          perform_throttle = nil unless GoodJob::DiscreteExecution.migrated? && perform_throttle.present? && perform_throttle.is_a?(Array) && perform_throttle.size == 2
+          perform_throttle = nil unless perform_throttle.present? && perform_throttle.is_a?(Array) && perform_throttle.size == 2
 
           limit = perform_limit || total_limit
           throttle = perform_throttle
@@ -75,17 +75,17 @@ module GoodJob
           key = job.good_job_concurrency_key
           next if key.blank?
 
-          if CurrentThread.execution.blank? || CurrentThread.execution.active_job_id != job_id
+          if CurrentThread.job.blank? || CurrentThread.job.active_job_id != job_id
             logger.debug("Ignoring concurrency limits because the job is executed with `perform_now`.")
             next
           end
 
-          GoodJob::Execution.advisory_lock_key(key, function: "pg_advisory_lock") do
+          GoodJob::Job.advisory_lock_key(key, function: "pg_advisory_lock") do
             if limit
-              allowed_active_job_ids = GoodJob::Execution.unfinished.where(concurrency_key: key)
-                                                         .advisory_locked
-                                                         .order(Arel.sql("COALESCE(performed_at, scheduled_at, created_at) ASC"))
-                                                         .limit(limit).pluck(:active_job_id)
+              allowed_active_job_ids = GoodJob::Job.unfinished.where(concurrency_key: key)
+                                                   .advisory_locked
+                                                   .order(Arel.sql("COALESCE(performed_at, scheduled_at, created_at) ASC"))
+                                                   .limit(limit).pluck(:active_job_id)
               # The current job has already been locked and will appear in the previous query
               raise GoodJob::ActiveJobExtensions::Concurrency::ConcurrencyExceededError unless allowed_active_job_ids.include?(job.job_id)
             end
@@ -172,12 +172,12 @@ module GoodJob
         throttle = enqueue_throttle
         return on_enqueue&.call unless limit || throttle
 
-        GoodJob::Execution.advisory_lock_key(key, function: "pg_advisory_lock") do
+        GoodJob::Job.advisory_lock_key(key, function: "pg_advisory_lock") do
           if limit
             enqueue_concurrency = if enqueue_limit
-                                    GoodJob::Execution.where(concurrency_key: key).unfinished.advisory_unlocked.count
+                                    GoodJob::Job.where(concurrency_key: key).unfinished.advisory_unlocked.count
                                   else
-                                    GoodJob::Execution.where(concurrency_key: key).unfinished.count
+                                    GoodJob::Job.where(concurrency_key: key).unfinished.count
                                   end
 
             # The job has not yet been enqueued, so check if adding it will go over the limit

data/lib/good_job/adapter.rb

@@ -37,7 +37,7 @@ module GoodJob
     # Enqueues the ActiveJob job to be performed.
     # For use by Rails; you should generally not call this directly.
     # @param active_job [ActiveJob::Base] the job to be enqueued from +#perform_later+
-    # @return [GoodJob::Execution]
+    # @return [GoodJob::Job]
     def enqueue(active_job)
       enqueue_at(active_job, nil)
     end
@@ -58,28 +58,17 @@ module GoodJob
       Rails.application.executor.wrap do
         current_time = Time.current
         executions = active_jobs.map do |active_job|
-          GoodJob::Execution.build_for_enqueue(active_job).tap do |execution|
-            if GoodJob::Execution.discrete_support?
-              execution.make_discrete
-              execution.scheduled_at = current_time if execution.scheduled_at == execution.created_at
-            end
-
-            execution.created_at = current_time
-            execution.updated_at = current_time
+          GoodJob::Job.build_for_enqueue(active_job).tap do |job|
+            job.scheduled_at = current_time if job.scheduled_at == job.created_at
+            job.created_at = current_time
+            job.updated_at = current_time
           end
         end
 
         inline_executions = []
-        GoodJob::Execution.transaction(requires_new: true, joinable: false) do
-          execution_attributes = executions.map do |execution|
-            if GoodJob::Execution.error_event_migrated?
-              execution.attributes
-            else
-              execution.attributes.except('error_event')
-            end
-          end
-
-          results = GoodJob::Execution.insert_all(execution_attributes, returning: %w[id active_job_id]) # rubocop:disable Rails/SkipsModelValidations
+        GoodJob::Job.transaction(requires_new: true, joinable: false) do
+          execution_attributes = executions.map(&:attributes)
+          results = GoodJob::Job.insert_all(execution_attributes, returning: %w[id active_job_id]) # rubocop:disable Rails/SkipsModelValidations
 
           job_id_to_provider_job_id = results.each_with_object({}) { |result, hash| hash[result['active_job_id']] = result['id'] }
           active_jobs.each do |active_job|
@@ -146,7 +135,7 @@ module GoodJob
     # For use by Rails; you should generally not call this directly.
     # @param active_job [ActiveJob::Base] the job to be enqueued from +#perform_later+
     # @param timestamp [Integer, nil] the epoch time to perform the job
-    # @return [GoodJob::Execution]
+    # @return [GoodJob::Job]
     def enqueue_at(active_job, timestamp)
       scheduled_at = timestamp ? Time.zone.at(timestamp) : nil
 
@@ -156,15 +145,15 @@ module GoodJob
 
       Rails.application.executor.wrap do
         will_execute_inline = execute_inline? && (scheduled_at.nil? || scheduled_at <= Time.current)
-        will_retry_inline = will_execute_inline && CurrentThread.execution&.active_job_id == active_job.job_id && !CurrentThread.retry_now
+        will_retry_inline = will_execute_inline && CurrentThread.job&.active_job_id == active_job.job_id && !CurrentThread.retry_now
 
         if will_retry_inline
-          execution = GoodJob::Execution.enqueue(
+          execution = GoodJob::Job.enqueue(
             active_job,
             scheduled_at: scheduled_at
           )
         elsif will_execute_inline
-          execution = GoodJob::Execution.enqueue(
+          execution = GoodJob::Job.enqueue(
             active_job,
             scheduled_at: scheduled_at,
             create_with_advisory_lock: true
@@ -186,7 +175,7 @@ module GoodJob
           end
           raise result.unhandled_error if result.unhandled_error
         else
-          execution = GoodJob::Execution.enqueue(
+          execution = GoodJob::Job.enqueue(
             active_job,
             scheduled_at: scheduled_at
           )

data/lib/good_job/current_thread.rb

@@ -13,7 +13,7 @@ module GoodJob
       error_on_discard
       error_on_retry
       error_on_retry_stopped
-      execution
+      job
       execution_interrupted
       execution_retried
       retry_now
@@ -49,11 +49,11 @@ module GoodJob
     #   @return [Exception, nil]
     thread_mattr_accessor :error_on_retry_stopped
 
-    # @!attribute [rw] executions
+    # @!attribute [rw] jobs
     #   @!scope class
     #   Execution
-    #   @return [GoodJob::Execution, nil]
-    thread_mattr_accessor :execution
+    #   @return [GoodJob::Job, nil]
+    thread_mattr_accessor :job
 
     # @!attribute [rw] execution_interrupted
     #   @!scope class
@@ -90,9 +90,9 @@ module GoodJob
       end
     end
 
-    # @return [String] UUID of the currently executing GoodJob::Execution
+    # @return [String] UUID of the currently executing GoodJob::Job
     def self.active_job_id
-      execution&.active_job_id
+      job&.active_job_id
     end
 
     # @return [Integer] Current process ID

data/lib/good_job/job_performer.rb

@@ -108,11 +108,11 @@ module GoodJob
     attr_reader :queue_string
 
     def job_query
-      @_job_query ||= GoodJob::Execution.queue_string(queue_string)
+      @_job_query ||= GoodJob::Job.queue_string(queue_string)
     end
 
     def parsed_queues
-      @_parsed_queues ||= GoodJob::Execution.queue_parser(queue_string)
+      @_parsed_queues ||= GoodJob::Job.queue_parser(queue_string)
     end
   end
 end

data/lib/good_job/log_subscriber.rb

@@ -18,14 +18,6 @@ module GoodJob
     #   Responds to the +$0.good_job+ notification.
     #   @param event [ActiveSupport::Notifications::Event]
     #   @return [void]
-    def create(event)
-      # FIXME: This method does not match any good_job notifications.
-      execution = event.payload[:execution]
-
-      debug do
-        "GoodJob created job resource with id #{execution.id}"
-      end
-    end
 
     # @!macro notification_responder
     def finished_timer_task(event)
@@ -110,12 +102,12 @@ module GoodJob
 
     # @!macro notification_responder
     def perform_job(event)
-      execution = event.payload[:execution]
+      job = event.payload[:job]
       process_id = event.payload[:process_id]
       thread_name = event.payload[:thread_name]
 
       info(tags: [process_id, thread_name]) do
-        "Executed GoodJob #{execution.id}"
+        "Executed GoodJob #{job.id}"
       end
     end
 

data/lib/good_job/notifier.rb

@@ -51,7 +51,7 @@ module GoodJob # :nodoc:
     # Send a message via Postgres NOTIFY
     # @param message [#to_json]
     def self.notify(message)
-      connection = ::GoodJob::Execution.connection
+      connection = ::GoodJob::Job.connection
       connection.exec_query <<~SQL.squish
         NOTIFY #{CHANNEL}, #{connection.quote(message.to_json)}
       SQL
@@ -251,8 +251,8 @@ module GoodJob # :nodoc:
 
     def with_connection
       Rails.application.executor.wrap do
-        self.connection = ::GoodJob::Execution.connection_pool.checkout.tap do |conn|
-          ::GoodJob::Execution.connection_pool.remove(conn)
+        self.connection = ::GoodJob::Job.connection_pool.checkout.tap do |conn|
+          ::GoodJob::Job.connection_pool.remove(conn)
         end
       end
       connection.execute("SET application_name = #{connection.quote(self.class.name)}")

data/lib/good_job/version.rb

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

data/lib/good_job.rb

@@ -58,7 +58,7 @@ module GoodJob
 
   # @!attribute [rw] active_record_parent_class
   #   @!scope class
-  #   The ActiveRecord parent class inherited by +GoodJob::Execution+ (default: +ActiveRecord::Base+).
+  #   The ActiveRecord parent class inherited by +GoodJob::Job+ (default: +ActiveRecord::Base+).
   #   Use this when using multiple databases or other custom ActiveRecord configuration.
   #   @return [ActiveRecord::Base]
   #   @example Change the base class:
@@ -133,6 +133,7 @@ module GoodJob
   def self.configure_active_record(&block)
     self._active_record_configuration = block
   end
+
   mattr_accessor :_active_record_configuration, default: nil
 
   # Stop executing jobs.
@@ -208,7 +209,7 @@ module GoodJob
     include_discarded = GoodJob.configuration.cleanup_discarded_jobs?
 
     ActiveSupport::Notifications.instrument("cleanup_preserved_jobs.good_job", { older_than: older_than, timestamp: timestamp }) do |payload|
-      deleted_executions_count = 0
+      deleted_jobs_count = 0
       deleted_batches_count = 0
       deleted_discrete_executions_count = 0
 
@@ -218,31 +219,27 @@ module GoodJob
         active_job_ids = jobs_query.pluck(:active_job_id)
         break if active_job_ids.empty?
 
-        if GoodJob::Execution.discrete_support?
-          deleted_discrete_executions = GoodJob::DiscreteExecution.where(active_job_id: active_job_ids).delete_all
-          deleted_discrete_executions_count += deleted_discrete_executions
-        end
+        deleted_discrete_executions = GoodJob::DiscreteExecution.where(active_job_id: active_job_ids).delete_all
+        deleted_discrete_executions_count += deleted_discrete_executions
 
-        deleted_executions = GoodJob::Execution.where(active_job_id: active_job_ids).delete_all
-        deleted_executions_count += deleted_executions
+        deleted_jobs = GoodJob::Job.where(active_job_id: active_job_ids).delete_all
+        deleted_jobs_count += deleted_jobs
       end
 
-      if GoodJob::BatchRecord.migrated?
-        batches_query = GoodJob::BatchRecord.finished_before(timestamp).limit(in_batches_of)
-        batches_query = batches_query.succeeded unless include_discarded
-        loop do
-          deleted = batches_query.delete_all
-          break if deleted.zero?
+      batches_query = GoodJob::BatchRecord.finished_before(timestamp).limit(in_batches_of)
+      batches_query = batches_query.succeeded unless include_discarded
+      loop do
+        deleted = batches_query.delete_all
+        break if deleted.zero?
 
-          deleted_batches_count += deleted
-        end
+        deleted_batches_count += deleted
       end
 
       payload[:destroyed_batches_count] = deleted_batches_count
       payload[:destroyed_discrete_executions_count] = deleted_discrete_executions_count
-      payload[:destroyed_executions_count] = deleted_executions_count
+      payload[:destroyed_jobs_count] = deleted_jobs_count
 
-      destroyed_records_count = deleted_batches_count + deleted_discrete_executions_count + deleted_executions_count
+      destroyed_records_count = deleted_batches_count + deleted_discrete_executions_count + deleted_jobs_count
       payload[:destroyed_records_count] = destroyed_records_count
 
       destroyed_records_count
@@ -291,9 +288,7 @@ module GoodJob
   # For use in tests/CI to validate GoodJob is up-to-date.
   # @return [Boolean]
   def self.migrated?
-    # Always update with the most recent migration check
-    GoodJob::DiscreteExecution.reset_column_information
-    GoodJob::DiscreteExecution.duration_interval_migrated?
+    true
   end
 
   ActiveSupport.run_load_hooks(:good_job, self)