good_job 1.2.6 → 1.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7bb8c33f26176b048399e596b7c4c5dcb10553209b9237fe6256e7af66b1ffcc
-  data.tar.gz: b401649bfe1dee5f83575e82cb2703407c2ddc367dabaabc05f41d9f79e4315d
+  metadata.gz: 7c7d64f21fbabba859d20d0a277d0a963672fcfde1284881b0130b1e05e62252
+  data.tar.gz: b7dbc95191a2bf115176f0e8ce09b8f7c997a2cb852fb673e5fee17c241434be
 SHA512:
-  metadata.gz: d38c25e5f61a8d6509f323509ecd5e0fb49a31466b58a3eae47a5614b0e56f3b30a90725d8e57dc0d170a1cda635cb49850cc98d6b4c1c4033c8a65db691af8c
-  data.tar.gz: 31add663e7307890b66f89e14b5ea164c9c67252c695db50f0d761921308019fcf7874984db7f263ae67557d1538f6b25d15271ca9880190b6faf13dc29346f8
+  metadata.gz: a0e58bf60a8008617703b575d55cdefd94fa9405d8d7cb034a75013b3a3fc8e4205833cf818d03caa137470b9ff431258d19e166e5d56f83a70667c3c484d904
+  data.tar.gz: adc2a494ea2f4e3e4ac7f569b013edade8a223f1e54474835cba34c6ac6233760f94bbbffb62f0ed37a119f8f15dfd1310a87b304483bbae72ecd0129f10f439

data/CHANGELOG.md

@@ -1,5 +1,69 @@
 # Changelog
 
+## [v1.3.4](https://github.com/bensheldon/good_job/tree/v1.3.4) (2020-12-02)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.3.3...v1.3.4)
+
+**Merged pull requests:**
+
+- Fix job ordering. [\#174](https://github.com/bensheldon/good_job/pull/174) ([morgoth](https://github.com/morgoth))
+
+## [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)
@@ -57,7 +121,6 @@
 - 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))
 - 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))
-- 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))
 
 ## [v1.2.4](https://github.com/bensheldon/good_job/tree/v1.2.4) (2020-09-01)
@@ -81,6 +144,7 @@
 
 **Merged pull requests:**
 
+- Zeitwerk Loader Implementation [\#123](https://github.com/bensheldon/good_job/pull/123) ([gadimbaylisahil](https://github.com/gadimbaylisahil))
 - Remove unused PgLocks class [\#120](https://github.com/bensheldon/good_job/pull/120) ([gadimbaylisahil](https://github.com/gadimbaylisahil))
 - Fix readme CommandLine option links [\#115](https://github.com/bensheldon/good_job/pull/115) ([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))
@@ -270,10 +334,6 @@
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v0.8.2...v0.9.0)
 
-**Merged pull requests:**
-
-- Allow preservation of finished job records [\#46](https://github.com/bensheldon/good_job/pull/46) ([bensheldon](https://github.com/bensheldon))
-
 ## [v0.8.2](https://github.com/bensheldon/good_job/tree/v0.8.2) (2020-07-18)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v0.8.1...v0.8.2)
@@ -301,6 +361,7 @@
 
 **Merged pull requests:**
 
+- Allow preservation of finished job records [\#46](https://github.com/bensheldon/good_job/pull/46) ([bensheldon](https://github.com/bensheldon))
 - Replace Adapter inline boolean kwarg with execution\_mode instead [\#41](https://github.com/bensheldon/good_job/pull/41) ([bensheldon](https://github.com/bensheldon))
 
 ## [v0.7.0](https://github.com/bensheldon/good_job/tree/v0.7.0) (2020-07-16)

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.**
@@ -210,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:
@@ -218,7 +221,7 @@ 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) }
 ```
 
@@ -301,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:

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

@@ -2,7 +2,7 @@ module GoodJob
   class ActiveJobsController < GoodJob::BaseController
     def show
       @jobs = GoodJob::Job.where("serialized_params ->> 'job_id' = ?", params[:id])
-                          .order('COALESCE(scheduled_at, created_at) DESC')
+                          .order(Arel.sql("COALESCE(scheduled_at, created_at) DESC"))
     end
   end
 end

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>
@@ -48,7 +48,7 @@
     </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>

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

@@ -37,14 +37,30 @@ module GoodJob
   #   @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

@@ -8,7 +8,7 @@ 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 = 1
+    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
 

data/lib/good_job/job.rb

@@ -204,7 +204,7 @@ module GoodJob
 
       self.error = "#{job_error.class}: #{job_error.message}" if job_error
 
-      if unhandled_error && GoodJob.reperform_jobs_on_standard_error
+      if unhandled_error && GoodJob.retry_on_unhandled_error
         save!
       elsif GoodJob.preserve_job_records == true || (unhandled_error && GoodJob.preserve_job_records == :on_unhandled_error)
         self.finished_at = Time.current

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

@@ -45,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
 
@@ -166,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
@@ -192,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

@@ -26,14 +26,6 @@ module GoodJob # :nodoc:
       fallback_policy: :discard,
     }.freeze
 
-    # 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 Schedulers in the current process.
@@ -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,7 +53,7 @@ module GoodJob # :nodoc:
         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, poll_interval: configuration.poll_interval)
+        GoodJob::Scheduler.new(job_performer, max_threads: max_threads)
       end
 
       if schedulers.size > 1
@@ -73,23 +64,19 @@ module GoodJob # :nodoc:
     end
 
     # @param performer [GoodJob::Performer]
-    # @param max_threads [Numeric, nil] the number of execution threads to use
-    # @param poll_interval [Numeric, nil] the number of seconds between polls for jobs
-    def initialize(performer, max_threads: nil, poll_interval: nil)
+    # @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
 
-      @timer_options = DEFAULT_TIMER_OPTIONS.dup
-      @timer_options[:execution_interval] = poll_interval if poll_interval.present?
-
       @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]} poll_interval=#{@timer_options[:execution_interval]})"
+      @pool_options[:name] = "GoodJob::Scheduler(queues=#{@performer.name} max_threads=#{@pool_options[:max_threads]})"
 
-      create_pools
+      create_pool
     end
 
     # Shut down the scheduler.
@@ -100,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.
@@ -131,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
 
@@ -157,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]
@@ -176,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
 
@@ -196,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.6'.freeze
+  VERSION = '1.3.4'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 1.2.6
+  version: 1.3.4
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-09-29 00:00:00.000000000 Z
+date: 2020-12-02 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