good_job 1.8.0 → 1.9.4

data/lib/good_job/job_performer.rb

@@ -24,7 +24,7 @@ module GoodJob
     end
 
     # Perform the next eligible job
-    # @return [nil, Object] Returns job result or +nil+ if no job was found
+    # @return [Object, nil] Returns job result or +nil+ if no job was found
     def next
       job_query.perform_with_advisory_lock
     end
@@ -54,7 +54,7 @@ module GoodJob
     # @param after [DateTime, Time, nil] future jobs scheduled after this time
     # @param limit [Integer] number of future timestamps to return
     # @param now_limit [Integer] number of past timestamps to return
-    # @return [Array<(Time, Timestamp)>, nil]
+    # @return [Array<DateTime, Time>, nil]
     def next_at(after: nil, limit: nil, now_limit: nil)
       job_query.next_scheduled_at(after: after, limit: limit, now_limit: now_limit)
     end

data/lib/good_job/lockable.rb

@@ -143,7 +143,7 @@ module GoodJob
       def supports_cte_materialization_specifiers?
         return @_supports_cte_materialization_specifiers if defined?(@_supports_cte_materialization_specifiers)
 
-        @_supports_cte_materialization_specifiers = ActiveRecord::Base.connection.postgresql_version >= 120000
+        @_supports_cte_materialization_specifiers = connection.postgresql_version >= 120000
       end
     end
 
@@ -158,7 +158,7 @@ module GoodJob
         WHERE pg_try_advisory_lock(('x'||substr(md5($1 || $2::text), 1, 16))::bit(64)::bigint)
       SQL
       binds = [[nil, self.class.table_name], [nil, send(self.class.primary_key)]]
-      ActiveRecord::Base.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Lock', binds).any?
+      self.class.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Lock', binds).any?
     end
 
     # Releases an advisory lock on this record if it is locked by this database
@@ -245,11 +245,8 @@ module GoodJob
 
     private
 
-    def sanitize_sql_for_conditions(*args)
-      # Made public in Rails 5.2
-      self.class.send(:sanitize_sql_for_conditions, *args)
-    end
-
+    # @param query [String]
+    # @return [Boolean]
     def pg_or_jdbc_query(query)
       if Concurrent.on_jruby?
         # Replace $1 bind parameters with ?

data/lib/good_job/log_subscriber.rb

@@ -14,6 +14,7 @@ module GoodJob
 
     # @!macro notification_responder
     #   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.
@@ -24,7 +25,7 @@ module GoodJob
       end
     end
 
-    # @macro notification_responder
+    # @!macro notification_responder
     def finished_timer_task(event)
       exception = event.payload[:error]
       return unless exception
@@ -34,7 +35,7 @@ module GoodJob
       end
     end
 
-    # @macro notification_responder
+    # @!macro notification_responder
     def finished_job_task(event)
       exception = event.payload[:error]
       return unless exception
@@ -44,7 +45,7 @@ module GoodJob
       end
     end
 
-    # @macro notification_responder
+    # @!macro notification_responder
     def scheduler_create_pool(event)
       max_threads = event.payload[:max_threads]
       performer_name = event.payload[:performer_name]
@@ -55,7 +56,7 @@ module GoodJob
       end
     end
 
-    # @macro notification_responder
+    # @!macro notification_responder
     def scheduler_shutdown_start(event)
       process_id = event.payload[:process_id]
 
@@ -64,7 +65,7 @@ module GoodJob
       end
     end
 
-    # @macro notification_responder
+    # @!macro notification_responder
     def scheduler_shutdown(event)
       process_id = event.payload[:process_id]
 
@@ -73,7 +74,7 @@ module GoodJob
       end
     end
 
-    # @macro notification_responder
+    # @!macro notification_responder
     def scheduler_restart_pools(event)
       process_id = event.payload[:process_id]
 
@@ -82,7 +83,7 @@ module GoodJob
       end
     end
 
-    # @macro notification_responder
+    # @!macro notification_responder
     def perform_job(event)
       good_job = event.payload[:good_job]
       process_id = event.payload[:process_id]
@@ -93,14 +94,14 @@ module GoodJob
       end
     end
 
-    # @macro notification_responder
-    def notifier_listen(_event)
+    # @!macro notification_responder
+    def notifier_listen(event) # rubocop:disable Lint/UnusedMethodArgument
       info do
         "Notifier subscribed with LISTEN"
       end
     end
 
-    # @macro notification_responder
+    # @!macro notification_responder
     def notifier_notified(event)
       payload = event.payload[:payload]
 
@@ -109,7 +110,7 @@ module GoodJob
       end
     end
 
