good_job 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8f0f56838ed9baa984ad7b70ece1c72009369149bb45522aa140298ff727d44
-  data.tar.gz: a076e6f1315911e9fcacc8be7be4e87d176f6a63fd4cf8e297b8985d928074cf
+  metadata.gz: ba54d04d3afa9fea7af913fb6e04f3bdbc104f47a57b629001071da7fcd4ed55
+  data.tar.gz: 2bd4dd5be31a15c43d58f0ab7cd33830834e1e2bcd0506445258aa75d4cc98e5
 SHA512:
-  metadata.gz: 6eae147e6a6f22da09c87b246735d0844e09dbaaea2e9b2cc92664ad86efef95feb8572ddafa83964009572d5c55db5eefc9f589d63820fb77fc59ec8ac4f110
-  data.tar.gz: 3f884573f31e65c3d63c2b864a820b9e9dd5db2a71405f3514ffdd774458bb89c7b5a834878aba2a57b988cce02443fc2df8e986d09815f98784bdaa9de6b62f
+  metadata.gz: 8ade9720ef3918e10d129e886411b819e8fd96614a299552d68287ed43fcab2997057b8c63ee26b35ac321cf7d58a055c7cf5b14f74f3c887b14f59934537be8
+  data.tar.gz: 9f81f5e7faacbe1b6a4999fa82afa6eb03675472c0237616f6f570c235f72c8c925fbea0ff526726bb6542c795ef47feaa61b5e9dd00520d6a38fbfa4b7463a5

data/CHANGELOG.md

@@ -1,6 +1,14 @@
 # Changelog
 
