good_job 1.3.0 → 1.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17fac9485f08bf55c8d2b2fbbc6e85efde95202d759d6155a4b23bf0755236ce
-  data.tar.gz: 562115863243ac98e3fd0cca7c04ad9f57a80f932682d7161e43336b521ea62d
+  metadata.gz: 46b04fbfe44919834c406101ee18f2b53f5cc05e076525f7243e346fa966ca94
+  data.tar.gz: 798738a1f2b0c7f21457921c2c640cdc78151a09262dfa7d8a383e8778282b9d
 SHA512:
-  metadata.gz: a06ee5d2bea077e7b612f6d44aa30666d52517849e5345d8882a9f21653513be2386e577dbbab8ad41897aeb48d14885cbfe8cd51784c96da300aee7233a5190
-  data.tar.gz: 7c366b21a4f28d66ce8d59d22fa56a081a63c181ee0b35ddd7965422c7c758f020bc7fba42aa34e61ec8abb17e9dcc5a9d0cb3b15f2d1c03d7153d83d7fbffdd
+  metadata.gz: 841c85e7b4d9fa28d1fcdbb7c6a48771438f24ae33a264a80afdff1c9730a3438b98aa5d82f54bd1d4c979b2dab64997fbf6d64036bc96fdac6c851f70e0f68f
+  data.tar.gz: 9c2d11c56e3db986aa5bbecc85a317396a19ba1c838b97d32cd16f21b9cd29b6c154be817879d8c8a8925da645d298442c0ebc39aba3d5bba707ed01558b55c5

data/CHANGELOG.md

@@ -1,12 +1,82 @@
 # Changelog
 
+## [v1.3.5](https://github.com/bensheldon/good_job/tree/v1.3.5) (2020-12-17)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v1.3.4...v1.3.5)
+
+**Closed issues:**
+
+- not running jobs [\#168](https://github.com/bensheldon/good_job/issues/168)
+- how to run good\_job on a separate machine  [\#162](https://github.com/bensheldon/good_job/issues/162)
+
+**Merged pull requests:**
+
+-  Ensure advisory lock CTE is MATERIALIZED on Postgres v12+ [\#179](https://github.com/bensheldon/good_job/pull/179) ([bensheldon](https://github.com/bensheldon))
+- Ensure that deleted jobs are unlocked [\#178](https://github.com/bensheldon/good_job/pull/178) ([bensheldon](https://github.com/bensheldon))
+- Add Appraisal for Rails 6.1-rc2 [\#175](https://github.com/bensheldon/good_job/pull/175) ([bensheldon](https://github.com/bensheldon))
+
+## [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 for Rails 6.1 [\#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)
 
-**Merged pull requests:**
+**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)
@@ -358,7 +428,6 @@
 **Merged pull requests:**
 
 - Improve ActiveRecord usage for advisory locking [\#24](https://github.com/bensheldon/good_job/pull/24) ([bensheldon](https://github.com/bensheldon))
-- Remove support for Rails 5.1 [\#23](https://github.com/bensheldon/good_job/pull/23) ([bensheldon](https://github.com/bensheldon))
 
 ## [v0.3.0](https://github.com/bensheldon/good_job/tree/v0.3.0) (2020-03-22)
 
@@ -377,6 +446,7 @@
 
 **Merged pull requests:**
 
+- Remove support for Rails 5.1 [\#23](https://github.com/bensheldon/good_job/pull/23) ([bensheldon](https://github.com/bensheldon))
 - Gracefully shutdown Scheduler when executable receives TERM or INT [\#17](https://github.com/bensheldon/good_job/pull/17) ([bensheldon](https://github.com/bensheldon))
 - Update Appraisals [\#16](https://github.com/bensheldon/good_job/pull/16) ([bensheldon](https://github.com/bensheldon))
 

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

@@ -1,24 +1,24 @@
 <!DOCTYPE html>
 <html>
 <head>
-  <title>Good job</title>
+  <title>Good Job Dashboard</title>
   <%= csrf_meta_tags %>
   <%= csp_meta_tag %>
 
   <style>
-    <%= render "vendor/bootstrap/bootstrap.css" %>
-    <%= render "vendor/chartist/chartist.css" %>
-    <%= render "assets/style.css" %>
+    <%= render file: GoodJob::Engine.root.join("app", "assets", "vendor", "bootstrap", "bootstrap.css") %>
+    <%= render file: GoodJob::Engine.root.join("app", "assets", "vendor", "chartist", "chartist.css") %>
+    <%= render file: GoodJob::Engine.root.join("app", "assets", "style.css") %>
   </style>
 
   <script>
-    <%= render "vendor/bootstrap/bootstrap-native.js" %>
-    <%= render "vendor/chartist/chartist.js" %>
+    <%= render file: GoodJob::Engine.root.join("app", "assets", "vendor", "bootstrap", "bootstrap-native.js") %>
+    <%= render file: GoodJob::Engine.root.join("app", "assets", "vendor", "chartist", "chartist.js") %>
   </script>
 </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/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

@@ -45,11 +45,13 @@ module GoodJob
                   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/lockable.rb

@@ -32,11 +32,18 @@ module GoodJob
         original_query = self
 
         cte_table = Arel::Table.new(:rows)
-        composed_cte = Arel::Nodes::As.new(cte_table, original_query.select(primary_key).except(:limit).arel)
+        cte_query = original_query.select(primary_key).except(:limit)
+        cte_type = if supports_cte_materialization_specifiers?
+                     'MATERIALIZED'
+                   else
+                     ''
+                   end
+
+        composed_cte = Arel::Nodes::As.new(cte_table, Arel::Nodes::SqlLiteral.new([cte_type, "(", cte_query.to_sql, ")"].join(' ')))
 
         query = cte_table.project(cte_table[:id])
-                  .with(composed_cte)
-                  .where(Arel.sql(sanitize_sql_for_conditions(["pg_try_advisory_lock(('x' || substr(md5(:table_name || #{connection.quote_table_name(cte_table.name)}.#{quoted_primary_key}::text), 1, 16))::bit(64)::bigint)", { table_name: table_name }])))
+                         .with(composed_cte)
+                         .where(Arel.sql(sanitize_sql_for_conditions(["pg_try_advisory_lock(('x' || substr(md5(:table_name || #{connection.quote_table_name(cte_table.name)}.#{quoted_primary_key}::text), 1, 16))::bit(64)::bigint)", { table_name: table_name }])))
 
         limit = original_query.arel.ast.limit
         query.limit = limit.value if limit.present?
@@ -56,7 +63,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
@@ -132,6 +139,12 @@ module GoodJob
           records.each(&:advisory_unlock)
         end
       end
+
+      def supports_cte_materialization_specifiers?
+        return @supports_cte_materialization_specifiers if defined?(@supports_cte_materialization_specifiers)
+
+        @supports_cte_materialization_specifiers = ActiveRecord::Base.connection.postgresql_version >= 120000
+      end
     end
 
     # Acquires an advisory lock on this record if it is not already locked by
@@ -140,10 +153,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 +164,11 @@ 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
-        pg_advisory_unlock(('x' || substr(md5(:table_name || :id::text), 1, 16))::bit(64)::bigint)
+      query = <<~SQL.squish
+        SELECT 1 AS one
+        WHERE 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.connection.execute(sanitize_sql_for_conditions([query, { table_name: self.class.table_name, id: send(self.class.primary_key) }])).ntuples.positive?
     end
 
     # Acquires an advisory lock on this record or raises
@@ -191,13 +205,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.3.0'.freeze
+  VERSION = '1.3.5'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.3.5
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-10-03 00:00:00.000000000 Z
+date: 2020-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -164,20 +164,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: erb_lint
-  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: foreman
   requirement: !ruby/object:Gem::Requirement
@@ -248,20 +234,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: mdl
-  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: pry-rails
   requirement: !ruby/object:Gem::Requirement
@@ -291,7 +263,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rbtrace
+  name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -305,49 +277,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec-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: rubocop
-  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: rubocop-performance
-  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: rubocop-rails
+  name: rbtrace
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -361,7 +291,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rubocop-rspec
+  name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -444,20 +374,20 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
+- engine/app/assets/style.css
+- engine/app/assets/vendor/bootstrap/bootstrap-native.js
+- engine/app/assets/vendor/bootstrap/bootstrap.css
+- engine/app/assets/vendor/chartist/chartist.css
+- engine/app/assets/vendor/chartist/chartist.js
 - engine/app/controllers/good_job/active_jobs_controller.rb
 - engine/app/controllers/good_job/base_controller.rb
 - engine/app/controllers/good_job/dashboards_controller.rb
 - engine/app/helpers/good_job/application_helper.rb
-- engine/app/views/assets/_style.css.erb
 - engine/app/views/good_job/active_jobs/show.html.erb
 - engine/app/views/good_job/dashboards/index.html.erb
 - engine/app/views/layouts/good_job/base.html.erb
 - engine/app/views/shared/_chart.erb
 - engine/app/views/shared/_jobs_table.erb
-- engine/app/views/vendor/bootstrap/_bootstrap-native.js.erb
-- engine/app/views/vendor/bootstrap/_bootstrap.css.erb
-- engine/app/views/vendor/chartist/_chartist.css.erb
-- engine/app/views/vendor/chartist/_chartist.js.erb
 - engine/config/routes.rb
 - engine/lib/good_job/engine.rb
 - exe/good_job
@@ -475,6 +405,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 +441,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