-    # @macro notification_responder
+    # @!macro notification_responder
     def notifier_notify_error(event)
       error = event.payload[:error]
 
@@ -118,14 +119,14 @@ module GoodJob
       end
     end
 
-    # @macro notification_responder
-    def notifier_unlisten(_event)
+    # @!macro notification_responder
+    def notifier_unlisten(event) # rubocop:disable Lint/UnusedMethodArgument
       info do
         "Notifier unsubscribed with UNLISTEN"
       end
     end
 
-    # @macro notification_responder
+    # @!macro notification_responder
     def cleanup_preserved_jobs(event)
       timestamp = event.payload[:timestamp]
       deleted_records_count = event.payload[:deleted_records_count]

data/lib/good_job/multi_scheduler.rb

@@ -4,31 +4,40 @@ module GoodJob
     # @return [Array<Scheduler>] List of the scheduler delegates
     attr_reader :schedulers
 
+    # @param schedulers [Array<Scheduler>]
     def initialize(schedulers)
       @schedulers = schedulers
     end
 
     # Delegates to {Scheduler#running?}.
+    # @return [Boolean, nil]
     def running?
       schedulers.all?(&:running?)
     end
 
     # Delegates to {Scheduler#shutdown?}.
+    # @return [Boolean, nil]
     def shutdown?
       schedulers.all?(&:shutdown?)
     end
 
     # Delegates to {Scheduler#shutdown}.
+    # @param timeout [Numeric, nil]
+    # @return [void]
     def shutdown(timeout: -1)
       GoodJob._shutdown_all(schedulers, timeout: timeout)
     end
 
     # Delegates to {Scheduler#restart}.
+    # @param timeout [Numeric, nil]
+    # @return [void]
     def restart(timeout: -1)
       GoodJob._shutdown_all(schedulers, :restart, timeout: timeout)
     end
 
     # Delegates to {Scheduler#create_thread}.
+    # @param state [Hash]
+    # @return [Boolean, nil]
     def create_thread(state = nil)
       results = []
 
@@ -44,7 +53,7 @@ module GoodJob
 
       if results.any?
         true
-      elsif results.any? { |result| result == false }
+      elsif results.any?(false)
         false
       else # rubocop:disable Style/EmptyElse
         nil

data/lib/good_job/notifier.rb

@@ -30,13 +30,13 @@ module GoodJob # :nodoc:
     # @!attribute [r] instances
     #   @!scope class
     #   List of all instantiated Notifiers in the current process.
-    #   @return [Array<GoodJob:Adapter>]
+    #   @return [Array<GoodJob::Notifier>, nil]
     cattr_reader :instances, default: [], instance_reader: false
 
     # Send a message via Postgres NOTIFY
     # @param message [#to_json]
     def self.notify(message)
-      connection = ActiveRecord::Base.connection
+      connection = Job.connection
       connection.exec_query <<~SQL.squish
         NOTIFY #{CHANNEL}, #{connection.quote(message.to_json)}
       SQL
@@ -64,18 +64,19 @@ module GoodJob # :nodoc:
     end
 
     # Tests whether the notifier is running.
+    # @!method running?
     # @return [true, false, nil]
     delegate :running?, to: :executor, allow_nil: true
 
     # Tests whether the scheduler is shutdown.
+    # @!method shutdown?
     # @return [true, false, nil]
     delegate :shutdown?, to: :executor, allow_nil: true
 
     # Shut down the notifier.
     # This stops the background LISTENing thread.
     # Use {#shutdown?} to determine whether threads have stopped.
-    # @param timeout [nil, Numeric] Seconds to wait for active threads.
-    #
+    # @param timeout [Numeric, nil] Seconds to wait for active threads.
     #   * +nil+, the scheduler will trigger a shutdown but not wait for it to complete.
     #   * +-1+, the scheduler will wait until the shutdown is complete.
     #   * +0+, the scheduler will immediately shutdown and stop any threads.
@@ -159,8 +160,8 @@ module GoodJob # :nodoc:
     end
 
     def with_listen_connection
-      ar_conn = ActiveRecord::Base.connection_pool.checkout.tap do |conn|
-        ActiveRecord::Base.connection_pool.remove(conn)
+      ar_conn = Job.connection_pool.checkout.tap do |conn|
+        Job.connection_pool.remove(conn)
       end
       pg_conn = ar_conn.raw_connection
       raise AdapterCannotListenError unless pg_conn.respond_to? :wait_for_notify

data/lib/good_job/poller.rb

@@ -16,7 +16,7 @@ module GoodJob # :nodoc:
     # @!attribute [r] instances
     #   @!scope class
     #   List of all instantiated Pollers in the current process.
