good_job 4.1.0 → 4.1.1

data/lib/good_job/adapter/inline_buffer.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/attribute_accessors_per_thread'
+
+module GoodJob
+  class Adapter
+    # The InlineBuffer is integrated into the Adapter and captures jobs that have been enqueued inline.
+    # The purpose is allow job records to be persisted, in a locked state, while within a transaction,
+    # and then execute the jobs after the transaction has been committed to ensure that the jobs
+    # do not run within a transaction.
+    #
+    # @private This is intended for internal GoodJob usage only.
+    class InlineBuffer
+      # @!attribute [rw] current_buffer
+      #   @!scope class
+      #   Current buffer of jobs to be enqueued.
+      #   @return [GoodJob::Adapter::InlineBuffer, nil]
+      thread_mattr_accessor :current_buffer
+
+      # This block should be used to wrap the transaction that could enqueue jobs.
+      # @yield The block that may enqueue jobs.
+      # @return [Proc] A proc that will execute enqueued jobs after the transaction has been committed.
+      # @example Wrapping a transaction
+      #   buffer = GoodJob::Adapter::InlineBuffer.capture do
+      #     ActiveRecord::Base.transaction do
+      #       MyJob.perform_later
+      #     end
+      #   end
+      #   buffer.call
+      def self.capture
+        if current_buffer
+          yield
+          return proc {}
+        end
+
+        begin
+          self.current_buffer = new
+          yield
+          current_buffer.to_proc
+        ensure
+          self.current_buffer = nil
+        end
+      end
+
+      # Used within the adapter to wrap inline job execution
+      def self.perform_now_or_defer(&block)
+        if defer?
+          current_buffer.defer(block)
+        else
+          yield
+        end
+      end
+
+      def self.defer?
+        current_buffer.present?
+      end
+
+      def initialize
+        @callables = []
+      end
+
+      def defer(callable)
+        @callables << callable
+      end
+
+      def to_proc
+        proc do
+          @callables.map(&:call)
+        end
+      end
+    end
+  end
+end

data/lib/good_job/adapter.rb

@@ -57,7 +57,7 @@ module GoodJob
 
       Rails.application.executor.wrap do
         current_time = Time.current
-        executions = active_jobs.map do |active_job|
+        jobs = active_jobs.map do |active_job|
           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
@@ -65,62 +65,56 @@ module GoodJob
           end
         end
 
-        inline_executions = []
+        inline_jobs = []
         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_attributes = jobs.map(&:attributes)