-## [v1.6.0](https://github.com/bensheldon/good_job/tree/v1.6.0) (2021-01-21)
+## [v1.7.0](https://github.com/bensheldon/good_job/tree/v1.7.0) (2021-01-25)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.6.0...v1.7.0)
+
+**Merged pull requests:**
+
+- Cache scheduled jobs in memory so they can be executed without polling [\#205](https://github.com/bensheldon/good_job/pull/205) ([bensheldon](https://github.com/bensheldon))
+
+## [v1.6.0](https://github.com/bensheldon/good_job/tree/v1.6.0) (2021-01-22)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v1.5.0...v1.6.0)
 

data/README.md

@@ -152,6 +152,7 @@ Options:
   [--max-threads=COUNT]      # Maximum number of threads to use for working jobs. (env var: GOOD_JOB_MAX_THREADS, default: 5)
   [--queues=QUEUE_LIST]      # Queues to work from. (env var: GOOD_JOB_QUEUES, default: *)
   [--poll-interval=SECONDS]  # Interval between polls for available jobs in seconds (env var: GOOD_JOB_POLL_INTERVAL, default: 1)
+  [--max-cache=COUNT]        # Maximum number of scheduled jobs to cache in memory (env var: GOOD_JOB_MAX_CACHE, default: 10000)
   [--daemonize]              # Run as a background daemon (default: false)
   [--pidfile=PIDFILE]        # Path to write daemonized Process ID (env var: GOOD_JOB_PIDFILE, default: tmp/pids/good_job.pid)
 
@@ -225,6 +226,7 @@ Available configuration options are:
 - `max_threads` (integer) sets the maximum number of threads to use when `execution_mode` is set to `:async`. You can also set this with the environment variable `GOOD_JOB_MAX_THREADS`.
 - `queues` (string) determines which queues to execute jobs from when `execution_mode` is set to `:async`. See the description of `good_job start` for more details on the format of this string. You can also set this with the environment variable `GOOD_JOB_QUEUES`.
 - `poll_interval` (integer) sets the number of seconds between polls for jobs when `execution_mode` is set to `:async`. You can also set this with the environment variable `GOOD_JOB_POLL_INTERVAL`.
+- `max_cache` (integer) sets the maximum number of scheduled jobs that will be stored in memory to reduce execution latency when also polling for scheduled jobs. Caching 10,000 scheduled jobs uses approximately 20MB of memory. You can also set this with the environment variable `GOOD_JOB_MAX_CACHE`.
 
 By default, GoodJob configures the following execution modes per environment:
 

data/exe/good_job

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
 require 'good_job/cli'
+GOOD_JOB_WITHIN_CLI = true
 GOOD_JOB_LOG_TO_STDOUT = true
 GoodJob::CLI.start(ARGV)

data/lib/good_job/adapter.rb

@@ -50,10 +50,10 @@ module GoodJob
       @execution_mode = configuration.execution_mode
       raise ArgumentError, "execution_mode: must be one of #{EXECUTION_MODES.join(', ')}." unless EXECUTION_MODES.include?(@execution_mode)
 
-      if @execution_mode == :async # rubocop:disable Style/GuardClause
+      if execute_async? # rubocop:disable Style/GuardClause
         @notifier = GoodJob::Notifier.new
         @poller = GoodJob::Poller.new(poll_interval: configuration.poll_interval)
-        @scheduler = GoodJob::Scheduler.from_configuration(configuration)
+        @scheduler = GoodJob::Scheduler.from_configuration(configuration, warm_cache_on_initialize: Rails.application.initialized?)
         @notifier.recipients << [@scheduler, :create_thread]
         @poller.recipients << [@scheduler, :create_thread]
       end
@@ -85,10 +85,13 @@ module GoodJob
         ensure
           good_job.advisory_unlock
         end
-      end
+      else
+        job_state = { queue_name: good_job.queue_name }
+        job_state[:scheduled_at] = good_job.scheduled_at if good_job.scheduled_at
 
-      executed_locally = execute_async? && @scheduler.create_thread(queue_name: good_job.queue_name)
-      Notifier.notify(queue_name: good_job.queue_name) unless executed_locally
+        executed_locally = execute_async? && @scheduler.create_thread(job_state)
+        Notifier.notify(job_state) unless executed_locally
+      end
 
       good_job
     end

data/lib/good_job/cli.rb

@@ -49,6 +49,10 @@ module GoodJob
                   type: :numeric,
                   banner: 'SECONDS',
                   desc: "Interval between polls for available jobs in seconds (env var: GOOD_JOB_POLL_INTERVAL, default: 5)"
+    method_option :max_cache,
+                  type: :numeric,
+                  banner: 'COUNT',
+                  desc: "Maximum number of scheduled jobs to cache in memory (env var: GOOD_JOB_MAX_CACHE, default: 10000)"
     method_option :daemonize,
                   type: :boolean,
                   desc: "Run as a background daemon (default: false)"

data/lib/good_job/configuration.rb

@@ -8,7 +8,9 @@ module GoodJob
     # Default number of threads to use per {Scheduler}
     DEFAULT_MAX_THREADS = 5
     # Default number of seconds between polls for jobs
-    DEFAULT_POLL_INTERVAL = 5
+    DEFAULT_POLL_INTERVAL = 10
+    # Default number of threads to use per {Scheduler}
+    DEFAULT_MAX_CACHE = 10000
     # Default number of seconds to preserve jobs for {CLI#cleanup_preserved_jobs}
     DEFAULT_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO = 24 * 60 * 60
 
@@ -42,7 +44,9 @@ module GoodJob
     #   Value to use if none was specified in the configuration.
     # @return [Symbol]
     def execution_mode(default: :external)
-      if options[:execution_mode]
+      if defined?(GOOD_JOB_WITHIN_CLI) && GOOD_JOB_WITHIN_CLI
+        :external
+      elsif options[:execution_mode]
         options[:execution_mode]
       elsif rails_config[:execution_mode]
         rails_config[:execution_mode]
@@ -105,6 +109,19 @@ module GoodJob
       ).to_i
     end
 
+    # The maximum number of future-scheduled jobs to store in memory.
+    # Storing future-scheduled jobs in memory reduces execution latency
+    # at the cost of increased memory usage. 10,000 stored jobs = ~20MB.
+    # @return [Integer]
+    def max_cache
+      (
+        options[:max_cache] ||
+          rails_config[:max_cache] ||
+          env['GOOD_JOB_MAX_CACHE'] ||
+          DEFAULT_MAX_CACHE
+      ).to_i
+    end
+
     # Number of seconds to preserve jobs when using the +good_job cleanup_preserved_jobs+ CLI command.
     # This configuration is only used when {GoodJob.preserve_job_records} is +true+.
     # @return [Integer]

data/lib/good_job/job.rb

@@ -72,6 +72,12 @@ module GoodJob
     # @return [ActiveRecord::Relation]
     scope :priority_ordered, -> { order('priority DESC NULLS LAST') }
 
