good_job 2.0.5 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe9ce3416f1a816d3aa317139da71333f36c69dec121371c163a4965d61a2a6a
-  data.tar.gz: 1d3cd7fd9bb43ccc0b0f94bbdf99cf2cd3865f4316ea8178aa67e4c3dfb9a97b
+  metadata.gz: a15eb306ad205685ef586d40c1f54cea489e900143e7080fa3da72b3272846a6
+  data.tar.gz: 4739ce28860fda800a785d32802a94083f7012496f465360240e895b15533879
 SHA512:
-  metadata.gz: 6aa38c7714d0e5e959d0dfcd48fc9cfcbbae475d40cdd9d9f3aa452178b470de500cc1c0513c00a80e4d8b2e762c73b2a55b1233a638d6acb7c3320ecdb16975
-  data.tar.gz: 96ec7cc7fbdb4cdc232a1ddfd046df5aa7976336e639d77fe3ff8dfdc9d2814cebdf88d8450aab2afa7f80a4b911282b96632fe04602c6dba5548a4435fce41f
+  metadata.gz: 4f02dbda1d52e6340b9cb93b3dd5389271f1356844391c4c14ffcc651b25edd7cc1d6bcdfe96f164e7ee8faec47b00daca5e2cd0d11ec2a616a15450801425ce
+  data.tar.gz: 335871d05b792214b2a168726c154c7267d5c6081b448cd1623462d11013d45bbb0b49adc5aea488de6e13f74f556ec8b1134684b1e5505f334324dfeeb948e8

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [v2.1.0](https://github.com/bensheldon/good_job/tree/v2.1.0) (2021-09-09)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v2.0.5...v2.1.0)
+
+**Implemented enhancements:**
+
+- Add `total_limit:` option to GoodJob::Concurrency to be inclusive of counting both enqueued and performing jobs [\#369](https://github.com/bensheldon/good_job/pull/369) ([bensheldon](https://github.com/bensheldon))
+- Add button to toggle all job params in Dashboard [\#365](https://github.com/bensheldon/good_job/pull/365) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- Cron-like jobs not always executed, possible reasons? [\#359](https://github.com/bensheldon/good_job/issues/359)
+
+**Merged pull requests:**
+
+- When shelling out in tests, send SIGKILL if process does not exit [\#371](https://github.com/bensheldon/good_job/pull/371) ([bensheldon](https://github.com/bensheldon))
+- Fix unlock key for Lockable\#with\_advisory\_lock [\#368](https://github.com/bensheldon/good_job/pull/368) ([bensheldon](https://github.com/bensheldon))
+- Have all tests use stubbed TestJob [\#364](https://github.com/bensheldon/good_job/pull/364) ([bensheldon](https://github.com/bensheldon))
+
 ## [v2.0.5](https://github.com/bensheldon/good_job/tree/v2.0.5) (2021-09-06)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v2.0.4...v2.0.5)

data/README.md

@@ -348,17 +348,20 @@ GoodJob includes a Dashboard as a mountable `Rails::Engine`.
 
 GoodJob can extend ActiveJob to provide limits on concurrently running jobs, either at time of _enqueue_ or at _perform_. Limiting concurrency can help prevent duplicate, double or unecessary jobs from being enqueued, or race conditions when performing, for example when interacting with 3rd-party APIs.
 
-**Note:** Limiting concurrency at _enqueue_ requires Rails 6.0+ because Rails 5.2 does not support `throw :abort` in ActiveJob callbacks.
+**Note:** Limiting concurrency at _enqueue_ requires Rails 6.0+ because Rails 5.2 cannot halt ActiveJob callbacks.
 
 ```ruby
 class MyJob < ApplicationJob
   include GoodJob::ActiveJobExtensions::Concurrency
 
   good_job_control_concurrency_with(
-    # Maximum number of jobs with the concurrency key to be concurrently enqueued
-    enqueue_limit: 2,
+    # Maximum number of unfinished jobs to allow with the concurrency key
+    total_limit: 1,
 
-    # Maximum number of jobs with the concurrency key to be concurrently performed
+    # Or, if more control is needed:
+    # Maximum number of jobs with the concurrency key to be concurrently enqueued (excludes performing jobs)
+    enqueue_limit: 2,
+    # Maximum number of jobs with the concurrency key to be concurrently performed (excludes enqueued jobs)
     perform_limit: 1,
 
     # A unique key to be globally locked against.

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

@@ -2,14 +2,22 @@
   <div class="table-responsive">
     <table class="table card-table table-bordered table-hover table-sm mb-0">
       <thead>
-        <th>GoodJob ID</th>
-        <th>ActiveJob ID</th>
-        <th>Job Class</th>
-        <th>Queue</th>
-        <th>Scheduled At</th>
-        <th>Error</th>
-        <th>ActiveJob Params</th>
-        <th>Actions</th>
+        <tr>
+          <th>GoodJob ID</th>
+          <th>ActiveJob ID</th>
+          <th>Job Class</th>
+          <th>Queue</th>
+          <th>Scheduled At</th>
+          <th>Error</th>
+          <th>
+            ActiveJob Params&nbsp;
+            <%= tag.button "Toggle", type: "button", class: "btn btn-sm btn-outline-primary", role: "button",
+                           data: { bs_toggle: "collapse", bs_target: ".job-params" },
+                           aria: { expanded: false, controls: jobs.map { |job| "##{dom_id(job, "params")}" }.join(" ") }
+            %>
+          </th>
+          <th>Actions</th>
+        </tr>
       </thead>
       <tbody>
         <% jobs.each do |job| %>
@@ -22,10 +30,10 @@
             <td class="text-break"><%= truncate(job.error, length: 1_000) %></td>
             <td>
               <%= tag.button "Preview", type: "button", class: "btn btn-sm btn-outline-primary", role: "button",
-                data: {bs_toggle: "collapse", bs_target: "##{dom_id(job, 'params')}"},
-                aria: {expanded: false, controls: dom_id(job, "params")}
+                data: { bs_toggle: "collapse", bs_target: "##{dom_id(job, 'params')}" },
+                aria: { expanded: false, controls: dom_id(job, "params") }
               %>
-              <%= tag.pre JSON.pretty_generate(job.serialized_params), id: dom_id(job, "params"), class: "collapse" %>
+              <%= tag.pre JSON.pretty_generate(job.serialized_params), id: dom_id(job, "params"), class: "collapse job-params" %>
             </td>
             <td>
               <%= button_to job_path(job.id), method: :delete, class: "btn btn-sm btn-outline-danger", title: "Delete job" do %>

data/lib/good_job/active_job_extensions/concurrency.rb

@@ -20,17 +20,26 @@ module GoodJob
           # Always allow jobs to be retried because the current job's execution will complete momentarily
           next(block.call) if CurrentExecution.active_job_id == job.job_id
 
-          limit = job.class.good_job_concurrency_config.fetch(:enqueue_limit, Float::INFINITY)
-          next(block.call) if limit.blank? || (0...Float::INFINITY).exclude?(limit)
+          enqueue_limit = job.class.good_job_concurrency_config[:enqueue_limit]
+          total_limit = job.class.good_job_concurrency_config[:total_limit]
+
+          has_limit = (enqueue_limit.present? && (0...Float::INFINITY).cover?(enqueue_limit)) ||
+                      (total_limit.present? && (0...Float::INFINITY).cover?(total_limit))
+          next(block.call) unless has_limit
 
           key = job.good_job_concurrency_key
           next(block.call) if key.blank?
 
           GoodJob::Job.new.with_advisory_lock(key: key, function: "pg_advisory_lock") do
-            # TODO: Why is `unscoped` necessary? Nested scope is bleeding into subsequent query?
-            enqueue_concurrency = GoodJob::Job.unscoped.where(concurrency_key: key).unfinished.advisory_unlocked.count
+            enqueue_concurrency = if enqueue_limit
+                                    # TODO: Why is `unscoped` necessary? Nested scope is bleeding into subsequent query?
+                                    GoodJob::Job.unscoped.where(concurrency_key: key).unfinished.advisory_unlocked.count
+                                  else
+                                    GoodJob::Job.unscoped.where(concurrency_key: key).unfinished.count
+                                  end
+
             # The job has not yet been enqueued, so check if adding it will go over the limit
-            block.call unless enqueue_concurrency + 1 > limit
+            block.call unless enqueue_concurrency + 1 > (enqueue_limit || total_limit)
           end
         end
 
@@ -44,14 +53,17 @@ module GoodJob
           # Don't attempt to enforce concurrency limits with other queue adapters.
           next unless job.class.queue_adapter.is_a?(GoodJob::Adapter)
 
-          limit = job.class.good_job_concurrency_config.fetch(:perform_limit, Float::INFINITY)
-          next if limit.blank? || (0...Float::INFINITY).exclude?(limit)
+          perform_limit = job.class.good_job_concurrency_config[:perform_limit] ||
+                          job.class.good_job_concurrency_config[:total_limit]
+
+          has_limit = perform_limit.present? && (0...Float::INFINITY).cover?(perform_limit)
+          next unless has_limit
 
           key = job.good_job_concurrency_key
           next if key.blank?
 
           GoodJob::Job.new.with_advisory_lock(key: key, function: "pg_advisory_lock") do
-            allowed_active_job_ids = GoodJob::Job.unscoped.where(concurrency_key: key).advisory_locked.order(Arel.sql("COALESCE(performed_at, scheduled_at, created_at) ASC")).limit(limit).pluck(:active_job_id)
+            allowed_active_job_ids = GoodJob::Job.unscoped.where(concurrency_key: key).advisory_locked.order(Arel.sql("COALESCE(performed_at, scheduled_at, created_at) ASC")).limit(perform_limit).pluck(:active_job_id)
             # The current job has already been locked and will appear in the previous query
             raise GoodJob::ActiveJobExtensions::Concurrency::ConcurrencyExceededError unless allowed_active_job_ids.include? job.job_id
           end

data/lib/good_job/lockable.rb

@@ -155,8 +155,7 @@ module GoodJob
             advisory_unlock_session
           else
             records.each do |record|
-              key = [table_name, record[_advisory_lockable_column]].join
-              record.advisory_unlock(key: key, function: advisory_unlockable_function(function))
+              record.advisory_unlock(key: record.lockable_column_key(column: column), function: advisory_unlockable_function(function))
             end
           end
         end
@@ -286,6 +285,13 @@ module GoodJob
       self.class.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Locked?', binds).any?
     end
 
+    # Tests whether this record does not have an advisory lock on it.
+    # @param key [String, Symbol] Key to test lock against
+    # @return [Boolean]
+    def advisory_unlocked?(key: lockable_key)
+      !advisory_locked?(key: key)
+    end
+
     # Tests whether this record is locked by the current database session.
     # @param key [String, Symbol] Key to test lock against
     # @return [Boolean]
@@ -315,7 +321,13 @@ module GoodJob
     # Default Advisory Lock key
     # @return [String]
     def lockable_key
-      "#{self.class.table_name}-#{self[self.class._advisory_lockable_column]}"
+      lockable_column_key
+    end
+
+    # Default Advisory Lock key for column-based locking
+    # @return [String]
+    def lockable_column_key(column: self.class._advisory_lockable_column)
+      "#{self.class.table_name}-#{self[column]}"
     end
 
     delegate :pg_or_jdbc_query, to: :class

data/lib/good_job/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module GoodJob
   # GoodJob gem version.
-  VERSION = '2.0.5'
+  VERSION = '2.1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 2.0.5
+  version: 2.1.0
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-06 00:00:00.000000000 Z
+date: 2021-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob