good_job 1.3.6 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b5d625792328475faca2679c6718f344fc5162cac639be09f91197c998f2fdf
-  data.tar.gz: 4aef2c4ae814f2a0606c18e875c91e56f8a1411394c37d45f4e1141be719f080
+  metadata.gz: ba54d04d3afa9fea7af913fb6e04f3bdbc104f47a57b629001071da7fcd4ed55
+  data.tar.gz: 2bd4dd5be31a15c43d58f0ab7cd33830834e1e2bcd0506445258aa75d4cc98e5
 SHA512:
-  metadata.gz: d309e288c89c65ec809cf7f9e138026b229aed9abb6ee667343c56ed1e96fb0833be36b7e1f1c6b064168957f537d572e2ceb5ecad0f6e754108762ace9fbd3b
-  data.tar.gz: c1b83122c14edcbe619c6198fae270f9dbb0398888232f96e8956be23ca0f5798422181a21ea08735a0089ad3a92c0405ee69731a8a205f3fe9c99ba2b27bb36
+  metadata.gz: 8ade9720ef3918e10d129e886411b819e8fd96614a299552d68287ed43fcab2997057b8c63ee26b35ac321cf7d58a055c7cf5b14f74f3c887b14f59934537be8
+  data.tar.gz: 9f81f5e7faacbe1b6a4999fa82afa6eb03675472c0237616f6f570c235f72c8c925fbea0ff526726bb6542c795ef47feaa61b5e9dd00520d6a38fbfa4b7463a5

data/CHANGELOG.md

@@ -1,5 +1,75 @@
 # Changelog
 