+    # Order jobs by scheduled (unscheduled or soonest first).
+    # @!method schedule_ordered
+    # @!scope class
+    # @return [ActiveRecord::Relation]
+    scope :schedule_ordered, -> { order(Arel.sql('COALESCE(scheduled_at, created_at) ASC')) }
+
     # Get Jobs were completed before the given timestamp. If no timestamp is
     # provided, get all jobs that have been completed. By default, GoodJob
     # deletes jobs after they are completed and this will find no jobs.
@@ -147,6 +153,23 @@ module GoodJob
       [good_job, result, error] if good_job
     end
 
+    # Fetches the scheduled execution time of the next eligible Job(s).
+    # @return [Array<(DateTime)>]
+    def self.next_scheduled_at(after: nil, limit: 100, now_limit: nil)
+      query = advisory_unlocked.unfinished.schedule_ordered
+
+      after ||= Time.current
+      after_query = query.where('scheduled_at > ?', after).or query.where(scheduled_at: nil).where('created_at > ?', after)
+      after_at = after_query.limit(limit).pluck(:scheduled_at, :created_at).map { |timestamps| timestamps.compact.first }
+
+      if now_limit&.positive?
+        now_query = query.where('scheduled_at < ?', Time.current).or query.where(scheduled_at: nil)
+        now_at = now_query.limit(now_limit).pluck(:scheduled_at, :created_at).map { |timestamps| timestamps.compact.first }
+      end
+
+      Array(now_at) + after_at
+    end
+
     # Places an ActiveJob job on a queue by creating a new {Job} record.
     # @param active_job [ActiveJob::Base]
     #   The job to enqueue.

data/lib/good_job/job_performer.rb

@@ -39,6 +39,8 @@ module GoodJob
     # @return [Boolean] whether the performer's {#next} method should be
     #   called in the current state.
     def next?(state = {})
+      return true unless state[:queue_name]
+
       if parsed_queues[:exclude]
         parsed_queues[:exclude].exclude?(state[:queue_name])
       elsif parsed_queues[:include]
@@ -48,6 +50,14 @@ module GoodJob
       end
     end
 
+    # The Returns timestamps of when next tasks may be available.
+    # @param count [Integer] number of timestamps to return
+    # @param count [DateTime, Time, nil] jobs scheduled after this time
+    # @return [Array<(Time, Timestamp)>, 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
+
     private
 
     attr_reader :queue_string

data/lib/good_job/railtie.rb

@@ -19,5 +19,9 @@ module GoodJob
         GoodJob::CurrentExecution.error_on_discard = event.payload[:error]
       end
     end
+
+    config.after_initialize do
+      GoodJob::Scheduler.instances.each(&:warm_cache)
+    end
   end
 end

data/lib/good_job/scheduler.rb

@@ -1,5 +1,6 @@
 require "concurrent/executor/thread_pool_executor"
-require "concurrent/timer_task"
+require "concurrent/executor/timer_set"
+require "concurrent/scheduled_task"
 require "concurrent/utility/processor_counter"
 
 module GoodJob # :nodoc:
@@ -22,7 +23,7 @@ module GoodJob # :nodoc:
       max_threads: Configuration::DEFAULT_MAX_THREADS,
       auto_terminate: true,
       idletime: 60,
-      max_queue: 0,
+      max_queue: 1, # ideally zero, but 0 == infinite
       fallback_policy: :discard,
     }.freeze
 
@@ -34,14 +35,20 @@ module GoodJob # :nodoc:
 
     # 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)
+    def self.from_configuration(configuration, warm_cache_on_initialize: true)
       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
 
         job_performer = GoodJob::JobPerformer.new(queue_string)
-        GoodJob::Scheduler.new(job_performer, max_threads: max_threads)
+        GoodJob::Scheduler.new(
+          job_performer,
+          max_threads: max_threads,
+          max_cache: configuration.max_cache,
+          warm_cache_on_initialize: warm_cache_on_initialize
+        )
       end
 
       if schedulers.size > 1
@@ -53,18 +60,22 @@ module GoodJob # :nodoc:
 
     # @param performer [GoodJob::JobPerformer]
     # @param max_threads [Numeric, nil] number of seconds between polls for jobs
-    def initialize(performer, max_threads: nil)
+    # @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)
       raise ArgumentError, "Performer argument must implement #next" unless performer.respond_to?(:next)
 
       self.class.instances << self
 
       @performer = performer
 