+          results = GoodJob::Job.insert_all(job_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|
             active_job.provider_job_id = job_id_to_provider_job_id[active_job.job_id]
             active_job.successfully_enqueued = active_job.provider_job_id.present? if active_job.respond_to?(:successfully_enqueued=)
           end
-          executions.each do |execution|
-            execution.instance_variable_set(:@new_record, false) if job_id_to_provider_job_id[execution.active_job_id]
+          jobs.each do |job|
+            job.instance_variable_set(:@new_record, false) if job_id_to_provider_job_id[job.active_job_id]
           end
-          executions = executions.select(&:persisted?) # prune unpersisted executions
+          jobs = jobs.select(&:persisted?) # prune unpersisted jobs
 
           if execute_inline?
-            inline_executions = executions.select { |execution| (execution.scheduled_at.nil? || execution.scheduled_at <= Time.current) }
-            inline_executions.each(&:advisory_lock!)
+            inline_jobs = jobs.select { |job| job.scheduled_at.nil? || job.scheduled_at <= Time.current }
+            inline_jobs.each(&:advisory_lock!)
           end
         end
 
-        @capsule.tracker.register
-        begin
-          until inline_executions.empty?
-            begin
-              inline_execution = inline_executions.shift
-              inline_result = inline_execution.perform(lock_id: @capsule.tracker.id_for_lock)
-
-              retried_execution = inline_result.retried
-              while retried_execution && retried_execution.scheduled_at <= Time.current
-                inline_execution = retried_execution
-                inline_result = inline_execution.perform(lock_id: @capsule.tracker.id_for_lock)
-                retried_execution = inline_result.retried
+        if inline_jobs.any?
+          deferred = InlineBuffer.defer?
+          InlineBuffer.perform_now_or_defer do
+            @capsule.tracker.register do
+              until inline_jobs.empty?
+                inline_job = inline_jobs.shift
+                perform_inline(inline_job, notify: deferred ? send_notify?(inline_job) : false)
               end
             ensure
-              inline_execution.advisory_unlock
-              inline_execution.run_callbacks(:perform_unlocked)
+              inline_jobs.each(&:advisory_unlock)
             end
-            raise inline_result.unhandled_error if inline_result.unhandled_error
           end
-        ensure
-          @capsule.tracker.unregister
-          inline_executions.each(&:advisory_unlock)
         end
 
-        non_inline_executions = executions.reject(&:finished_at)
-        if non_inline_executions.any?
+        non_inline_jobs = if InlineBuffer.defer?
+                            jobs - inline_jobs
+                          else
+                            jobs.reject(&:finished_at)
+                          end
+        if non_inline_jobs.any?
           job_id_to_active_jobs = active_jobs.index_by(&:job_id)
-          non_inline_executions.group_by(&:queue_name).each do |queue_name, executions_by_queue|
-            executions_by_queue.group_by(&:scheduled_at).each do |scheduled_at, executions_by_queue_and_scheduled_at|
-              state = { queue_name: queue_name, count: executions_by_queue_and_scheduled_at.size }
+          non_inline_jobs.group_by(&:queue_name).each do |queue_name, jobs_by_queue|
+            jobs_by_queue.group_by(&:scheduled_at).each do |scheduled_at, jobs_by_queue_and_scheduled_at|
+              state = { queue_name: queue_name, count: jobs_by_queue_and_scheduled_at.size }
               state[:scheduled_at] = scheduled_at if scheduled_at
 
               executed_locally = execute_async? && @capsule&.create_thread(state)
               unless executed_locally
-                state[:count] = job_id_to_active_jobs.values_at(*executions_by_queue_and_scheduled_at.map(&:active_job_id)).count { |active_job| send_notify?(active_job) }
+                state[:count] = job_id_to_active_jobs.values_at(*jobs_by_queue_and_scheduled_at.map(&:active_job_id)).count { |active_job| send_notify?(active_job) }
                 Notifier.notify(state) unless state[:count].zero?
               end
             end
@@ -148,43 +142,32 @@ module GoodJob
         will_retry_inline = will_execute_inline && CurrentThread.job&.active_job_id == active_job.job_id && !CurrentThread.retry_now
 
         if will_retry_inline
-          execution = GoodJob::Job.enqueue(
+          job = GoodJob::Job.enqueue(
             active_job,
             scheduled_at: scheduled_at
           )
         elsif will_execute_inline
-          execution = GoodJob::Job.enqueue(
+          job = GoodJob::Job.enqueue(
             active_job,
             scheduled_at: scheduled_at,
             create_with_advisory_lock: true
           )
-          begin
-            result = @capsule.tracker.register { execution.perform(lock_id: @capsule.tracker.id_for_lock) }
-
-            retried_execution = result.retried
-            while retried_execution && (retried_execution.scheduled_at.nil? || retried_execution.scheduled_at <= Time.current)
-              execution = retried_execution
-              result = @capsule.tracker.register { execution.perform(lock_id: @capsule.tracker.id_for_lock) }
-              retried_execution = result.retried
+          InlineBuffer.perform_now_or_defer do
+            @capsule.tracker.register do
+              perform_inline(job, notify: send_notify?(active_job))
             end
-
-            Notifier.notify(retried_execution.job_state) if retried_execution&.scheduled_at && retried_execution.scheduled_at > Time.current && send_notify?(active_job)
-          ensure
-            execution.advisory_unlock
-            execution.run_callbacks(:perform_unlocked)
           end
-          raise result.unhandled_error if result.unhandled_error
         else
-          execution = GoodJob::Job.enqueue(
+          job = GoodJob::Job.enqueue(
             active_job,
             scheduled_at: scheduled_at
           )
 
-          executed_locally = execute_async? && @capsule&.create_thread(execution.job_state)
-          Notifier.notify(execution.job_state) if !executed_locally && send_notify?(active_job)
+          executed_locally = execute_async? && @capsule&.create_thread(job.job_state)
+          Notifier.notify(job.job_state) if !executed_locally && send_notify?(active_job)
         end
 
-        execution
+        job
       end
     end
 
@@ -250,5 +233,28 @@ module GoodJob
 
       !(active_job.good_job_notify == false || (active_job.class.good_job_notify == false && active_job.good_job_notify.nil?))
     end
+
+    # @param job [GoodJob::Job] the job to perform, which must be enqueued and advisory locked already
+    # @param notify [Boolean] whether to send a NOTIFY event for a retried job
+    def perform_inline(job, notify: true)
+      result = nil
+      retried_job = nil
+
+      loop do
+        result = job.perform(lock_id: @capsule.tracker.id_for_lock)
+        retried_job = result.retried_job
+        break if retried_job.nil? || retried_job.scheduled_at.nil? || retried_job.scheduled_at > Time.current
+
+        job = retried_job
+      end
+
+      Notifier.notify(retried_job.job_state) if notify && retried_job&.scheduled_at && retried_job.scheduled_at > Time.current
+      result
+    ensure
+      job.advisory_unlock
+      job.run_callbacks(:perform_unlocked)
+
+      raise result.unhandled_error if result.unhandled_error
+    end
   end
 end

data/lib/good_job/configuration.rb

@@ -150,11 +150,10 @@ module GoodJob
     # poll (using this interval) for new queued jobs to execute.
     # @return [Integer]
     def poll_interval
-      interval = (
+      interval =
         options[:poll_interval] ||
-          rails_config[:poll_interval] ||
-          env['GOOD_JOB_POLL_INTERVAL']
-      )
+        rails_config[:poll_interval] ||
+        env['GOOD_JOB_POLL_INTERVAL']
 
       if interval
         interval.to_i

data/lib/good_job/cron_manager.rb

@@ -55,9 +55,7 @@ module GoodJob # :nodoc:
     # @param timeout [Numeric, nil] Unused but retained for compatibility
     def shutdown(timeout: nil) # rubocop:disable Lint/UnusedMethodArgument
       @running = false
-      @tasks.each do |_cron_key, task|
-        task.cancel
-      end
+      @tasks.each_value(&:cancel)
       @tasks.clear
     end
 

data/lib/good_job/current_thread.rb

@@ -15,7 +15,7 @@ module GoodJob
       error_on_retry_stopped
       job
       execution_interrupted
-      execution_retried
+      retried_job
       retry_now
     ].freeze
 
@@ -61,11 +61,11 @@ module GoodJob
     #   @return [Boolean, nil]
     thread_mattr_accessor :execution_interrupted
 
-    # @!attribute [rw] execution_retried
+    # @!attribute [rw] retried_job
     #   @!scope class
     #   Execution Retried
-    #   @return [Boolean, nil]
-    thread_mattr_accessor :execution_retried
+    #   @return [GoodJob::Job, nil]
+    thread_mattr_accessor :retried_job
 
     # @!attribute [rw] retry_now
     #   @!scope class

data/lib/good_job/version.rb

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

data/lib/good_job.rb

@@ -7,6 +7,7 @@ require_relative "good_job/version"
 require_relative "good_job/engine"
 
 require_relative "good_job/adapter"
+require_relative "good_job/adapter/inline_buffer"
 require_relative "active_job/queue_adapters/good_job_adapter"
 require_relative "good_job/active_job_extensions/batches"
 require_relative "good_job/active_job_extensions/concurrency"
@@ -211,7 +212,7 @@ module GoodJob
     ActiveSupport::Notifications.instrument("cleanup_preserved_jobs.good_job", { older_than: older_than, timestamp: timestamp }) do |payload|
       deleted_jobs_count = 0
       deleted_batches_count = 0
-      deleted_discrete_executions_count = 0
+      deleted_executions_count = 0
 
       jobs_query = GoodJob::Job.finished_before(timestamp).order(finished_at: :asc).limit(in_batches_of)
       jobs_query = jobs_query.succeeded unless include_discarded
@@ -219,8 +220,8 @@ module GoodJob
         active_job_ids = jobs_query.pluck(:active_job_id)
         break if active_job_ids.empty?
 
-        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
@@ -236,10 +237,10 @@ module GoodJob
       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_jobs_count
+      destroyed_records_count = deleted_batches_count + deleted_executions_count + deleted_jobs_count
       payload[:destroyed_records_count] = destroyed_records_count
 
       destroyed_records_count

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 4.1.1
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-16 00:00:00.000000000 Z
+date: 2024-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -264,6 +264,7 @@ files:
 - app/filters/good_job/batches_filter.rb
 - app/filters/good_job/jobs_filter.rb
 - app/frontend/good_job/application.js
+- app/frontend/good_job/icons.svg
 - app/frontend/good_job/modules/async_values_controller.js
 - app/frontend/good_job/modules/charts.js
 - app/frontend/good_job/modules/checkbox_toggle.js
@@ -286,7 +287,6 @@ files:
 - app/models/concerns/good_job/filterable.rb
 - app/models/concerns/good_job/reportable.rb
 - app/models/good_job/active_record_parent_class.rb
-- app/models/good_job/base_execution.rb
 - app/models/good_job/base_record.rb
 - app/models/good_job/batch.rb
 - app/models/good_job/batch_record.rb
@@ -319,24 +319,9 @@ files:
 - app/views/good_job/shared/_footer.erb
 - app/views/good_job/shared/_navbar.erb
 - app/views/good_job/shared/_secondary_navbar.erb
-- app/views/good_job/shared/icons/_arrow_clockwise.html.erb
-- app/views/good_job/shared/icons/_check.html.erb
-- app/views/good_job/shared/icons/_circle_half.html.erb
-- app/views/good_job/shared/icons/_clock.html.erb
-- app/views/good_job/shared/icons/_dash_circle.html.erb
-- app/views/good_job/shared/icons/_dots.html.erb
-- app/views/good_job/shared/icons/_eject.html.erb
-- app/views/good_job/shared/icons/_exclamation.html.erb
-- app/views/good_job/shared/icons/_globe.html.erb
-- app/views/good_job/shared/icons/_info.html.erb
-- app/views/good_job/shared/icons/_moon_stars_fill.html.erb
-- app/views/good_job/shared/icons/_pause.html.erb
-- app/views/good_job/shared/icons/_play.html.erb
-- app/views/good_job/shared/icons/_skip_forward.html.erb
-- app/views/good_job/shared/icons/_stop.html.erb
-- app/views/good_job/shared/icons/_sun_fill.html.erb
 - app/views/good_job/shared/icons/_trash.html.erb
 - app/views/layouts/good_job/application.html.erb
+- config/brakeman.ignore
 - config/locales/de.yml
 - config/locales/en.yml
 - config/locales/es.yml
@@ -363,6 +348,7 @@ files:
 - lib/good_job/active_job_extensions/labels.rb
 - lib/good_job/active_job_extensions/notify_options.rb
 - lib/good_job/adapter.rb
+- lib/good_job/adapter/inline_buffer.rb
 - lib/good_job/bulk.rb
 - lib/good_job/callable.rb
 - lib/good_job/capsule.rb
@@ -427,7 +413,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.14
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: A multithreaded, Postgres-based ActiveJob backend for Ruby on Rails