good_job 1.2.5 → 1.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca2673887424565881a47ad6eaf9300b6281e43c87066f01ceb899b76716d43e
-  data.tar.gz: 6a0f749171316300ebfc7257d1d62efc330092391f026d6f50e20ccda5fee208
+  metadata.gz: d48414f6b03482087018157412c87afb3fdb70929a292294f7db2e14309c31fd
+  data.tar.gz: dd221c88385350fff14b593a6504bc98adeae44893d523c90949332a81eb6fd9
 SHA512:
-  metadata.gz: 4fcef37d707e0d25f44965949abfeba914a4ee9f743ed32498e28df95751f666bdfb942c12049b23d78ff2b52e14465ca1cda2007bfae3541f9f0c53e6f74964
-  data.tar.gz: db7d224567bde1427210638226d5005dd279a2c73c97ff9c19eb40edc523ae7863973cccf7d263a08dcf56ec66fd112a492afa269dad4b12cc70b79027baf296
+  metadata.gz: 77ab00b0cd0772641a402205856d5c03c675dc2edc769e5fed8909636fc2c4a69b033da98a7d0ae09a7ac1fc3f40dd5dc4ff637b3d13e4c290acb9a40bc51ead
+  data.tar.gz: 1777e663267f7e626d7f5ebf5b61b156e83b7bcf9234addddabeb10ef1054c05f8602ca0111c1abe4de9fb53b32aafac4df5d88e1c7c0147e0f1a7cbdc57219d

data/CHANGELOG.md

@@ -1,5 +1,86 @@
 # Changelog
 
+## [v1.3.3](https://github.com/bensheldon/good_job/tree/v1.3.3) (2020-12-01)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.3.2...v1.3.3)
+
+**Merged pull requests:**
+
+- UI: Admin UI with filters and space efficient layout [\#173](https://github.com/bensheldon/good_job/pull/173) ([zealot128](https://github.com/zealot128))
+
+## [v1.3.2](https://github.com/bensheldon/good_job/tree/v1.3.2) (2020-11-12)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.3.1...v1.3.2)
+
+**Fixed bugs:**
+
+- \(bug\) MultiScheduler polling bug [\#171](https://github.com/bensheldon/good_job/issues/171)
+- MultiScheduler should delegate to all schedulers when state is nil [\#172](https://github.com/bensheldon/good_job/pull/172) ([bensheldon](https://github.com/bensheldon))
+
+## [v1.3.1](https://github.com/bensheldon/good_job/tree/v1.3.1) (2020-11-01)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.3.0...v1.3.1)
+
+**Implemented enhancements:**
+
+- Extract polling from scheduler into Polling object [\#128](https://github.com/bensheldon/good_job/issues/128)
+- Format serialized params to ease reading [\#170](https://github.com/bensheldon/good_job/pull/170) ([morgoth](https://github.com/morgoth))
+
+**Fixed bugs:**
+
+- Don't disconnect a nil activerecord connection [\#161](https://github.com/bensheldon/good_job/pull/161) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- Propose addition of GoodJob to queue-shootout benchmarks [\#40](https://github.com/bensheldon/good_job/issues/40)
+
+**Merged pull requests:**
+
+- Ensure Rails is a development dependency [\#169](https://github.com/bensheldon/good_job/pull/169) ([bensheldon](https://github.com/bensheldon))
+- Fix Ruby 2.7 GH action by setting default bundler explicitly [\#166](https://github.com/bensheldon/good_job/pull/166) ([bensheldon](https://github.com/bensheldon))
+- Cache ruby version explicitly in Github Action [\#165](https://github.com/bensheldon/good_job/pull/165) ([bensheldon](https://github.com/bensheldon))
+- Update development dependencies, rubocop [\#164](https://github.com/bensheldon/good_job/pull/164) ([bensheldon](https://github.com/bensheldon))
+- Fix intended constant hierarchy of GoodJob::Scheduler::ThreadPoolExecutor [\#158](https://github.com/bensheldon/good_job/pull/158) ([bensheldon](https://github.com/bensheldon))
+- Add bin/test\_app executable for Rails debugging [\#157](https://github.com/bensheldon/good_job/pull/157) ([bensheldon](https://github.com/bensheldon))
+- Extract Scheduler polling behavior to its own object [\#152](https://github.com/bensheldon/good_job/pull/152) ([bensheldon](https://github.com/bensheldon))
+
+## [v1.3.0](https://github.com/bensheldon/good_job/tree/v1.3.0) (2020-10-03)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.2.6...v1.3.0)
+
+**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)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.2.5...v1.2.6)
+
+**Implemented enhancements:**
+
+- Preserve only failed jobs [\#136](https://github.com/bensheldon/good_job/issues/136)
+- Add `GoodJob.preserve\_job\_records = :on\_unhandled\_error` option to only preserve jobs that errored [\#145](https://github.com/bensheldon/good_job/pull/145) ([morgoth](https://github.com/morgoth))
+
+**Fixed bugs:**
+
+- Fix LogSubscriber notifications for finished\_timer\_task and finished\_job\_task [\#148](https://github.com/bensheldon/good_job/pull/148) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- run-once guarantee? [\#151](https://github.com/bensheldon/good_job/issues/151)
+
+**Merged pull requests:**
+
+- Add info how to setup basic auth for engine [\#153](https://github.com/bensheldon/good_job/pull/153) ([morgoth](https://github.com/morgoth))
+- Add documentation for Dashboard Rails::Engine [\#149](https://github.com/bensheldon/good_job/pull/149) ([bensheldon](https://github.com/bensheldon))
+- Style cleanup to Job error handling [\#147](https://github.com/bensheldon/good_job/pull/147) ([bensheldon](https://github.com/bensheldon))
+- Replace gerund titles in Readme [\#146](https://github.com/bensheldon/good_job/pull/146) ([bensheldon](https://github.com/bensheldon))
+- Only allow Scheduler to be initialized with max\_threads and poll\_interval; remove full access to pool and timer\_task options [\#137](https://github.com/bensheldon/good_job/pull/137) ([bensheldon](https://github.com/bensheldon))
+
 ## [v1.2.5](https://github.com/bensheldon/good_job/tree/v1.2.5) (2020-09-17)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v1.2.4...v1.2.5)
@@ -7,10 +88,15 @@
 **Implemented enhancements:**
 
 - Use Zeitwerk for auto-loading [\#87](https://github.com/bensheldon/good_job/issues/87)
+- Spike on data dashboard; pull in full Bootstrap CSS and JS [\#131](https://github.com/bensheldon/good_job/pull/131) ([bensheldon](https://github.com/bensheldon))
 
 **Fixed bugs:**
 
 - `poll-interval=-1` does not disable polling as intended [\#133](https://github.com/bensheldon/good_job/issues/133)
+- Update Gemspec to reflect that GoodJob is not compatible with Rails 5.1 [\#143](https://github.com/bensheldon/good_job/pull/143) ([bensheldon](https://github.com/bensheldon))
+- Prevent jobs hanging [\#141](https://github.com/bensheldon/good_job/pull/141) ([morgoth](https://github.com/morgoth))
+- Add explicit require\_paths to gemspec for engine [\#134](https://github.com/bensheldon/good_job/pull/134) ([bensheldon](https://github.com/bensheldon))
+- Use `connection.quote\_table\_name` and add spacing for SQL concatenation [\#124](https://github.com/bensheldon/good_job/pull/124) ([bensheldon](https://github.com/bensheldon))
 
 **Closed issues:**
 
@@ -21,17 +107,12 @@
 **Merged pull requests:**
 
 - Test GoodJob against Rails HEAD [\#144](https://github.com/bensheldon/good_job/pull/144) ([bensheldon](https://github.com/bensheldon))
-- Update Gemspec to reflect that GoodJob is not compatible with Rails 5.1 [\#143](https://github.com/bensheldon/good_job/pull/143) ([bensheldon](https://github.com/bensheldon))
 - Drop Ruby 2.4 support [\#142](https://github.com/bensheldon/good_job/pull/142) ([morgoth](https://github.com/morgoth))
-- Prevent jobs hanging [\#141](https://github.com/bensheldon/good_job/pull/141) ([morgoth](https://github.com/morgoth))
 - Remove arguments from perform method [\#140](https://github.com/bensheldon/good_job/pull/140) ([morgoth](https://github.com/morgoth))
 - Extract "execute" method to reduce "perform" method complexity [\#138](https://github.com/bensheldon/good_job/pull/138) ([morgoth](https://github.com/morgoth))
 - Correct example on how to configure multiple queues by command line. [\#135](https://github.com/bensheldon/good_job/pull/135) ([morgoth](https://github.com/morgoth))
-- Add explicit require\_paths to gemspec for engine [\#134](https://github.com/bensheldon/good_job/pull/134) ([bensheldon](https://github.com/bensheldon))
-- Spike on data dashboard; pull in full Bootstrap CSS and JS [\#131](https://github.com/bensheldon/good_job/pull/131) ([bensheldon](https://github.com/bensheldon))
 - Update ActionMailer Job class, to match the default [\#130](https://github.com/bensheldon/good_job/pull/130) ([morgoth](https://github.com/morgoth))
 - Add initial Engine scaffold [\#125](https://github.com/bensheldon/good_job/pull/125) ([bensheldon](https://github.com/bensheldon))
-- Use `connection.quote\_table\_name` and add spacing for SQL concatenation [\#124](https://github.com/bensheldon/good_job/pull/124) ([bensheldon](https://github.com/bensheldon))
 - Zeitwerk Loader Implementation [\#123](https://github.com/bensheldon/good_job/pull/123) ([gadimbaylisahil](https://github.com/gadimbaylisahil))
 - Update code-level documentation [\#111](https://github.com/bensheldon/good_job/pull/111) ([bensheldon](https://github.com/bensheldon))
 
@@ -42,6 +123,11 @@
 **Implemented enhancements:**
 
 - Add environment variable to mirror `cleanup\_preserved\_jobs --before-seconds-ago=SECONDS` [\#110](https://github.com/bensheldon/good_job/issues/110)
+- Allow env variable config for cleanups [\#114](https://github.com/bensheldon/good_job/pull/114) ([gadimbaylisahil](https://github.com/gadimbaylisahil))
+
+**Fixed bugs:**
+
+- Better table name detection for Job queries [\#119](https://github.com/bensheldon/good_job/pull/119) ([gadimbaylisahil](https://github.com/gadimbaylisahil))
 
 **Closed issues:**
 
@@ -52,9 +138,7 @@
 **Merged pull requests:**
 
 - Remove unused PgLocks class [\#120](https://github.com/bensheldon/good_job/pull/120) ([gadimbaylisahil](https://github.com/gadimbaylisahil))
-- Better table name detection for Job queries [\#119](https://github.com/bensheldon/good_job/pull/119) ([gadimbaylisahil](https://github.com/gadimbaylisahil))
 - Fix readme CommandLine option links [\#115](https://github.com/bensheldon/good_job/pull/115) ([gadimbaylisahil](https://github.com/gadimbaylisahil))
-- Allow env variable config for cleanups [\#114](https://github.com/bensheldon/good_job/pull/114) ([gadimbaylisahil](https://github.com/gadimbaylisahil))
 - Have YARD render markdown files with GFM \(Github Flavored Markdown\) [\#113](https://github.com/bensheldon/good_job/pull/113) ([bensheldon](https://github.com/bensheldon))
 - Add markdownlint to lint readme [\#109](https://github.com/bensheldon/good_job/pull/109) ([bensheldon](https://github.com/bensheldon))
 - Remove unused method in PgLocks [\#107](https://github.com/bensheldon/good_job/pull/107) ([gadimbaylisahil](https://github.com/gadimbaylisahil))
@@ -71,6 +155,7 @@
 **Merged pull requests:**
 
 - stop depending on all rails libs [\#104](https://github.com/bensheldon/good_job/pull/104) ([thilo](https://github.com/thilo))
+- Use more ActiveRecord in Lockable and not connection.execute [\#102](https://github.com/bensheldon/good_job/pull/102) ([bensheldon](https://github.com/bensheldon))
 
 ## [v1.2.2](https://github.com/bensheldon/good_job/tree/v1.2.2) (2020-08-27)
 
@@ -91,7 +176,6 @@
 
 **Merged pull requests:**
 
-- 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))
@@ -354,7 +438,6 @@
 - Add pg gem as explicit dependency [\#13](https://github.com/bensheldon/good_job/pull/13) ([bensheldon](https://github.com/bensheldon))
 - Bump nokogiri from 1.10.7 to 1.10.9 [\#12](https://github.com/bensheldon/good_job/pull/12) ([dependabot[bot]](https://github.com/apps/dependabot))
 - Add Appraisal with tests for Rails 5.1, 5.2, 6.0 [\#11](https://github.com/bensheldon/good_job/pull/11) ([bensheldon](https://github.com/bensheldon))
-- Use Rails.logger and ActiveSupport::Notifications for logging instead of puts [\#10](https://github.com/bensheldon/good_job/pull/10) ([bensheldon](https://github.com/bensheldon))
 
 ## [v0.2.0](https://github.com/bensheldon/good_job/tree/v0.2.0) (2020-03-06)
 
@@ -362,6 +445,7 @@
 
 **Merged pull requests:**
 
+- Use Rails.logger and ActiveSupport::Notifications for logging instead of puts [\#10](https://github.com/bensheldon/good_job/pull/10) ([bensheldon](https://github.com/bensheldon))
 - Remove minitest files [\#9](https://github.com/bensheldon/good_job/pull/9) ([bensheldon](https://github.com/bensheldon))
 - Use scheduled\_at and priority for scheduling [\#8](https://github.com/bensheldon/good_job/pull/8) ([bensheldon](https://github.com/bensheldon))
 - Create Github Action workflow for PRs and Issues [\#7](https://github.com/bensheldon/good_job/pull/7) ([bensheldon](https://github.com/bensheldon))

data/README.md

@@ -1,5 +1,8 @@
 # GoodJob
 
+[![Gem Version](https://badge.fury.io/rb/good_job.svg)](https://rubygems.org/gems/good_job)
+[![Test Status](https://github.com/bensheldon/good_job/workflows/Test/badge.svg)](https://github.com/bensheldon/good_job/actions)
+
 GoodJob is a multithreaded, Postgres-based, ActiveJob backend for Ruby on Rails.
 
 **Inspired by [Delayed::Job](https://github.com/collectiveidea/delayed_job) and [Que](https://github.com/que-rb/que), GoodJob is designed for maximum compatibility with Ruby on Rails, ActiveJob, and Postgres to be simple and performant for most workloads.**
@@ -33,7 +36,8 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
         - [`good_job cleanup_preserved_jobs`](#good_job-cleanup_preserved_jobs)
     - [Adapter options](#adapter-options)
     - [Global options](#global-options)
-- [Going deeper](#going-deeper)
+    - [Dashboard](#dashboard)
+- [Go deeper](#go-deeper)
     - [Exceptions, retries, and reliability](#exceptions-retries-and-reliability)
         - [Exceptions](#exceptions)
         - [Retries](#retries)
@@ -41,12 +45,12 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
     - [Timeouts](#timeouts)
     - [Optimize queues, threads, and processes](#optimize-queues-threads-and-processes)
     - [Database connections](#database-connections)
-    - [Executing jobs async / in-process](#executing-jobs-async--in-process)
-    - [Migrating to GoodJob from a different ActiveJob backend](#migrating-to-goodjob-from-a-different-activejob-backend)
-    - [Monitoring and preserving worked jobs](#monitoring-and-preserving-worked-jobs)
-- [Contributing](#contributing)
+    - [Execute jobs async / in-process](#execute-jobs-async--in-process)
+    - [Migrate to GoodJob from a different ActiveJob backend](#migrate-to-goodjob-from-a-different-activejob-backend)
+    - [Monitor and preserve worked jobs](#monitor-and-preserve-worked-jobs)
+- [Contribute](#contribute)
     - [Gem development](#gem-development)
-    - [Releasing](#releasing)
+    - [Release](#release)
 - [License](#license)
 
 ## Set up
@@ -209,7 +213,7 @@ Good Job’s general behavior can also be configured via several attributes dire
 
 - **`GoodJob.logger`** ([Rails Logger](https://api.rubyonrails.org/classes/ActiveSupport/Logger.html)) lets you set a custom logger for GoodJob. It should be an instance of a Rails `Logger`.
 - **`GoodJob.preserve_job_records`** (boolean) keeps job records in your database even after jobs are completed. (Default: `false`)
-- **`GoodJob.reperform_jobs_on_standard_error`** (boolean) causes jobs to be re-queued and retried if they raise an instance of `StandardError`. Instances of `Exception`, like SIGINT, will *always* be retried, regardless of this attribute’s value. (Default: `true`)
+- **`GoodJob.retry_on_unhandled_error`** (boolean) causes jobs to be re-queued and retried if they raise an instance of `StandardError`. Instances of `Exception`, like SIGINT, will *always* be retried, regardless of this attribute’s value. (Default: `true`)
 - **`GoodJob.on_thread_error`** (proc, lambda, or callable) will be called when an Exception. It can be useful for logging errors to bug tracking services, like Sentry or Airbrake.
 
 You’ll generally want to configure these in `config/initializers/good_job.rb`, like so:
@@ -217,11 +221,56 @@ You’ll generally want to configure these in `config/initializers/good_job.rb`,
 ```ruby
 # config/initializers/good_job.rb
 GoodJob.preserve_job_records = true
-GoodJob.reperform_jobs_on_standard_error = false
+GoodJob.retry_on_unhandled_error = false
 GoodJob.on_thread_error = -> (exception) { Raven.capture_exception(exception) }
 ```
 
-## Going deeper
+### Dashboard
+
+_🚧 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`.
+
+1. Explicitly require the Engine code at the top of your `config/application.rb` file, immediately after Rails is required. This is necessary because the mountable engine is an optional feature of GoodJob.
+
+    ```ruby
+    # config/application.rb
+    require_relative 'boot'
+
+    require 'rails/all'
+    require 'good_job/engine' # <= Add this line
+    # ...
+    ```
+
+1. Mount the engine in your `config/routes.rb` file. The following will mount it at `http://example.com/good_job`.
+
+    ```ruby
+    # config/routes.rb
+    # ...
+    mount GoodJob::Engine => 'good_job'
+    ```
+
+    Because jobs can potentially contain sensitive information, you should authorize access. For example, using Devise's `authenticate` helper, that might look like:
+
+    ```ruby
+    # config/routes.rb
+    # ...
+    authenticate :user, ->(user) { user.admin? } do
+      mount GoodJob::Engine => 'good_job'
+    end
+    ```
+
+    Another option is using basic auth like this:
+
+    ```ruby
+    # config/initializers/good_job.rb
+    GoodJob::Engine.middleware.use(Rack::Auth::Basic) do |username, password|
+      ActiveSupport::SecurityUtils.secure_compare(Rails.application.credentials.good_job_username, username) &&
+        ActiveSupport::SecurityUtils.secure_compare(Rails.application.credentials.good_job_password, password)
+    end
+    ```
+
+## Go deeper
 
 ### Exceptions, retries, and reliability
 
@@ -255,7 +304,7 @@ When using `retry_on` with _a limited number of retries_, the final exception wi
 
 ```ruby
 # config/initializers/good_job.rb
-GoodJob.reperform_jobs_on_standard_error = false
+GoodJob.retry_on_unhandled_error = false
 ```
 
 Alternatively, pass a block to `retry_on` to handle the final exception instead of raising it to GoodJob:
@@ -380,7 +429,7 @@ Each GoodJob execution thread requires its own database connection that is autom
 pool: <%= [ENV.fetch("RAILS_MAX_THREADS", 5).to_i, ENV.fetch("GOOD_JOB_MAX_THREADS", 4).to_i].max %>
 ```
 
-### Executing jobs async / in-process
+### Execute jobs async / in-process
 
 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:
 
@@ -431,7 +480,7 @@ Depending on your application configuration, you may need to take additional ste
 
   GoodJob is compatible with Puma's `preload_app!` method.
 
-### Migrating to GoodJob from a different ActiveJob backend
+### Migrate to GoodJob from a different ActiveJob backend
 
 If your application is already using an ActiveJob backend, you will need to install GoodJob to enqueue and perform newly created jobs _and_ finish performing pre-existing jobs on the previous backend.
 
@@ -455,7 +504,7 @@ If your application is already using an ActiveJob backend, you will need to inst
 
 1. Once you are confident that no unperformed jobs remain in the previous ActiveJob backend, code and configuration for that backend can be completely removed.
 
-### Monitoring and preserving worked jobs
+### Monitor and preserve worked jobs
 
 GoodJob is fully instrumented with [`ActiveSupport::Notifications`](https://edgeguides.rubyonrails.org/active_support_instrumentation.html#introduction-to-instrumentation).
 
@@ -482,7 +531,7 @@ It is also necessary to delete these preserved jobs from the database after a ce
     $ bundle exec good_job cleanup_preserved_jobs --before-seconds-ago=86400
     ```
 
-## Contributing
+## Contribute
 
 Contributions are welcomed and appreciated 🙏
 
@@ -527,7 +576,7 @@ $ bundle install
 # => Using good_job 0.1.0 from https://github.com/bensheldon/good_job.git (at /Users/You/Projects/good_job@dc57fb0)
 ```
 
-### Releasing
+### Release
 
 Package maintainers can release this gem by running:
 

data/engine/app/controllers/good_job/dashboards_controller.rb

@@ -1,10 +1,59 @@
 module GoodJob
   class DashboardsController < GoodJob::BaseController
-    def index
-      @jobs = GoodJob::Job.display_all(after_scheduled_at: params[:after_scheduled_at], after_id: params[:after_id])
+    class JobFilter
+      attr_accessor :params
+
+      def initialize(params)
+        @params = params
+      end
+
+      def last
+        @_last ||= jobs.last
+      end
+
+      def jobs
+        sql = GoodJob::Job.display_all(after_scheduled_at: params[:after_scheduled_at], after_id: params[:after_id])
                           .limit(params.fetch(:limit, 10))
+        if params[:job_class] # rubocop:disable Style/IfUnlessModifier
+          sql = sql.where("serialized_params->>'job_class' = ?", params[:job_class])
+        end
+        if params[:state]
+          case params[:state]
+          when 'finished'
+            sql = sql.finished
+          when 'unfinished'
+            sql = sql.unfinished
+          when 'errors'
+            sql = sql.where.not(error: nil)
+          end
+        end
+        sql
+      end
+
+      def states
+        {
+          'finished' => GoodJob::Job.finished.count,
+          'unfinished' => GoodJob::Job.unfinished.count,
+          'errors' => GoodJob::Job.where.not(error: nil).count,
+        }
+      end
+
+      def job_classes
+        GoodJob::Job.group("serialized_params->>'job_class'").count
+      end
+
+      def to_query(override)
+        {
+          state: params[:state],
+          job_class: params[:job_class],
+        }.merge(override).delete_if { |_, v| v.nil? }.to_query
+      end
+    end
+
+    def index
+      @filter = JobFilter.new(params)
 
-      job_data = GoodJob::Job.connection.exec_query Arel.sql(<<~SQL)
+      job_data = GoodJob::Job.connection.exec_query Arel.sql(<<~SQL.squish)
         SELECT *
         FROM generate_series(
           date_trunc('hour', NOW() - '1 day'::interval),

data/engine/app/views/good_job/dashboards/index.html.erb

@@ -2,13 +2,36 @@
   <%= render 'shared/chart', chart_data: @chart %>
 </div>
 
-<% if @jobs.present? %>
-  <%= render 'shared/jobs_table', jobs: @jobs %>
+<div class='card mb-2'>
+  <div class='card-body d-flex flex-wrap'>
+    <div class='mr-4'>
+      <small>Filter by job class</small>
+      <br>
+      <% @filter.job_classes.each do |name, count| %>
+        <a href='<%= request.path + "?#{@filter.to_query(job_class: name)}" %>' class='btn btn-sm btn-outline-secondary <%= "active" if params[:job_class] == name %>'>
+          <%= name %> (<%= count %>)
+        </a>
+      <% end %>
+    </div>
+    <div>
+      <small>Filter by state</small>
+      <br>
+      <% @filter.states.each do |name, count| %>
+        <a href='<%= request.path + "?#{@filter.to_query(state: name)}" %>' class='btn btn-sm btn-outline-secondary <%= "active" if params[:state] == name %>'>
+          <%= name %> (<%= count %>)
+        </a>
+      <% end %>
+    </div>
+  </div>
+</div>
+
+<% if @filter.jobs.present? %>
+  <%= render 'shared/jobs_table', jobs: @filter.jobs %>
 
   <nav aria-label="Job pagination">
     <ul class="pagination">
       <li class="page-item">
-        <%= link_to({ after_scheduled_at: (@jobs.last.scheduled_at || @jobs.last.created_at), after_id: @jobs.last.id }, class: "page-link") do %>
+        <%= link_to({ after_scheduled_at: (@filter.last.scheduled_at || @filter.last.created_at), after_id: @filter.last.id }, class: "page-link") do %>
           Next jobs <span aria-hidden="true">&raquo;</span>
         <% end %>
       </li>

data/engine/app/views/layouts/good_job/base.html.erb

@@ -18,7 +18,7 @@
 </head>
 <body>
   <nav class="navbar navbar-expand-lg navbar-light bg-light">
-    <div class="container">
+    <div class="container-fluid">
       <%= link_to "GoodJob 👍", root_path, class: 'navbar-brand mb-0 h1' %>
       <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarSupportedContent" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
         <span class="navbar-toggler-icon"></span>
@@ -27,23 +27,34 @@
       <div class="collapse navbar-collapse" id="navbarSupportedContent">
         <ul class="navbar-nav mr-auto">
           <li class="nav-item">
-            <%= link_to "All jobs", root_path, class: ["nav-link", ("active" if current_page?(root_path))] %>
-          </li>
-          <li class="nav-item">
-            <%= link_to "Upcoming Jobs", 'todo', class: ["nav-link", ("active" if current_page?('todo'))] %>
-          </li>
-          <li class="nav-item">
-            <%= link_to "Finished Jobs", 'todo', class: ["nav-link", ("active" if current_page?('todo'))] %>
-          </li>
-          <li class="nav-item">
-            <%= link_to "Errored Jobs", 'todo', class: ["nav-link", ("active" if current_page?('todo'))] %>
+            <%= link_to root_path, class: ["nav-link", ("active" if current_page?(root_path))] do %>
+              All jobs <span class="badge badge-secondary">More views coming soon</span>
+            <% end %>
           </li>
+
+          <!-- Coming Soon
+            <li class="nav-item">
+              <%= link_to "Upcoming Jobs", 'todo', class: ["nav-link", ("active" if current_page?('todo'))] %>
+            </li>
+            <li class="nav-item">
+              <%= link_to "Finished Jobs", 'todo', class: ["nav-link", ("active" if current_page?('todo'))] %>
+            </li>
+            <li class="nav-item">
+              <%= link_to "Errored Jobs", 'todo', class: ["nav-link", ("active" if current_page?('todo'))] %>
+            </li>
+          -->
         </ul>
       </div>
     </div>
   </nav>
 
-  <div class="container">
+  <div class="container-fluid">
+    <div class="card border-warning text-dark my-3">
+      <div class="card-body">
+        <p class="card-text">🚧 GoodJob's dashboard is a work in progress. Please contribute ideas and code on <a href="https://github.com/bensheldon/good_job/issues" target="_blank" rel="nofollow noopener noreferrer">Github</a>.</p>
+      </div>
+    </div>
+
     <%= yield %>
   </div>
 </body>

data/engine/app/views/shared/_jobs_table.erb

@@ -1,13 +1,13 @@
 <div class="table-responsive">
-  <table class="table table-bordered table-hover">
+  <table class="table table-bordered table-hover table-sm">
     <thead>
       <th>GoodJob ID</th>
       <th>ActiveJob ID</th>
       <th>Job Class</th>
       <th>Queue</th>
       <th>Scheduled At</th>
-      <th>ActiveJob Params</th>
       <th>Error</th>
+      <th>ActiveJob Params</th>
     </thead>
     <tbody>
       <% jobs.each do |job| %>
@@ -17,8 +17,8 @@
           <td><%= job.serialized_params['job_class'] %></td>
           <td><%= job.queue_name %></td>
           <td><%= job.scheduled_at || job.created_at %></td>
-          <td><%= job.serialized_params %></td>
           <td><%= job.error %></td>
+          <td><pre><%= JSON.pretty_generate(job.serialized_params) %></pre></td>
         </tr>
       <% end %>
     </tbody>

data/lib/good_job.rb

@@ -32,18 +32,35 @@ module GoodJob
   #   Whether to preserve job records in the database after they have finished (default: +false+).
   #   By default, GoodJob deletes job records after the job is completed successfully.
   #   If you want to preserve jobs for latter inspection, set this to +true+.
+  #   If you want to preserve only jobs that finished with error for latter inspection, set this to +:on_unhandled_error+.
   #   If +true+, you will need to clean out jobs using the +good_job cleanup_preserved_jobs+ CLI command.
   #   @return [Boolean]
   mattr_accessor :preserve_job_records, default: false
 
-  # @!attribute [rw] reperform_jobs_on_standard_error
+  # @!attribute [rw] retry_on_unhandled_error
   #   @!scope class
   #   Whether to re-perform a job when a type of +StandardError+ is raised to GoodJob (default: +true+).
   #   If +true+, causes jobs to be re-queued and retried if they raise an instance of +StandardError+.
   #   If +false+, jobs will be discarded or marked as finished if they raise an instance of +StandardError+.
   #   Instances of +Exception+, like +SIGINT+, will *always* be retried, regardless of this attribute's value.
   #   @return [Boolean]
-  mattr_accessor :reperform_jobs_on_standard_error, default: true
+  mattr_accessor :retry_on_unhandled_error, default: true
+
+  # @deprecated Use {GoodJob#retry_on_unhandled_error} instead.
+  def self.reperform_jobs_on_standard_error
+    ActiveSupport::Deprecation.warn(
+      "Calling 'GoodJob.reperform_jobs_on_standard_error' is deprecated. Please use 'retry_on_unhandled_error'"
+    )
+    retry_on_unhandled_error
+  end
+
+  # @deprecated Use {GoodJob#retry_on_unhandled_error=} instead.
+  def self.reperform_jobs_on_standard_error=(value)
+    ActiveSupport::Deprecation.warn(
+      "Setting 'GoodJob.reperform_jobs_on_standard_error=' is deprecated. Please use 'retry_on_unhandled_error='"
+    )
+    self.retry_on_unhandled_error = value
+  end
 
   # @!attribute [rw] on_thread_error
   #   @!scope class

data/lib/good_job/adapter.rb

@@ -43,8 +43,10 @@ module GoodJob
 
       if @execution_mode == :async # rubocop:disable Style/GuardClause
         @notifier = notifier || GoodJob::Notifier.new
+        @poller = GoodJob::Poller.new(poll_interval: configuration.poll_interval)
         @scheduler = scheduler || GoodJob::Scheduler.from_configuration(configuration)
         @notifier.recipients << [@scheduler, :create_thread]
+        @poller.recipients << [@scheduler, :create_thread]
       end
     end
 
@@ -88,6 +90,7 @@ module GoodJob
     # @return [void]
     def shutdown(wait: true)
       @notifier&.shutdown(wait: wait)
+      @poller&.shutdown(wait: wait)
       @scheduler&.shutdown(wait: wait)
     end
 

data/lib/good_job/cli.rb

@@ -42,14 +42,16 @@ module GoodJob
     method_option :poll_interval,
                   type: :numeric,
                   banner: 'SECONDS',
-                  desc: "Interval between polls for available jobs in seconds (env var: GOOD_JOB_POLL_INTERVAL, default: 1)"
+                  desc: "Interval between polls for available jobs in seconds (env var: GOOD_JOB_POLL_INTERVAL, default: 5)"
     def start
       set_up_application!
+      configuration = GoodJob::Configuration.new(options)
 
       notifier = GoodJob::Notifier.new
-      configuration = GoodJob::Configuration.new(options)
+      poller = GoodJob::Poller.new(poll_interval: configuration.poll_interval)
       scheduler = GoodJob::Scheduler.from_configuration(configuration)
       notifier.recipients << [scheduler, :create_thread]
+      poller.recipients << [scheduler, :create_thread]
 
       @stop_good_job_executable = false
       %w[INT TERM].each do |signal|
@@ -62,6 +64,7 @@ module GoodJob
       end
 
       notifier.shutdown
+      poller.shutdown
       scheduler.shutdown
     end
 

data/lib/good_job/configuration.rb

@@ -5,6 +5,13 @@ module GoodJob
   # set options to get the final values for each option.
   #
   class Configuration
+    # 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 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]
@@ -69,7 +76,7 @@ module GoodJob
         options[:max_threads] ||
         env['GOOD_JOB_MAX_THREADS'] ||
         env['RAILS_MAX_THREADS'] ||
-        ActiveRecord::Base.connection_pool.size
+        DEFAULT_MAX_THREADS
       ).to_i
     end
 
@@ -92,7 +99,7 @@ module GoodJob
       (
         options[:poll_interval] ||
         env['GOOD_JOB_POLL_INTERVAL'] ||
-        1
+        DEFAULT_POLL_INTERVAL
       ).to_i
     end
 
@@ -100,7 +107,7 @@ module GoodJob
       (
         options[:before_seconds_ago] ||
         env['GOOD_JOB_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO'] ||
-        24 * 60 * 60
+        DEFAULT_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO
       ).to_i
     end
   end

data/lib/good_job/job.rb

@@ -189,37 +189,31 @@ module GoodJob
       self.performed_at = Time.current
       save! if GoodJob.preserve_job_records
 
-      result, rescued_error = execute
+      result, unhandled_error = execute
 
-      retry_or_discard_error = GoodJob::CurrentExecution.error_on_retry ||
-                               GoodJob::CurrentExecution.error_on_discard
-
-      error = nil
-      if rescued_error
-        error = rescued_error
-      elsif result.is_a?(Exception)
-        error = result
+      result_error = nil
+      if result.is_a?(Exception)
+        result_error = result
         result = nil
-      elsif retry_or_discard_error
-        error = retry_or_discard_error
       end
 
-      error_message = "#{error.class}: #{error.message}" if error
-      self.error = error_message
+      job_error = unhandled_error ||
+                  result_error ||
+                  GoodJob::CurrentExecution.error_on_retry ||
+                  GoodJob::CurrentExecution.error_on_discard
 
-      if rescued_error && GoodJob.reperform_jobs_on_standard_error
+      self.error = "#{job_error.class}: #{job_error.message}" if job_error
+
+      if unhandled_error && GoodJob.retry_on_unhandled_error
         save!
-      else
+      elsif GoodJob.preserve_job_records == true || (unhandled_error && GoodJob.preserve_job_records == :on_unhandled_error)
         self.finished_at = Time.current
-
-        if GoodJob.preserve_job_records
-          save!
-        else
-          destroy!
-        end
+        save!
+      else
+        destroy!
       end
 
-      [result, error]
+      [result, job_error]
     end
 
     private

data/lib/good_job/lockable.rb

@@ -56,7 +56,7 @@ module GoodJob
       # @example Get the records that have a session awaiting a lock:
       #   MyLockableRecord.joins_advisory_locks.where("pg_locks.granted = ?", false)
       scope :joins_advisory_locks, (lambda do
-        join_sql = <<~SQL
+        join_sql = <<~SQL.squish
           LEFT JOIN pg_locks ON pg_locks.locktype = 'advisory'
             AND pg_locks.objsubid = 1
             AND pg_locks.classid = ('x' || substr(md5(:table_name || #{quoted_table_name}.#{quoted_primary_key}::text), 1, 16))::bit(32)::int
@@ -140,10 +140,10 @@ module GoodJob
     # all remaining locks).
     # @return [Boolean] whether the lock was acquired.
     def advisory_lock
-      where_sql = <<~SQL
+      where_sql = <<~SQL.squish
         pg_try_advisory_lock(('x' || substr(md5(:table_name || :id::text), 1, 16))::bit(64)::bigint)
       SQL
-      self.class.unscoped.where(where_sql, { table_name: self.class.table_name, id: send(self.class.primary_key) }).exists?
+      self.class.unscoped.exists?([where_sql, { table_name: self.class.table_name, id: send(self.class.primary_key) }])
     end
 
     # Releases an advisory lock on this record if it is locked by this database
@@ -151,10 +151,10 @@ module GoodJob
     # {#advisory_unlock} and {#advisory_lock} the same number of times.
     # @return [Boolean] whether the lock was released.
     def advisory_unlock
-      where_sql = <<~SQL
+      where_sql = <<~SQL.squish
         pg_advisory_unlock(('x' || substr(md5(:table_name || :id::text), 1, 16))::bit(64)::bigint)
       SQL
-      self.class.unscoped.where(where_sql, { table_name: self.class.table_name, id: send(self.class.primary_key) }).exists?
+      self.class.unscoped.exists?([where_sql, { table_name: self.class.table_name, id: send(self.class.primary_key) }])
     end
 
     # Acquires an advisory lock on this record or raises
@@ -191,13 +191,13 @@ module GoodJob
     # Tests whether this record has an advisory lock on it.
     # @return [Boolean]
     def advisory_locked?
-      self.class.unscoped.advisory_locked.where(id: send(self.class.primary_key)).exists?
+      self.class.unscoped.advisory_locked.exists?(id: send(self.class.primary_key))
     end
 
     # Tests whether this record is locked by the current database session.
     # @return [Boolean]
     def owns_advisory_lock?
-      self.class.unscoped.owns_advisory_locked.where(id: send(self.class.primary_key)).exists?
+      self.class.unscoped.owns_advisory_locked.exists?(id: send(self.class.primary_key))
     end
 
     # Releases all advisory locks on the record that are held by the current

data/lib/good_job/log_subscriber.rb

@@ -25,8 +25,7 @@ module GoodJob
     end
 
     # @macro notification_responder
-    def timer_task_finished(event)
-      # FIXME: This method does not match any good_job notifications.
+    def finished_timer_task(event)
       exception = event.payload[:error]
       return unless exception
 
@@ -36,8 +35,7 @@ module GoodJob
     end
 
     # @macro notification_responder
-    def job_finished(event)
-      # FIXME: This method does not match any good_job notifications.
+    def finished_job_task(event)
       exception = event.payload[:error]
       return unless exception
 
@@ -47,14 +45,13 @@ module GoodJob
     end
 
     # @macro notification_responder
-    def scheduler_create_pools(event)
+    def scheduler_create_pool(event)
       max_threads = event.payload[:max_threads]
-      poll_interval = event.payload[:poll_interval]
       performer_name = event.payload[:performer_name]
       process_id = event.payload[:process_id]
 
       info(tags: [process_id]) do
-        "GoodJob started scheduler with queues=#{performer_name} max_threads=#{max_threads} poll_interval=#{poll_interval}."
+        "GoodJob started scheduler with queues=#{performer_name} max_threads=#{max_threads}."
       end
     end
 
@@ -168,12 +165,12 @@ module GoodJob
       # @return [Logger]
       def logger
         @_logger ||= begin
-                      logger = Logger.new(StringIO.new)
-                      loggers.each do |each_logger|
-                        logger.extend(ActiveSupport::Logger.broadcast(each_logger))
-                      end
-                      logger
-                    end
+          logger = Logger.new(StringIO.new)
+          loggers.each do |each_logger|
+            logger.extend(ActiveSupport::Logger.broadcast(each_logger))
+          end
+          logger
+        end
       end
 
       # Reset {LogSubscriber.logger} and force it to rebuild a new shortcut to
@@ -194,11 +191,12 @@ module GoodJob
     # @return [void]
     def tag_logger(*tags, &block)
       tags = tags.dup.unshift("GoodJob").compact
+      good_job_tag = ["ActiveJob"].freeze
 
       self.class.loggers.inject(block) do |inner, each_logger|
         if each_logger.respond_to?(:tagged)
           tags_for_logger = if each_logger.formatter.current_tags.include?("ActiveJob")
-                              ["ActiveJob"] + tags
+                              good_job_tag + tags
                             else
                               tags
                             end

data/lib/good_job/multi_scheduler.rb

@@ -26,14 +26,23 @@ module GoodJob
     # Delegates to {Scheduler#create_thread}.
     def create_thread(state = nil)
       results = []
-      any_true = schedulers.any? do |scheduler|
-        scheduler.create_thread(state).tap { |result| results << result }
+
+      if state
+        schedulers.any? do |scheduler|
+          scheduler.create_thread(state).tap { |result| results << result }
+        end
+      else
+        schedulers.each do |scheduler|
+          results << scheduler.create_thread(state)
+        end
       end
 
-      if any_true
+      if results.any?
         true
-      else
-        results.any? { |result| result == false } ? false : nil
+      elsif results.any? { |result| result == false }
+        false
+      else # rubocop:disable Style/EmptyElse
+        nil
       end
     end
   end

data/lib/good_job/notifier.rb

@@ -34,7 +34,7 @@ module GoodJob # :nodoc:
     # @param message [#to_json]
     def self.notify(message)
       connection = ActiveRecord::Base.connection
-      connection.exec_query <<~SQL
+      connection.exec_query <<~SQL.squish
         NOTIFY #{CHANNEL}, #{connection.quote(message.to_json)}
       SQL
     end
@@ -75,7 +75,7 @@ module GoodJob # :nodoc:
     # If +wait+ is +true+, the notifier will wait for background thread to shutdown.
     # If +wait+ is +false+, this method will return immediately even though threads may still be running.
     # Use {#shutdown?} to determine whether threads have stopped.
-    # @param wait [Boolean] Wait for actively executing jobs to finish
+    # @param wait [Boolean] Wait for actively executing threads to finish
     # @return [void]
     def shutdown(wait: true)
       return unless @pool.running?
@@ -147,7 +147,7 @@ module GoodJob # :nodoc:
       pg_conn.exec("SET application_name = #{pg_conn.escape_identifier(self.class.name)}")
       yield pg_conn
     ensure
-      ar_conn.disconnect!
+      ar_conn&.disconnect!
     end
   end
 end

data/lib/good_job/poller.rb

@@ -0,0 +1,94 @@
+require 'concurrent/atomic/atomic_boolean'
+
+module GoodJob # :nodoc:
+  #
+  # Pollers regularly wake up execution threads to check for new work.
+  #
+  class Poller
+    # Defaults for instance of Concurrent::TimerTask.
+    # The timer controls how and when sleeping threads check for new work.
+    DEFAULT_TIMER_OPTIONS = {
+      execution_interval: Configuration::DEFAULT_POLL_INTERVAL,
+      timeout_interval: 1,
+      run_now: true,
+    }.freeze
+
+    # @!attribute [r] instances
+    #   @!scope class
+    #   List of all instantiated Pollers in the current process.
+    #   @return [array<GoodJob:Poller>]
+    cattr_reader :instances, default: [], instance_reader: false
+
+    def self.from_configuration(configuration)
+      GoodJob::Poller.new(poll_interval: configuration.poll_interval)
+    end
+
+    # List of recipients that will receive notifications.
+    # @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
+    def initialize(*recipients, poll_interval: nil)
+      @recipients = Concurrent::Array.new(recipients)
+
+      @timer_options = DEFAULT_TIMER_OPTIONS.dup
+      @timer_options[:execution_interval] = poll_interval if poll_interval.present?
+
+      self.class.instances << self
+
+      create_pool
+    end
+
+    # Shut down the poller.
+    # If +wait+ is +true+, the poller will wait for background thread to shutdown.
+    # If +wait+ is +false+, this method will return immediately even though threads may still be running.
+    # Use {#shutdown?} to determine whether threads have stopped.
+    # @param wait [Boolean] Wait for actively executing threads to finish
+    # @return [void]
+    def shutdown(wait: true)
+      return unless @timer&.running?
+
+      @timer.shutdown
+      @timer.wait_for_termination if wait
+    end
+
+    # Tests whether the poller is shutdown.
+    # @return [true, false, nil]
+    def shutdown?
+      !@timer&.running?
+    end
+
+    # Restart the poller.
+    # When shutdown, start; or shutdown and start.
+    # @param wait [Boolean] Wait for background thread to finish
+    # @return [void]
+    def restart(wait: true)
+      shutdown(wait: wait)
+      create_pool
+    end
+
+    # Invoked on completion of TimerTask task.
+    # @!visibility private
+    # @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 })
+    end
+
+    private
+
+    def create_pool
+      return if @timer_options[:execution_interval] <= 0
+
+      @timer = Concurrent::TimerTask.new(@timer_options) do
+        recipients.each do |recipient|
+          target, method_name = recipient.is_a?(Array) ? recipient : [recipient, :call]
+          target.send(method_name)
+        end
+      end
+      @timer.add_observer(self, :timer_observer)
+      @timer.execute
+    end
+  end
+end

data/lib/good_job/scheduler.rb

@@ -14,20 +14,12 @@ module GoodJob # :nodoc:
   # The scheduler maintains an instance of +Concurrent::TimerTask+, which wakes sleeping threads and causes them to check whether the performer has new work.
   #
   class Scheduler
-    # Defaults for instance of Concurrent::TimerTask.
-    # The timer controls how and when sleeping threads check for new work.
-    DEFAULT_TIMER_OPTIONS = {
-      execution_interval: 1,
-      timeout_interval: 1,
-      run_now: true,
-    }.freeze
-
     # Defaults for instance of Concurrent::ThreadPoolExecutor
     # The thread pool is where work is performed.
     DEFAULT_POOL_OPTIONS = {
       name: name,
       min_threads: 0,
-      max_threads: Concurrent.processor_count,
+      max_threads: Configuration::DEFAULT_MAX_THREADS,
       auto_terminate: true,
       idletime: 60,
       max_queue: -1,
@@ -41,7 +33,6 @@ module GoodJob # :nodoc:
     cattr_reader :instances, default: [], instance_reader: false
 
     # Creates GoodJob::Scheduler(s) and Performers from a GoodJob::Configuration instance.
-    # TODO: move this to GoodJob::Configuration
     # @param configuration [GoodJob::Configuration]
     # @return [GoodJob::Scheduler, GoodJob::MultiScheduler]
     def self.from_configuration(configuration)
@@ -53,7 +44,7 @@ module GoodJob # :nodoc:
         parsed = GoodJob::Job.queue_parser(queue_string)
         job_filter = proc do |state|
           if parsed[:exclude]
-            !parsed[:exclude].include? state[:queue_name]
+            parsed[:exclude].exclude?(state[:queue_name])
           elsif parsed[:include]
             parsed[:include].include? state[:queue_name]
           else
@@ -62,14 +53,7 @@ module GoodJob # :nodoc:
         end
         job_performer = GoodJob::Performer.new(job_query, :perform_with_advisory_lock, name: queue_string, filter: job_filter)
 
-        timer_options = {}
-        timer_options[:execution_interval] = configuration.poll_interval
-
-        pool_options = {
-          max_threads: max_threads,
-        }
-
-        GoodJob::Scheduler.new(job_performer, timer_options: timer_options, pool_options: pool_options)
+        GoodJob::Scheduler.new(job_performer, max_threads: max_threads)
       end
 
       if schedulers.size > 1
@@ -80,21 +64,19 @@ module GoodJob # :nodoc:
     end
 
     # @param performer [GoodJob::Performer]
-    # @param timer_options [Hash] Options to instantiate a Concurrent::TimerTask
-    # @param pool_options [Hash] Options to instantiate a Concurrent::ThreadPoolExecutor
-    def initialize(performer, timer_options: {}, pool_options: {})
-      # TODO: Replace `timer_options` and `pool_options` with only `poll_interval` and `max_threads`
+    # @param max_threads [Numeric, nil] number of seconds between polls for jobs
+    def initialize(performer, max_threads: nil)
       raise ArgumentError, "Performer argument must implement #next" unless performer.respond_to?(:next)
 
       self.class.instances << self
 
       @performer = performer
-      @pool_options = DEFAULT_POOL_OPTIONS.merge(pool_options)
-      @timer_options = DEFAULT_TIMER_OPTIONS.merge(timer_options)
 
-      @pool_options[:name] = "GoodJob::Scheduler(queues=#{@performer.name} max_threads=#{@pool_options[:max_threads]} poll_interval=#{@timer_options[:execution_interval]})"
+      @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_pools
+      create_pool
     end
 
     # Shut down the scheduler.
@@ -105,28 +87,20 @@ module GoodJob # :nodoc:
     # @param wait [Boolean] Wait for actively executing jobs to finish
     # @return [void]
     def shutdown(wait: true)
-      @_shutdown = true
+      return unless @pool&.running?
 
       instrument("scheduler_shutdown_start", { wait: wait })
       instrument("scheduler_shutdown", { wait: wait }) do
-        if @timer&.running?
-          @timer.shutdown
-          @timer.wait_for_termination if wait
-          # TODO: Should be killed if wait is not true
-        end
-
-        if @pool&.running?
-          @pool.shutdown
-          @pool.wait_for_termination if wait
-          # TODO: Should be killed if wait is not true
-        end
+        @pool.shutdown
+        @pool.wait_for_termination if wait
+        # TODO: Should be killed if wait is not true
       end
     end
 
     # Tests whether the scheduler is shutdown.
     # @return [true, false, nil]
     def shutdown?
-      @_shutdown
+      !@pool&.running?
     end
 
     # Restart the Scheduler.
@@ -136,8 +110,7 @@ module GoodJob # :nodoc:
     def restart(wait: true)
       instrument("scheduler_restart_pools") do
         shutdown(wait: wait) unless shutdown?
-        create_pools
-        @_shutdown = false
+        create_pool
       end
     end
 
@@ -162,14 +135,6 @@ module GoodJob # :nodoc:
       true
     end
 
-    # Invoked on completion of TimerTask task.
-    # @!visibility private
-    # @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 })
-    end
-
     # Invoked on completion of ThreadPoolExecutor task
     # @!visibility private
     # @return [void]
@@ -181,14 +146,9 @@ module GoodJob # :nodoc:
 
     private
 
-    def create_pools
-      instrument("scheduler_create_pools", { performer_name: @performer.name, max_threads: @pool_options[:max_threads], poll_interval: @timer_options[:execution_interval] }) do
+    def create_pool
+      instrument("scheduler_create_pool", { performer_name: @performer.name, max_threads: @pool_options[:max_threads] }) do
         @pool = ThreadPoolExecutor.new(@pool_options)
-        next unless @timer_options[:execution_interval].positive?
-
-        @timer = Concurrent::TimerTask.new(@timer_options) { create_thread }
-        @timer.add_observer(self, :timer_observer)
-        @timer.execute
       end
     end
 
@@ -201,20 +161,20 @@ module GoodJob # :nodoc:
 
       ActiveSupport::Notifications.instrument("#{name}.good_job", payload, &block)
     end
-  end
 
-  # Custom sub-class of +Concurrent::ThreadPoolExecutor+ to add additional worker status.
-  # @private
-  class ThreadPoolExecutor < Concurrent::ThreadPoolExecutor
-    # Number of inactive threads available to execute tasks.
-    # https://github.com/ruby-concurrency/concurrent-ruby/issues/684#issuecomment-427594437
-    # @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
+    # Custom sub-class of +Concurrent::ThreadPoolExecutor+ to add additional worker status.
+    # @private
+    class ThreadPoolExecutor < Concurrent::ThreadPoolExecutor
+      # Number of inactive threads available to execute tasks.
+      # https://github.com/ruby-concurrency/concurrent-ruby/issues/684#issuecomment-427594437
+      # @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
+        end
       end
     end
   end

data/lib/good_job/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 1.2.5
+  version: 1.3.3
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-09-17 00:00:00.000000000 Z
+date: 2020-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -290,6 +290,20 @@ 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
@@ -475,6 +489,7 @@ files:
 - 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
 - lib/good_job/version.rb
@@ -510,7 +525,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
 summary: A multithreaded, Postgres-based ActiveJob backend for Ruby on Rails