+## [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)
+
+**Implemented enhancements:**
+
+- Running as a daemon [\#88](https://github.com/bensheldon/good_job/issues/88)
+- Add daemonize option to CLI [\#202](https://github.com/bensheldon/good_job/pull/202) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- Rails 6.1 & async - `queue\_parser': undefined method `first' for "\*":String \(NoMethodError\) [\#195](https://github.com/bensheldon/good_job/issues/195)
+
+**Merged pull requests:**
+
+- Add scripts directory for benchmarking and dev tasks [\#204](https://github.com/bensheldon/good_job/pull/204) ([bensheldon](https://github.com/bensheldon))
+- Fix YARD attr\_ declarations for documentation [\#203](https://github.com/bensheldon/good_job/pull/203) ([bensheldon](https://github.com/bensheldon))
+- Remove Appraisal gemfile locks [\#201](https://github.com/bensheldon/good_job/pull/201) ([bensheldon](https://github.com/bensheldon))
+
+## [v1.5.0](https://github.com/bensheldon/good_job/tree/v1.5.0) (2021-01-18)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.4.1...v1.5.0)
+
+**Implemented enhancements:**
+
+- Create Web UI Dashboard [\#50](https://github.com/bensheldon/good_job/issues/50)
+
+**Closed issues:**
+
+- JRuby Support [\#160](https://github.com/bensheldon/good_job/issues/160)
+
+**Merged pull requests:**
+
+- Update bundler version to 2.2.5 [\#200](https://github.com/bensheldon/good_job/pull/200) ([bensheldon](https://github.com/bensheldon))
+- Configure GoodJob via `Rails.application.config` instead of recommending `GoodJob::Adapter.new` [\#199](https://github.com/bensheldon/good_job/pull/199) ([bensheldon](https://github.com/bensheldon))
+- Update GH Test Matrix with minimum & latest JRuby version [\#197](https://github.com/bensheldon/good_job/pull/197) ([tedhexaflow](https://github.com/tedhexaflow))
+- Fix JRuby version number [\#193](https://github.com/bensheldon/good_job/pull/193) ([tedhexaflow](https://github.com/tedhexaflow))
+
+## [v1.4.1](https://github.com/bensheldon/good_job/tree/v1.4.1) (2021-01-09)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.4.0...v1.4.1)
+
+**Fixed bugs:**
+
+- Do not add lib/generators to Zeitwerk autoloader [\#192](https://github.com/bensheldon/good_job/pull/192) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- Issues with Heroku and Good Job [\#184](https://github.com/bensheldon/good_job/issues/184)
+
+**Merged pull requests:**
+
+- Add missing YARD docs and Dashboard screenshot [\#191](https://github.com/bensheldon/good_job/pull/191) ([bensheldon](https://github.com/bensheldon))
+
+## [v1.4.0](https://github.com/bensheldon/good_job/tree/v1.4.0) (2020-12-31)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.3.6...v1.4.0)
+
+**Implemented enhancements:**
+
+- Add JRuby support [\#167](https://github.com/bensheldon/good_job/pull/167) ([bensheldon](https://github.com/bensheldon))
+
 ## [v1.3.6](https://github.com/bensheldon/good_job/tree/v1.3.6) (2020-12-30)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v1.3.5...v1.3.6)
@@ -100,9 +170,6 @@
 **Implemented enhancements:**
 
 - Lengthen default poll interval from 1 to 5 seconds [\#156](https://github.com/bensheldon/good_job/pull/156) ([bensheldon](https://github.com/bensheldon))
-
-**Merged pull requests:**
-
 - Rename reperform\_jobs\_on\_standard\_error to retry\_on\_unhandled\_error [\#154](https://github.com/bensheldon/good_job/pull/154) ([morgoth](https://github.com/morgoth))
 
 ## [v1.2.6](https://github.com/bensheldon/good_job/tree/v1.2.6) (2020-09-29)
@@ -212,11 +279,13 @@
 **Implemented enhancements:**
 
 - Run Github Action tests against Ruby 2.5, 2.6, 2.7 [\#100](https://github.com/bensheldon/good_job/issues/100)
+- Name the thread pools [\#96](https://github.com/bensheldon/good_job/pull/96) ([sj26](https://github.com/sj26))
 
 **Fixed bugs:**
 
 - Freezes puma on code change [\#95](https://github.com/bensheldon/good_job/issues/95)
 - Ruby 2.7 keyword arguments warning [\#93](https://github.com/bensheldon/good_job/issues/93)
+- Return to using executor.wrap around Scheduler execution task [\#99](https://github.com/bensheldon/good_job/pull/99) ([bensheldon](https://github.com/bensheldon))
 
 **Closed issues:**
 
@@ -226,10 +295,8 @@
 
 - Use more ActiveRecord in Lockable and not connection.execute [\#102](https://github.com/bensheldon/good_job/pull/102) ([bensheldon](https://github.com/bensheldon))
 - Run CI tests on Ruby 2.5, 2.6, and 2.7 [\#101](https://github.com/bensheldon/good_job/pull/101) ([arku](https://github.com/arku))
-- Return to using executor.wrap around Scheduler execution task [\#99](https://github.com/bensheldon/good_job/pull/99) ([bensheldon](https://github.com/bensheldon))
 - Fix Ruby 2.7 keyword arguments warning [\#98](https://github.com/bensheldon/good_job/pull/98) ([arku](https://github.com/arku))
 - Remove executor/reloader for less interlocking [\#97](https://github.com/bensheldon/good_job/pull/97) ([sj26](https://github.com/sj26))
-- Name the thread pools [\#96](https://github.com/bensheldon/good_job/pull/96) ([sj26](https://github.com/sj26))
 - Add test for `rails g good\_job:install` [\#94](https://github.com/bensheldon/good_job/pull/94) ([arku](https://github.com/arku))
 
 ## [v1.2.1](https://github.com/bensheldon/good_job/tree/v1.2.1) (2020-08-21)

data/README.md

@@ -30,12 +30,13 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
 ## Table of contents
 
 - [Set up](#set-up)
+- [Compatibility](#compatibility)
 - [Configuration](#configuration)
     - [Command-line options](#command-line-options)
         - [`good_job start`](#good_job-start)
         - [`good_job cleanup_preserved_jobs`](#good_job-cleanup_preserved_jobs)
-    - [Adapter options](#adapter-options)
-    - [Global options](#global-options)
+    - [Configuration options](#configuration-options)
+    - [Global options](#global-options)pter
     - [Dashboard](#dashboard)
 - [Go deeper](#go-deeper)
     - [Exceptions, retries, and reliability](#exceptions-retries-and-reliability)
@@ -123,6 +124,12 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
 
         Additional configuration is likely necessary, see the reference below for async configuration.
 
+## Compatibility
+
+- **Ruby on Rails:** 5.2+
+- **Ruby:** MRI 2.5+. JRuby 9.2.13+ (_JRuby's `activerecord-jdbcpostgresql-adapter` gem does not support Postgres LISTEN/NOTIFY)._
+- **Postgres:** 9.6+
+
 ## Configuration
 
 ### Command-line options
@@ -145,6 +152,9 @@ 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)
 
 Executes queued jobs.
 
@@ -152,6 +162,7 @@ All options can be configured with environment variables.
 See option descriptions for the matching environment variable name.
 
 == Configuring queues
+
 Separate multiple queues with commas; exclude queues with a leading minus;
 separate isolated execution pools with semicolons and threads with colons.
 ```
@@ -182,9 +193,31 @@ If you are preserving job records this way, use this command regularly
 to delete old records and preserve space in your database.
 ```
 
-### Adapter options
+### Configuration options
+
+To use GoodJob, you can set `config.active_job.queue_adapter` to a `:good_job`.
+
+Additional configuration can be provided via `config.good_job.OPTION = ...` for example:
+
+```ruby
+# config/application.rb
+
+config.active_job.queue_adapter = :good_job
 
-To use GoodJob, you can set `config.active_job.queue_adapter` to a `:good_job` or to an instance of `GoodJob::Adapter`, which you can configure with several options:
+# Configure options individually...
+config.good_job.execution_mode = :async
+config.good_job.max_threads = 5
+config.good_job.poll_interval = 30 # seconds
+
+# ...or all at once.
+config.good_job = {
+  execution_mode: :async,
+  max_threads: 5,
+  poll_interval: 30,
+}
+```
+
+Available configuration options are:
 
 - `execution_mode` (symbol) specifies how and where jobs should be executed. You can also set this with the environment variable `GOOD_JOB_EXECUTION_MODE`. It can be any one of:
     - `:inline` executes jobs immediately in whatever process queued them (usually the web server process). This should only be used in test and development environments.
@@ -193,18 +226,23 @@ To use GoodJob, you can set `config.active_job.queue_adapter` to a `:good_job` o
 - `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`.
 
-Using the symbol instead of explicitly configuring the options above (i.e. setting `config.active_job.queue_adapter = :good_job`) is equivalent to:
+By default, GoodJob configures the following execution modes per environment:
 
 ```ruby
+
 # config/environments/development.rb
-config.active_job.queue_adapter = GoodJob::Adapter.new(execution_mode: :inline)
+config.active_job.queue_adapter = :good_job
+config.good_job.execution_mode = :inline
 
 # config/environments/test.rb
-config.active_job.queue_adapter = GoodJob::Adapter.new(execution_mode: :inline)
+config.active_job.queue_adapter = :good_job
+config.good_job.execution_mode = :inline
 
 # config/environments/production.rb
-config.active_job.queue_adapter = GoodJob::Adapter.new(execution_mode: :external)
+config.active_job.queue_adapter = :good_job
+config.good_job.execution_mode = :external
 ```
 
 ### Global options
@@ -227,6 +265,8 @@ GoodJob.on_thread_error = -> (exception) { Raven.capture_exception(exception) }
 
 ### Dashboard
 
+![Dashboard UI](https://github.com/bensheldon/good_job/raw/main/SCREENSHOT.png)
+
 _🚧 GoodJob's dashboard is a work in progress. Please contribute ideas and code on [Github](https://github.com/bensheldon/good_job/issues)._
 
 GoodJob includes a Dashboard as a mountable `Rails::Engine`.
@@ -433,14 +473,24 @@ pool: <%= [ENV.fetch("RAILS_MAX_THREADS", 5).to_i, ENV.fetch("GOOD_JOB_MAX_THREA
 
 GoodJob can execute jobs "async" in the same process as the webserver (e.g. `bin/rail s`). GoodJob's async execution mode offers benefits of economy by not requiring a separate job worker process, but with the tradeoff of increased complexity. Async mode can be configured in two ways:
 
-- Directly configure the ActiveJob adapter:
+- Via Rails configuration:
 
     ```ruby
     # config/environments/production.rb
-    config.active_job.queue_adapter = GoodJob::Adapter.new(execution_mode: :async, max_threads: 4, poll_interval: 30)
+    config.active_job.queue_adapter = :good_job
+
+    # To change the execution mode
+    config.good_job.execution_mode = :async
+
+    # Or with more configuration
+    config.good_job = {
+      execution_mode: :async,
+      max_threads: 4,
+      poll_interval: 30
+    }
     ```
 
-- Or, when using `...queue_adapter = :good_job`, via environment variables:
+- Or, with environment variables:
 
     ```bash
     $ GOOD_JOB_EXECUTION_MODE=async GOOD_JOB_MAX_THREADS=4 GOOD_JOB_POLL_INTERVAL=30 bin/rails server

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/active_job/queue_adapters/good_job_adapter.rb

@@ -2,9 +2,9 @@ module ActiveJob # :nodoc:
   module QueueAdapters # :nodoc:
     # See {GoodJob::Adapter} for details.
     class GoodJobAdapter < GoodJob::Adapter
-      def initialize(execution_mode: nil, max_threads: nil, poll_interval: nil, scheduler: nil, inline: false)
-        configuration = GoodJob::Configuration.new({ execution_mode: execution_mode }, env: ENV)
-        super(execution_mode: configuration.rails_execution_mode, max_threads: max_threads, poll_interval: poll_interval, scheduler: scheduler, inline: inline)
+      def initialize(**options)
+        configuration = GoodJob::Configuration.new(options, env: ENV)
+        super(**options.merge(execution_mode: configuration.rails_execution_mode))
       end
     end
   end

data/lib/good_job.rb

@@ -1,16 +1,15 @@
 require "rails"
-
 require "active_job"
 require "active_job/queue_adapters"
 
 require "zeitwerk"
-
-loader = Zeitwerk::Loader.for_gem
-loader.inflector.inflect(
-  'cli' => "CLI"
-)
-loader.push_dir(File.join(__dir__, ["generators"]))
-loader.setup
+Zeitwerk::Loader.for_gem.tap do |loader|
+  loader.inflector.inflect({
+                             "cli" => "CLI",
+                           })
+  loader.ignore(File.join(File.dirname(__FILE__), "generators"))
+  loader.setup
+end
 
 require "good_job/railtie"
 

data/lib/good_job/adapter.rb

@@ -20,13 +20,22 @@ module GoodJob
     # @param max_threads [nil, Integer] sets the number of threads per scheduler to use when +execution_mode+ is set to +:async+. The +queues+ parameter can specify a number of threads for each group of queues which will override this value. You can also set this with the environment variable +GOOD_JOB_MAX_THREADS+. Defaults to +5+.
     # @param queues [nil, String] determines which queues to execute jobs from when +execution_mode+ is set to +:async+. See {file:README.md#optimize-queues-threads-and-processes} for more details on the format of this string. You can also set this with the environment variable +GOOD_JOB_QUEUES+. Defaults to +"*"+.
     # @param poll_interval [nil, 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+. Defaults to +1+.
-    # @param scheduler [nil, Scheduler] (deprecated) a scheduler to be managed by the adapter
-    # @param notifier [nil, Notifier] (deprecated) a notifier to be managed by the adapter
-    # @param inline [nil, Boolean] (deprecated) whether to run in inline execution mode
-    def initialize(execution_mode: nil, queues: nil, max_threads: nil, poll_interval: nil, scheduler: nil, notifier: nil, inline: false)
-      if inline && execution_mode.nil?
-        ActiveSupport::Deprecation.warn('GoodJob::Adapter#new(inline: true) is deprecated; use GoodJob::Adapter.new(execution_mode: :inline) instead')
-        execution_mode = :inline
+    def initialize(execution_mode: nil, queues: nil, max_threads: nil, poll_interval: nil)
+      if caller[0..4].find { |c| c.include?("/config/application.rb") || c.include?("/config/environments/") }
+        ActiveSupport::Deprecation.warn(<<~DEPRECATION)
+          GoodJob no longer recommends creating a GoodJob::Adapter instance:
+
+              config.active_job.queue_adapter = GoodJob::Adapter.new...
+
+          Instead, configure GoodJob through configuration:
+
+              config.active_job.queue_adapter = :good_job
+              config.good_job.execution_mode = :#{execution_mode}
+              config.good_job.max_threads = #{max_threads}
+              config.good_job.poll_interval = #{poll_interval}
+              # etc...
+
+        DEPRECATION
       end
 
       configuration = GoodJob::Configuration.new(
@@ -41,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
-        @notifier = notifier || GoodJob::Notifier.new
+      if execute_async? # rubocop:disable Style/GuardClause
+        @notifier = GoodJob::Notifier.new
         @poller = GoodJob::Poller.new(poll_interval: configuration.poll_interval)
-        @scheduler = 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
@@ -76,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
@@ -108,11 +120,5 @@ module GoodJob
     def execute_inline?
       @execution_mode == :inline
     end
-
-    # (deprecated) Whether in +:inline+ execution mode.
-    def inline?
-      ActiveSupport::Deprecation.warn('GoodJob::Adapter::inline? is deprecated; use GoodJob::Adapter::execute_inline? instead')
-      execute_inline?
-    end
   end
 end

data/lib/good_job/cli.rb

@@ -15,6 +15,11 @@ module GoodJob
     # Requiring this loads the application's configuration and classes.
     RAILS_ENVIRONMENT_RB = File.expand_path("config/environment.rb")
 
+    # @!visibility private
+    def self.exit_on_failure?
+      true
+    end
+
     # @!macro thor.desc
     #   @!method $1
     #   @return [void]
@@ -27,7 +32,8 @@ module GoodJob
       See option descriptions for the matching environment variable name.
 
       == Configuring queues
-      \x5Separate multiple queues with commas; exclude queues with a leading minus;
+
+      Separate multiple queues with commas; exclude queues with a leading minus;
       separate isolated execution pools with semicolons and threads with colons.
 
     DESCRIPTION
@@ -43,10 +49,22 @@ 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)"
+    method_option :pidfile,
+                  type: :string,
+                  desc: "Path to write daemonized Process ID (env var: GOOD_JOB_PIDFILE, default: tmp/pids/good_job.pid)"
     def start
       set_up_application!
       configuration = GoodJob::Configuration.new(options)
 
+      Daemon.new(pidfile: configuration.pidfile).daemonize if configuration.daemonize?
+
       notifier = GoodJob::Notifier.new
       poller = GoodJob::Poller.new(poll_interval: configuration.poll_interval)
       scheduler = GoodJob::Scheduler.from_configuration(configuration)

data/lib/good_job/configuration.rb

@@ -8,20 +8,21 @@ 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
 
-    # @!attribute [r] options
-    #   The options that were explicitly set when initializing +Configuration+.
-    #   @return [Hash]
-    #
-    # @!attribute [r] env
-    #   The environment from which to read GoodJob's environment variables. By
-    #   default, this is the current process's environment, but it can be set
-    #   to something else in {#initialize}.
-    #   @return [Hash]
-    attr_reader :options, :env
+    # The options that were explicitly set when initializing +Configuration+.
+    # @return [Hash]
+    attr_reader :options
+
+    # The environment from which to read GoodJob's environment variables. By
+    # default, this is the current process's environment, but it can be set
+    # to something else in {#initialize}.
+    # @return [Hash]
+    attr_reader :env
 
     # @param options [Hash] Any explicitly specified configuration options to
     #   use. Keys are symbols that match the various methods on this class.
@@ -43,8 +44,12 @@ 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]
       elsif env['GOOD_JOB_EXECUTION_MODE'].present?
         env['GOOD_JOB_EXECUTION_MODE'].to_sym
       else
@@ -72,6 +77,7 @@ module GoodJob
     def max_threads
       (
         options[:max_threads] ||
+        rails_config[:max_threads] ||
         env['GOOD_JOB_MAX_THREADS'] ||
         env['RAILS_MAX_THREADS'] ||
         DEFAULT_MAX_THREADS
@@ -85,6 +91,7 @@ module GoodJob
     # @return [String]
     def queue_string
       options[:queues] ||
+        rails_config[:queues] ||
         env['GOOD_JOB_QUEUES'] ||
         '*'
     end
@@ -96,17 +103,55 @@ module GoodJob
     def poll_interval
       (
         options[:poll_interval] ||
+        rails_config[:poll_interval] ||
         env['GOOD_JOB_POLL_INTERVAL'] ||
         DEFAULT_POLL_INTERVAL
       ).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]
     def cleanup_preserved_jobs_before_seconds_ago
       (
         options[:before_seconds_ago] ||
+        rails_config[:cleanup_preserved_jobs_before_seconds_ago] ||
         env['GOOD_JOB_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO'] ||
         DEFAULT_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO
       ).to_i
     end
+
+    # Tests whether to daemonize the process.
+    # @return [Boolean]
+    def daemonize?
+      options[:daemonize] || false
+    end
+
+    # Path of the pidfile to create when running as a daemon.
+    # @return [Pathname,String]
+    def pidfile
+      options[:pidfile] ||
+        env['GOOD_JOB_PIDFILE'] ||
+        Rails.application.root.join('tmp', 'pids', 'good_job.pid')
+    end
+
+    private
+
+    def rails_config
+      Rails.application.config.good_job
+    end
   end
 end

data/lib/good_job/daemon.rb

@@ -0,0 +1,59 @@
+module GoodJob
+  #
+  # Manages daemonization of the current process.
+  #
+  class Daemon
+    # The path of the generated pidfile.
+    # @return [Pathname,String]
+    attr_reader :pidfile
+
+    # @param pidfile [Pathname,String] Pidfile path
+    def initialize(pidfile:)
+      @pidfile = pidfile
+    end
+
+    # Daemonizes the current process and writes out a pidfile.
+    def daemonize
+      check_pid
+      Process.daemon
+      write_pid
+    end
+
+    private
+
+    def write_pid
+      File.open(pidfile, ::File::CREAT | ::File::EXCL | ::File::WRONLY) { |f| f.write(Process.pid.to_s) }
+      at_exit { File.delete(pidfile) if File.exist?(pidfile) }
+    rescue Errno::EEXIST
+      check_pid
+      retry
+    end
+
+    def delete_pid
+      File.delete(pidfile) if File.exist?(pidfile)
+    end
+
+    def check_pid
+      case pid_status(pidfile)
+      when :running, :not_owned
+        abort "A server is already running. Check #{pidfile}"
+      when :dead
+        File.delete(pidfile)
+      end
+    end
+
+    def pid_status(pidfile)
+      return :exited unless File.exist?(pidfile)
+
+      pid = ::File.read(pidfile).to_i
+      return :dead if pid.zero?
+
+      Process.kill(0, pid) # check process status
+      :running
+    rescue Errno::ESRCH
+      :dead
+    rescue Errno::EPERM
+      :not_owned
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+require 'concurrent/delay'
+
+module GoodJob
+  #
+  # JobPerformer queries the database for jobs and performs them on behalf of a
+  # {Scheduler}. It mainly functions as glue between a {Scheduler} and the jobs
+  # it should be executing.
+  #
+  # The JobPerformer must be safe to execute across multiple threads.
+  #
+  class JobPerformer
+    # @param queue_string [String] Queues to execute jobs from
+    def initialize(queue_string)
+      @queue_string = queue_string
+
+      @job_query = Concurrent::Delay.new { GoodJob::Job.queue_string(queue_string) }
+      @parsed_queues = Concurrent::Delay.new { GoodJob::Job.queue_parser(queue_string) }
+    end
+
+    # A meaningful name to identify the performer in logs and for debugging.
+    # @return [String] The queues from which Jobs are worked
+    def name
+      @queue_string
+    end
+
+    # Perform the next eligible job
+    # @return [nil, Object] Returns job result or +nil+ if no job was found
+    def next
+      job_query.perform_with_advisory_lock
+    end
+
+    # Tests whether this performer should be used in GoodJob's current state.
+    #
+    # For example, state will be a LISTEN/NOTIFY message that is passed down
+    # from the Notifier to the Scheduler. The Scheduler is able to ask
+    # its performer "does this message relate to you?", and if not, ignore it
+    # to minimize thread wake-ups, database queries, and thundering herds.
+    #
+    # @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]
+        parsed_queues[:include].include?(state[:queue_name])
+      else
+        true
+      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
+
+    def job_query
+      @job_query.value
+    end
+
+    def parsed_queues
+      @parsed_queues.value
+    end
+  end
+end

data/lib/good_job/lockable.rb

@@ -92,8 +92,6 @@ module GoodJob
       # @return [ActiveRecord::Relation]
       scope :owns_advisory_locked, -> { joins_advisory_locks.where('"pg_locks"."pid" = pg_backend_pid()') }
 
-      # @!attribute [r] create_with_advisory_lock
-      # @return [Boolean]
       # Whether an advisory lock should be acquired in the same transaction
       # that created the record.
       #
@@ -107,6 +105,8 @@ module GoodJob
       #   record = MyLockableRecord.create(create_with_advisory_lock: true)
       #   record.advisory_locked?
       #   => true
+      #
+      # @return [Boolean]
       attr_accessor :create_with_advisory_lock
 
       after_create -> { advisory_lock }, if: :create_with_advisory_lock
@@ -157,7 +157,8 @@ module GoodJob
         SELECT 1 AS one
         WHERE pg_try_advisory_lock(('x'||substr(md5($1 || $2::text), 1, 16))::bit(64)::bigint)
       SQL
-      self.class.connection.exec_query(query, 'GoodJob::Lockable Advisory Lock', [[nil, self.class.table_name], [nil, send(self.class.primary_key)]]).any?
+      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?
     end
 
     # Releases an advisory lock on this record if it is locked by this database
@@ -169,7 +170,8 @@ module GoodJob
         SELECT 1 AS one
         WHERE pg_advisory_unlock(('x'||substr(md5($1 || $2::text), 1, 16))::bit(64)::bigint)
       SQL
-      self.class.connection.exec_query(query, 'GoodJob::Lockable Advisory Unlock', [[nil, self.class.table_name], [nil, send(self.class.primary_key)]]).any?
+      binds = [[nil, self.class.table_name], [nil, send(self.class.primary_key)]]
+      self.class.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Unlock', binds).any?
     end
 
     # Acquires an advisory lock on this record or raises
@@ -212,9 +214,10 @@ module GoodJob
         WHERE pg_locks.locktype = 'advisory'
           AND pg_locks.objsubid = 1
           AND pg_locks.classid = ('x' || substr(md5($1 || $2::text), 1, 16))::bit(32)::int
-          AND pg_locks.objid = (('x' || substr(md5($1 || $2::text), 1, 16))::bit(64) << 32)::bit(32)::int
+          AND pg_locks.objid = (('x' || substr(md5($3 || $4::text), 1, 16))::bit(64) << 32)::bit(32)::int
       SQL
-      self.class.connection.exec_query(query, 'GoodJob::Lockable Advisory Locked?', [[nil, self.class.table_name], [nil, send(self.class.primary_key)]]).any?
+      binds = [[nil, self.class.table_name], [nil, send(self.class.primary_key)], [nil, self.class.table_name], [nil, send(self.class.primary_key)]]
+      self.class.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Locked?', binds).any?
     end
 
     # Tests whether this record is locked by the current database session.
@@ -226,10 +229,11 @@ module GoodJob
         WHERE pg_locks.locktype = 'advisory'
           AND pg_locks.objsubid = 1
           AND pg_locks.classid = ('x' || substr(md5($1 || $2::text), 1, 16))::bit(32)::int
-          AND pg_locks.objid = (('x' || substr(md5($1 || $2::text), 1, 16))::bit(64) << 32)::bit(32)::int
+          AND pg_locks.objid = (('x' || substr(md5($3 || $4::text), 1, 16))::bit(64) << 32)::bit(32)::int
           AND pg_locks.pid = pg_backend_pid()
       SQL
-      self.class.connection.exec_query(query, 'GoodJob::Lockable Owns Advisory Lock?', [[nil, self.class.table_name], [nil, send(self.class.primary_key)]]).any?
+      binds = [[nil, self.class.table_name], [nil, send(self.class.primary_key)], [nil, self.class.table_name], [nil, send(self.class.primary_key)]]
+      self.class.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Owns Advisory Lock?', binds).any?
     end
 
     # Releases all advisory locks on the record that are held by the current
@@ -245,5 +249,14 @@ module GoodJob
       # Made public in Rails 5.2
       self.class.send(:sanitize_sql_for_conditions, *args)
     end
+
+    def pg_or_jdbc_query(query)
+      if Concurrent.on_jruby?
+        # Replace $1 bind parameters with ?
+        query.gsub(/\$\d*/, '?')
+      else
+        query
+      end
+    end
   end
 end

data/lib/good_job/notifier.rb

@@ -9,6 +9,9 @@ module GoodJob # :nodoc:
   # When a message is received, the notifier passes the message to each of its recipients.
   #
   class Notifier
+    # Raised if the Database adapter does not implement LISTEN.
+    AdapterCannotListenError = Class.new(StandardError)
+
     # Default Postgres channel for LISTEN/NOTIFY
     CHANNEL = 'good_job'.freeze
     # Defaults for instance of Concurrent::ThreadPoolExecutor
@@ -94,6 +97,8 @@ module GoodJob # :nodoc:
     # @!visibility private
     # @return [void]
     def listen_observer(_time, _result, thread_error)
+      return if thread_error.is_a? AdapterCannotListenError
+
       if thread_error
         GoodJob.on_thread_error.call(thread_error) if GoodJob.on_thread_error.respond_to?(:call)
         ActiveSupport::Notifications.instrument("notifier_notify_error.good_job", { error: thread_error })
@@ -149,6 +154,8 @@ module GoodJob # :nodoc:
         ActiveRecord::Base.connection_pool.remove(conn)
       end
       pg_conn = ar_conn.raw_connection
+      raise AdapterCannotListenError unless pg_conn.respond_to? :wait_for_notify
+
       pg_conn.async_exec("SET application_name = #{pg_conn.escape_identifier(self.class.name)}").clear
       yield pg_conn
     ensure

data/lib/good_job/poller.rb

@@ -19,6 +19,9 @@ module GoodJob # :nodoc:
     #   @return [array<GoodJob:Poller>]
     cattr_reader :instances, default: [], instance_reader: false
 
+    # Creates GoodJob::Poller from a GoodJob::Configuration instance.
+    # @param configuration [GoodJob::Configuration]
+    # @return [GoodJob::Poller]
     def self.from_configuration(configuration)
       GoodJob::Poller.new(poll_interval: configuration.poll_interval)
     end

data/lib/good_job/railtie.rb

@@ -1,8 +1,12 @@
 module GoodJob
   # Ruby on Rails integration.
   class Railtie < ::Rails::Railtie
-    initializer "good_job.logger" do
-      ActiveSupport.on_load(:good_job) { self.logger = ::Rails.logger }
+    config.good_job = ActiveSupport::OrderedOptions.new
+
+    initializer "good_job.logger" do |_app|
+      ActiveSupport.on_load(:good_job) do
+        self.logger = ::Rails.logger
+      end
       GoodJob::LogSubscriber.attach_to :good_job
     end
 
@@ -15,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:
@@ -8,7 +9,7 @@ module GoodJob # :nodoc:
   # periodically checking for available tasks, executing tasks within a thread,
   # and efficiently scaling active threads.
   #
-  # Every scheduler has a single {Performer} that will execute tasks.
+  # Every scheduler has a single {JobPerformer} that will execute tasks.
   # The scheduler is responsible for calling its performer efficiently across threads managed by an instance of +Concurrent::ThreadPoolExecutor+.
   # If a performer does not have work, the thread will go to sleep.
   # The scheduler maintains an instance of +Concurrent::TimerTask+, which wakes sleeping threads and causes them to check whether the performer has new work.
@@ -22,7 +23,7 @@ module GoodJob # :nodoc:
       max_threads: Configuration::DEFAULT_MAX_THREADS,
       auto_terminate: true,
       idletime: 60,
-      max_queue: -1,
+      max_queue: 1, # ideally zero, but 0 == infinite
       fallback_policy: :discard,
     }.freeze
 
@@ -34,26 +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_query = GoodJob::Job.queue_string(queue_string)
-        parsed = GoodJob::Job.queue_parser(queue_string)
-        job_filter = proc do |state|
-          if parsed[:exclude]
-            parsed[:exclude].exclude?(state[:queue_name])
-          elsif parsed[:include]
-            parsed[:include].include? state[:queue_name]
-          else
-            true
-          end
-        end
-        job_performer = GoodJob::Performer.new(job_query, :perform_with_advisory_lock, name: queue_string, filter: job_filter)
-
-        GoodJob::Scheduler.new(job_performer, max_threads: max_threads)
+        job_performer = GoodJob::JobPerformer.new(queue_string)
+        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
@@ -63,20 +58,24 @@ module GoodJob # :nodoc:
       end
     end
 
-    # @param performer [GoodJob::Performer]
+    # @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.
@@ -91,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
@@ -111,6 +112,7 @@ module GoodJob # :nodoc:
       instrument("scheduler_restart_pools") do
         shutdown(wait: wait) unless shutdown?
         create_pool
+        warm_cache
       end
     end
 
@@ -121,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
@@ -132,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
@@ -144,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
@@ -162,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
@@ -170,10 +226,13 @@ module GoodJob # :nodoc:
       # @return [Integer]
       def ready_worker_count
         synchronize do
-          workers_still_to_be_created = @max_length - @pool.length
-          workers_created_but_waiting = @ready.length
-
-          workers_still_to_be_created + workers_created_but_waiting
+          if Concurrent.on_jruby?
+            @executor.getMaximumPoolSize - @executor.getActiveCount
+          else
+            workers_still_to_be_created = @max_length - @pool.length
+            workers_created_but_waiting = @ready.length
+            workers_still_to_be_created + workers_created_but_waiting
+          end
         end
       end
     end

data/lib/good_job/version.rb

@@ -1,4 +1,4 @@
 module GoodJob
   # GoodJob gem version.
-  VERSION = '1.3.6'.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.3.6
+  version: 1.7.0
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-30 00:00:00.000000000 Z
+date: 2021-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -52,20 +52,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.2
-- !ruby/object:Gem::Dependency
-  name: pg
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
@@ -262,34 +248,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: rails
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rbtrace
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
@@ -399,12 +357,13 @@ files:
 - lib/good_job/cli.rb
 - lib/good_job/configuration.rb
 - lib/good_job/current_execution.rb
+- lib/good_job/daemon.rb
 - lib/good_job/job.rb
+- lib/good_job/job_performer.rb
 - lib/good_job/lockable.rb
 - lib/good_job/log_subscriber.rb
 - lib/good_job/multi_scheduler.rb
 - lib/good_job/notifier.rb
-- lib/good_job/performer.rb
 - lib/good_job/poller.rb
 - lib/good_job/railtie.rb
 - lib/good_job/scheduler.rb
@@ -441,7 +400,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.4
 signing_key:
 specification_version: 4
 summary: A multithreaded, Postgres-based ActiveJob backend for Ruby on Rails

data/lib/good_job/performer.rb

@@ -1,60 +0,0 @@
-module GoodJob
-  #
-  # Performer queries the database for jobs and performs them on behalf of a
-  # {Scheduler}. It mainly functions as glue between a {Scheduler} and the jobs
-  # it should be executing.
-  #
-  # The Performer enforces a callable that does not rely on scoped/closure
-  # variables because they might not be available when executed in a different
-  # thread.
-  #
-  class Performer
-    # @!attribute [r] name
-    # @return [String]
-    #   a meaningful name to identify the performer in logs and for debugging.
-    #   This is usually set to the list of queues the performer will query,
-    #   e.g. +"-transactional_messages,batch_processing"+.
-    attr_reader :name
-
-    # @param target [Object]
-    #   An object that can perform jobs. It must respond to +method_name+ by
-    #   finding and performing jobs and is usually a {Job} query,
-    #   e.g. +GoodJob::Job.where(queue_name: ['queue1', 'queue2'])+.
-    # @param method_name [Symbol]
-    #   The name of a method on +target+ that finds and performs jobs.
-    # @param name [String]
-    #   A name for the performer to be used in logs and for debugging.
-    # @param filter [#call]
-    #   Used to determine whether the performer should be used in GoodJob's
-    #   current state. GoodJob state is a +Hash+ that will be passed as the
-    #   first argument to +filter+ and includes info like the current queue.
-    def initialize(target, method_name, name: nil, filter: nil)
-      @target = target
-      @method_name = method_name
-      @name = name
-      @filter = filter
-    end
-
-    # Find and perform any eligible jobs.
-    def next
-      @target.public_send(@method_name)
-    end
-
-    # Tests whether this performer should be used in GoodJob's current state by
-    # calling the +filter+ callable set in {#initialize}. Always returns +true+
-    # if there is no filter.
-    #
-    # For example, state will be a LISTEN/NOTIFY message that is passed down
-    # from the Notifier to the Scheduler. The Scheduler is able to ask
-    # its performer "does this message relate to you?", and if not, ignore it
-    # to minimize thread wake-ups, database queries, and thundering herds.
-    #
-    # @return [Boolean] whether the performer's {#next} method should be
-    #   called in the current state.
-    def next?(state = {})
-      return true unless @filter.respond_to?(:call)
-
-      @filter.call(state)
-    end
-  end
-end