-    #   @return [Array<GoodJob:Poller>]
+    #   @return [Array<GoodJob::Poller>, nil]
     cattr_reader :instances, default: [], instance_reader: false
 
     # Creates GoodJob::Poller from a GoodJob::Configuration instance.
@@ -30,8 +30,8 @@ module GoodJob # :nodoc:
     # @return [Array<#call, Array(Object, Symbol)>]
     attr_reader :recipients
 
-    # @param recipients [Array<#call, Array(Object, Symbol)>]
-    # @param poll_interval [Hash] number of seconds between polls
+    # @param recipients [Array<Proc, #call, Array(Object, Symbol)>]
+    # @param poll_interval [Integer, nil] number of seconds between polls
     def initialize(*recipients, poll_interval: nil)
       @recipients = Concurrent::Array.new(recipients)
 
@@ -54,7 +54,6 @@ module GoodJob # :nodoc:
     # Shut down the notifier.
     # Use {#shutdown?} to determine whether threads have stopped.
     # @param timeout [nil, Numeric] Seconds to wait for active threads.
-    #
     #   * +nil+, the scheduler will trigger a shutdown but not wait for it to complete.
     #   * +-1+, the scheduler will wait until the shutdown is complete.
     #   * +0+, the scheduler will immediately shutdown and stop any threads.
@@ -73,7 +72,7 @@ module GoodJob # :nodoc:
 
     # Restart the poller.
     # When shutdown, start; or shutdown and start.
-    # @param timeout [nil, Numeric] Seconds to wait; shares same values as {#shutdown}.
+    # @param timeout [Numeric, nil] Seconds to wait; shares same values as {#shutdown}.
     # @return [void]
     def restart(timeout: -1)
       shutdown(timeout: timeout) if running?
@@ -82,16 +81,21 @@ module GoodJob # :nodoc:
 
     # Invoked on completion of TimerTask task.
     # @!visibility private
+    # @param time [Integer]
+    # @param executed_task [Object, nil]
+    # @param thread_error [Exception, nil]
     # @return [void]
     def timer_observer(time, executed_task, thread_error)
       GoodJob.on_thread_error.call(thread_error) if thread_error && GoodJob.on_thread_error.respond_to?(:call)
-      instrument("finished_timer_task", { result: executed_task, error: thread_error, time: time })
+      ActiveSupport::Notifications.instrument("finished_timer_task", { result: executed_task, error: thread_error, time: time })
     end
 
     private
 
+    # @return [Concurrent::TimerTask]
     attr_reader :timer
 
+    # @return [void]
     def create_timer
       return if @timer_options[:execution_interval] <= 0
 

data/lib/good_job/scheduler.rb

@@ -30,14 +30,14 @@ module GoodJob # :nodoc:
     # @!attribute [r] instances
     #   @!scope class
     #   List of all instantiated Schedulers in the current process.
-    #   @return [Array<GoodJob:Scheduler>]
+    #   @return [Array<GoodJob::Scheduler>, nil]
     cattr_reader :instances, default: [], instance_reader: false
 
     # Creates GoodJob::Scheduler(s) and Performers from a GoodJob::Configuration instance.
     # @param configuration [GoodJob::Configuration]
     # @param warm_cache_on_initialize [Boolean]
     # @return [GoodJob::Scheduler, GoodJob::MultiScheduler]
-    def self.from_configuration(configuration, warm_cache_on_initialize: true)
+    def self.from_configuration(configuration, warm_cache_on_initialize: false)
       schedulers = configuration.queue_string.split(';').map do |queue_string_and_max_threads|
         queue_string, max_threads = queue_string_and_max_threads.split(':')
         max_threads = (max_threads || configuration.max_threads).to_i
@@ -61,8 +61,8 @@ module GoodJob # :nodoc:
     # @param performer [GoodJob::JobPerformer]
     # @param max_threads [Numeric, nil] number of seconds between polls for jobs
     # @param max_cache [Numeric, nil] maximum number of scheduled jobs to cache in memory
-    # @param warm_cache_on_initialize [Boolean] whether to warm the cache immediately
-    def initialize(performer, max_threads: nil, max_cache: nil, warm_cache_on_initialize: true)
+    # @param warm_cache_on_initialize [Boolean] whether to warm the cache immediately, or manually by calling +warm_cache+
+    def initialize(performer, max_threads: nil, max_cache: nil, warm_cache_on_initialize: false)
       raise ArgumentError, "Performer argument must implement #next" unless performer.respond_to?(:next)
 
       self.class.instances << self
@@ -82,18 +82,17 @@ module GoodJob # :nodoc:
     end
 
     # Tests whether the scheduler is running.
-    # @return [true, false, nil]
+    # @return [Boolean, nil]
     delegate :running?, to: :executor, allow_nil: true
 
     # Tests whether the scheduler is shutdown.
-    # @return [true, false, nil]
+    # @return [Boolean, nil]
     delegate :shutdown?, to: :executor, allow_nil: true
 
     # Shut down the scheduler.
     # This stops all threads in the thread pool.
     # Use {#shutdown?} to determine whether threads have stopped.
-    # @param timeout [nil, Numeric] Seconds to wait for actively executing jobs to finish
-    #
+    # @param timeout [Numeric, nil] Seconds to wait for actively executing jobs to finish
     #   * +nil+, the scheduler will trigger a shutdown but not wait for it to complete.
     #   * +-1+, the scheduler will wait until the shutdown is complete.
     #   * +0+, the scheduler will immediately shutdown and stop any active tasks.
@@ -129,8 +128,8 @@ module GoodJob # :nodoc:
     end
 
     # Wakes a thread to allow the performer to execute a task.
-    # @param state [nil, Object] Contextual information for the performer. See {JobPerformer#next?}.
-    # @return [nil, Boolean] Whether work was started.
+    # @param state [Hash, nil] Contextual information for the performer. See {JobPerformer#next?}.
+    # @return [Boolean, nil] Whether work was started.
     #
     #   * +nil+ if the scheduler is unable to take new work, for example if the thread pool is shut down or at capacity.
     #   * +true+ if the performer started executing work.
@@ -187,38 +186,58 @@ module GoodJob # :nodoc:
       }
     end
 
+    # Preload existing runnable and future-scheduled jobs
+    # @return [void]
     def warm_cache
       return if @max_cache.zero?
 
-      performer.next_at(
-        limit: @max_cache,
-        now_limit: @executor_options[:max_threads]
-      ).each do |scheduled_at|
-        create_thread({ scheduled_at: scheduled_at })
+      future = Concurrent::Future.new(args: [self, @performer], executor: executor) do |thr_scheduler, thr_performer|
+        Rails.application.executor.wrap do
+          thr_performer.next_at(
+            limit: @max_cache,
+            now_limit: @executor_options[:max_threads]
+          ).each do |scheduled_at|
+            thr_scheduler.create_thread({ scheduled_at: scheduled_at })
+          end
+        end
+      end
+
+      observer = lambda do |_time, _output, thread_error|
+        GoodJob.on_thread_error.call(thread_error) if thread_error && GoodJob.on_thread_error.respond_to?(:call)
+        create_task # If cache-warming exhausts the threads, ensure there isn't an executable task remaining
       end
+      future.add_observer(observer, :call)
+
+      future.execute
     end
 
     private
 
     attr_reader :performer, :executor, :timer_set
 
+    # @return [void]
     def create_executor
       instrument("scheduler_create_pool", { performer_name: performer.name, max_threads: @executor_options[:max_threads] }) do
-        @timer_set = Concurrent::TimerSet.new
+        @timer_set = TimerSet.new
         @executor = ThreadPoolExecutor.new(@executor_options)
       end
     end
 
+    # @param delay [Integer]
+    # @return [void]
     def create_task(delay = 0)
       future = Concurrent::ScheduledTask.new(delay, args: [performer], executor: executor, timer_set: timer_set) do |thr_performer|
-        output = nil
-        Rails.application.executor.wrap { output = thr_performer.next }
-        output
+        Rails.application.executor.wrap do
+          thr_performer.next
+        end
       end
       future.add_observer(self, :task_observer)
       future.execute
     end
 
+    # @param name [String]
+    # @param payload [Hash]
+    # @return [void]
     def instrument(name, payload = {}, &block)
       payload = payload.reverse_merge({
                                         scheduler: self,
@@ -230,7 +249,7 @@ module GoodJob # :nodoc:
     end
 
     def cache_count
-      timer_set.instance_variable_get(:@queue).length
+      timer_set.length
     end
 
     def remaining_cache_count
@@ -255,5 +274,21 @@ module GoodJob # :nodoc:
         end
       end
     end
+
+    # Custom sub-class of +Concurrent::TimerSet+ for additional behavior.
+    # @private
+    class TimerSet < Concurrent::TimerSet
+      # Number of scheduled jobs in the queue
+      # @return [Integer]
+      def length
+        @queue.length
+      end
+
+      # Clear the queue
+      # @return [void]
+      def reset
+        synchronize { @queue.clear }
+      end
+    end
   end
 end