good_job 3.4.2 → 3.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c31e9dc63de3bff82d55ba85e17690ad52dcf2d9b8ebc8bcb0d8dc7eab261b0
-  data.tar.gz: bab18a8d7b7328f172a6b66adba1767281cba281a8f38e76c8bfd303fd6a25a9
+  metadata.gz: 8838f9cf09b7dda04c3dc119db41deef4facc8b31a07e879e082898d77915d8d
+  data.tar.gz: a7e146e678ea6432f291f593edfce11497b70201576e299360a026dc83290dda
 SHA512:
-  metadata.gz: d93aa0c5246d5e7be37f5887b7b3c8618815b88558360bb351ce9df7529460994506ddbdd84f1c57d4066216ea0fa98afdb937468c60aafd4966a2de88967656
-  data.tar.gz: b25da80ce2ca30517c4ec89187e062db7c1fd1e0b16ce7adaec33fb7da53ce1d56163a58595b57b4919d9d9cdbdf81ef6cf61664c48d2940c1f06fc70aaa6589
+  metadata.gz: 87a1770d3b74c50c6a40bc63ca50ad368578524029b8d11b5221baf721f7c8169051f0c19bc9554962ff61fc9cf51ac397f042ad393a4c19cecb73924db0c6c2
+  data.tar.gz: d707c9b35f41b417628425c74e916c21654992dcb41a27e52fdc88435e74fae09168b85bea81470aeba7eb2236b9d2d57a736ce4c34a5c427c4f82230146d7fa

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [v3.4.3](https://github.com/bensheldon/good_job/tree/v3.4.3) (2022-08-15)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v3.4.2...v3.4.3)
+
+**Closed issues:**
+
+- How to run multiple workers? [\#699](https://github.com/bensheldon/good_job/issues/699)
+- Getting Postgres Errors on killing development server after setting up Goodjob [\#692](https://github.com/bensheldon/good_job/issues/692)
+
+**Merged pull requests:**
+
+- Fix Project v2 GitHub Actions [\#701](https://github.com/bensheldon/good_job/pull/701) ([bensheldon](https://github.com/bensheldon))
+- Remove development dependencies: memory\_profiler, rbtrace, sigdump [\#700](https://github.com/bensheldon/good_job/pull/700) ([bensheldon](https://github.com/bensheldon))
+- Allow concurrency limits to be configured dynamically with lambda/proc [\#696](https://github.com/bensheldon/good_job/pull/696) ([baka-san](https://github.com/baka-san))
+- Add additional details to Concurrency Control explanation [\#695](https://github.com/bensheldon/good_job/pull/695) ([bensheldon](https://github.com/bensheldon))
+
 ## [v3.4.2](https://github.com/bensheldon/good_job/tree/v3.4.2) (2022-08-13)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v3.4.1...v3.4.2)
@@ -18,7 +34,7 @@
 
 **Merged pull requests:**
 
-- Enqueues jobs with I18n default locale [\#698](https://github.com/bensheldon/good_job/pull/698) ([esasse](https://github.com/esasse))
+- Enqueues Cron jobs with I18n default locale [\#698](https://github.com/bensheldon/good_job/pull/698) ([esasse](https://github.com/esasse))
 
 ## [v3.4.1](https://github.com/bensheldon/good_job/tree/v3.4.1) (2022-08-06)
 

data/README.md

@@ -406,15 +406,18 @@ class MyJob < ApplicationJob
 
   good_job_control_concurrency_with(
     # Maximum number of unfinished jobs to allow with the concurrency key
+    # Can be an Integer or Lambda/Proc that is invoked in the context of the job
     total_limit: 1,
 
     # Or, if more control is needed:
     # Maximum number of jobs with the concurrency key to be
     # concurrently enqueued (excludes performing jobs)
+    # Can be an Integer or Lambda/Proc that is invoked in the context of the job
     enqueue_limit: 2,
 
     # Maximum number of jobs with the concurrency key to be
     # concurrently performed (excludes enqueued jobs)
+    # Can be an Integer or Lambda/Proc that is invoked in the context of the job
     perform_limit: 1,
 
     # Note: Under heavy load, the total number of jobs may exceed the
@@ -444,10 +447,11 @@ job.good_job_concurrency_key #=> "Unique-Alice"
 
 #### How concurrency controls work
 
-GoodJob's concurrency control strategy for `perform_limit` is "optimistic retry with an incremental backoff". The [code is readable](https://github.com/bensheldon/good_job/blob/main/lib/good_job/active_job_extensions/concurrency.rb).
+GoodJob's concurrency control strategy for `perform_limit` is "optimistic retry with an incremental backoff".  The [code is readable](https://github.com/bensheldon/good_job/blob/main/lib/good_job/active_job_extensions/concurrency.rb).
 
-- "Optimistic" meaning that the implementation's performance trade-off assumes that collisions are atypical (e.g. two users enqueue the same job at the same time) rather than regular (e.g. the system enqueues thousands of colliding jobs at the same time).
+- "Optimistic" meaning that the implementation's performance trade-off assumes that collisions are atypical (e.g. two users enqueue the same job at the same time) rather than regular (e.g. the system enqueues thousands of colliding jobs at the same time). Depending on your concurrency requirements, you may also want to manage concurrency through the number of GoodJob threads and processes that are performing a given queue.
 - "Retry with an incremental backoff" means that when `perform_limit` is exceeded, the job will raise a `GoodJob::ActiveJobExtensions::Concurrency::ConcurrencyExceededError` which is caught by a `retry_on` handler which re-schedules the job to execute in the near future with an incremental backoff.
+- First-in-first-out job execution order is not preserved when a job is retried with incremental back-off.
 
 ### Cron-style repeating/recurring jobs
 

data/lib/good_job/active_job_extensions/concurrency.rb

@@ -31,11 +31,17 @@ module GoodJob
           next(block.call) if CurrentThread.active_job_id == job.job_id
 
           enqueue_limit = job.class.good_job_concurrency_config[:enqueue_limit]
-          total_limit = job.class.good_job_concurrency_config[:total_limit]
+          enqueue_limit = instance_exec(&enqueue_limit) if enqueue_limit.respond_to?(:call)
+          enqueue_limit = nil unless enqueue_limit.present? && (0...Float::INFINITY).cover?(enqueue_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
+          unless enqueue_limit
+            total_limit = job.class.good_job_concurrency_config[:total_limit]
+            total_limit = instance_exec(&total_limit) if total_limit.respond_to?(:call)
+            total_limit = nil unless total_limit.present? && (0...Float::INFINITY).cover?(total_limit)
+          end
+
+          limit = enqueue_limit || total_limit
+          next(block.call) unless limit
 
           # Only generate the concurrency key on the initial enqueue in case it is dynamic
           job.good_job_concurrency_key ||= job._good_job_concurrency_key
@@ -50,7 +56,7 @@ module GoodJob
                                   end
 
             # The job has not yet been enqueued, so check if adding it will go over the limit
-            block.call unless enqueue_concurrency + 1 > (enqueue_limit || total_limit)
+            block.call unless (enqueue_concurrency + 1) > limit
           end
         end
 
@@ -64,11 +70,18 @@ module GoodJob
           # Don't attempt to enforce concurrency limits with other queue adapters.
           next unless job.class.queue_adapter.is_a?(GoodJob::Adapter)
 
-          perform_limit = job.class.good_job_concurrency_config[:perform_limit] ||
-                          job.class.good_job_concurrency_config[:total_limit]
+          perform_limit = job.class.good_job_concurrency_config[:perform_limit]
+          perform_limit = instance_exec(&perform_limit) if perform_limit.respond_to?(:call)
+          perform_limit = nil unless perform_limit.present? && (0...Float::INFINITY).cover?(perform_limit)
+
+          unless perform_limit
+            total_limit = job.class.good_job_concurrency_config[:total_limit]
+            total_limit = instance_exec(&total_limit) if total_limit.respond_to?(:call)
+            total_limit = nil unless total_limit.present? && (0...Float::INFINITY).cover?(total_limit)
+          end
 
-          has_limit = perform_limit.present? && (0...Float::INFINITY).cover?(perform_limit)
-          next unless has_limit
+          limit = perform_limit || total_limit
+          next unless limit
 
           key = job.good_job_concurrency_key
           next if key.blank?
@@ -79,7 +92,7 @@ module GoodJob
           end
 
           GoodJob::Execution.advisory_lock_key(key, function: "pg_advisory_lock") do
-            allowed_active_job_ids = GoodJob::Execution.unfinished.where(concurrency_key: key).advisory_locked.order(Arel.sql("COALESCE(performed_at, scheduled_at, created_at) ASC")).limit(perform_limit).pluck(:active_job_id)
+            allowed_active_job_ids = GoodJob::Execution.unfinished.where(concurrency_key: key).advisory_locked.order(Arel.sql("COALESCE(performed_at, scheduled_at, created_at) ASC")).limit(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/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 3.4.2
+  version: 3.4.3
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-08-13 00:00:00.000000000 Z
+date: 2022-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -290,20 +290,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: sigdump
-  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: yard
   requirement: !ruby/object:Gem::Requirement