+      @max_cache = max_cache || 0
       @pool_options = DEFAULT_POOL_OPTIONS.dup
       @pool_options[:max_threads] = max_threads if max_threads.present?
       @pool_options[:name] = "GoodJob::Scheduler(queues=#{@performer.name} max_threads=#{@pool_options[:max_threads]})"
 
       create_pool
+      warm_cache if warm_cache_on_initialize
     end
 
     # Shut down the scheduler.
@@ -79,6 +90,8 @@ module GoodJob # :nodoc:
 
       instrument("scheduler_shutdown_start", { wait: wait })
       instrument("scheduler_shutdown", { wait: wait }) do
+        @timer_set.shutdown
+
         @pool.shutdown
         @pool.wait_for_termination if wait
         # TODO: Should be killed if wait is not true
@@ -99,6 +112,7 @@ module GoodJob # :nodoc:
       instrument("scheduler_restart_pools") do
         shutdown(wait: wait) unless shutdown?
         create_pool
+        warm_cache
       end
     end
 
@@ -109,10 +123,30 @@ module GoodJob # :nodoc:
     #   Returns +true+ if the performer started executing work.
     #   Returns +false+ if the performer decides not to attempt to execute a task based on the +state+ that is passed to it.
     def create_thread(state = nil)
-      return nil unless @pool.running? && @pool.ready_worker_count.positive?
-      return false if state && !@performer.next?(state)
+      return nil unless @pool.running?
+
+      if state
+        return false unless @performer.next?(state)
+
+        if state[:scheduled_at]
+          scheduled_at = if state[:scheduled_at].is_a? String
+                           Time.zone.parse state[:scheduled_at]
+                         else
+                           state[:scheduled_at]
+                         end
+          delay = [(scheduled_at - Time.current).to_f, 0].max
+        end
+      end
+
+      delay ||= 0
+      run_now = delay <= 0.01
+      if run_now
+        return nil unless @pool.ready_worker_count.positive?
+      elsif @max_cache.positive?
+        return nil unless remaining_cache_count.positive?
+      end
 
-      future = Concurrent::Future.new(args: [@performer], executor: @pool) do |performer|
+      future = Concurrent::ScheduledTask.new(delay, args: [@performer], executor: @pool, timer_set: timer_set) do |performer|
         output = nil
         Rails.application.executor.wrap { output = performer.next }
         output
@@ -120,7 +154,7 @@ module GoodJob # :nodoc:
       future.add_observer(self, :task_observer)
       future.execute
 
-      true
+      run_now ? true : nil
     end
 
     # Invoked on completion of ThreadPoolExecutor task
@@ -132,10 +166,36 @@ module GoodJob # :nodoc:
       create_thread if output
     end
 
+    def warm_cache
+      return if @max_cache.zero?
+
+      @performer.next_at(
+        limit: @max_cache,
+        now_limit: @pool_options[:max_threads]
+      ).each do |scheduled_at|
+        create_thread({ scheduled_at: scheduled_at })
+      end
+    end
+
+    def stats
+      {
+        name: @performer.name,
+        max_threads: @pool_options[:max_threads],
+        active_threads: @pool.ready_worker_count - @pool_options[:max_threads],
+        inactive_threads: @pool.ready_worker_count,
+        max_cache: @max_cache,
+        cache_count: cache_count,
+        cache_remaining: remaining_cache_count,
+      }
+    end
+
     private
 
+    attr_reader :timer_set
+
     def create_pool
       instrument("scheduler_create_pool", { performer_name: @performer.name, max_threads: @pool_options[:max_threads] }) do
+        @timer_set = Concurrent::TimerSet.new
         @pool = ThreadPoolExecutor.new(@pool_options)
       end
     end
@@ -150,6 +210,14 @@ module GoodJob # :nodoc:
       ActiveSupport::Notifications.instrument("#{name}.good_job", payload, &block)
     end
 
+    def cache_count
+      timer_set.instance_variable_get(:@queue).length
+    end
+
+    def remaining_cache_count
+      @max_cache - cache_count
+    end
+
     # Custom sub-class of +Concurrent::ThreadPoolExecutor+ to add additional worker status.
     # @private
     class ThreadPoolExecutor < Concurrent::ThreadPoolExecutor

data/lib/good_job/version.rb

@@ -1,4 +1,4 @@
 module GoodJob
   # GoodJob gem version.
-  VERSION = '1.6.0'.freeze
+  VERSION = '1.7.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.0
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-22 00:00:00.000000000 Z
+date: 2021-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob