good_job 3.4.1 → 3.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38942c9c17765023398fe2a5c2f3dc2c0ebadc799858ed1102bc47bd11d70ed9
-  data.tar.gz: 1dbbff4895a344d948592ec8801e1a325f48b984b66738efdbf785ca4f46f9b6
+  metadata.gz: c54a7908e5803c8f247421375b0ca4a09f97d5b0d21131ef2bfc54e91a4c7eed
+  data.tar.gz: 8a616c9407d2844ee89e2f12fa71c197ddb60e693983c66ce664ac413d0676f0
 SHA512:
-  metadata.gz: 03ac67ff433d1124b3d1dfcb07fb61d9b47393d4dcc8f3341698d5eead8597611009f453ea7cdc09f12cab2b1fbd1a6ed04fcb14fbe532aed8d0ac9fdb9c33f0
-  data.tar.gz: 0d951f8f156fbc47df60271d8f845df9ee93980af9ce3153a81fb8e3c7c0b4f80cbe7f727189be7d06930b97e30b89c65bf7d15fbe39138044979c8c4b319c8d
+  metadata.gz: 0040cd9afa69d73d4c9bf09da90bd7c1e4c73d4dc4251faff13fd495e2c39d081d099163482edb332a392be1dd560ac056705a5261363e8172d2ae7eab20be55
+  data.tar.gz: c4e41bd8da8e2afd309fceb2c0c5eb4b042d85234c4d34f4a687bcb2fe63f9e2f7d0c442c07bf68a248201d5e9c42c2e84dc8022c9f3eace8ea0b97c3995e004

data/CHANGELOG.md

@@ -1,5 +1,54 @@
 # Changelog
 
+## [v3.4.4](https://github.com/bensheldon/good_job/tree/v3.4.4) (2022-08-20)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v3.4.3...v3.4.4)
+
+**Fixed bugs:**
+
+- Keep locale param when submitting dashboard filter [\#707](https://github.com/bensheldon/good_job/pull/707) ([aki77](https://github.com/aki77))
+
+**Merged pull requests:**
+
+- Fix document [\#704](https://github.com/bensheldon/good_job/pull/704) ([aki77](https://github.com/aki77))
+- Describe pessimistic usecases [\#702](https://github.com/bensheldon/good_job/pull/702) ([shouichi](https://github.com/shouichi))
+
+## [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)
+
+**Fixed bugs:**
+
+- Jobs enqueued via dashboard ignores app default\_locale [\#697](https://github.com/bensheldon/good_job/issues/697)
+- Include better exception log messages, including class and backtrace [\#693](https://github.com/bensheldon/good_job/pull/693) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- Do we need to implement concurrency with scheduled cron jobs? [\#690](https://github.com/bensheldon/good_job/issues/690)
+- Uninitialized constant GoodJob::JobsController [\#674](https://github.com/bensheldon/good_job/issues/674)
+- ActiveRecord::StatementInvalid: PG::ConnectionBad: PQsocket\(\) can't get socket descriptor every 30 minutes aprox. [\#579](https://github.com/bensheldon/good_job/issues/579)
+- Handle assets in dashboard when rails app is behind proxy path [\#424](https://github.com/bensheldon/good_job/issues/424)
+
+**Merged pull requests:**
+
+- 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)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v3.4.0...v3.4.1)
@@ -8,7 +57,6 @@
 
 - Add `cron_enabled` to Process state [\#673](https://github.com/bensheldon/good_job/issues/673)
 - Good job is using a lot of memory / ram [\#613](https://github.com/bensheldon/good_job/issues/613)
-- ActiveRecord::StatementInvalid: PG::ConnectionBad: PQsocket\(\) can't get socket descriptor every 30 minutes aprox. [\#579](https://github.com/bensheldon/good_job/issues/579)
 
 **Merged pull requests:**
 
@@ -90,7 +138,6 @@
 
 **Closed issues:**
 
-- Calculating database connections [\#669](https://github.com/bensheldon/good_job/issues/669)
 - Unable to Replace GoodJob's Logger [\#667](https://github.com/bensheldon/good_job/issues/667)
 - Readme should consistently encourage usage of `config.good_job....` instead of `GoodJob.` configuration [\#628](https://github.com/bensheldon/good_job/issues/628)
 - Improve the "Gem development" section of README? [\#551](https://github.com/bensheldon/good_job/issues/551)

data/README.md

@@ -283,7 +283,7 @@ Available configuration options are:
 - `inline_execution_respects_schedule` (boolean) Opt-in to future behavior of inline execution respecting scheduled jobs. Defaults to `false`.
 - `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` (Default: `Rails.logger`).
 - `preserve_job_records` (boolean) keeps job records in your database even after jobs are completed. (Default: `true`)
-- `retry_on_unhandled_error` (boolean) causes jobs to be re-queued and retried if they raise an instance of `StandardError`. Be advised this may lead to jobs being repeated infinitely ([see below for more on retries](#retries)). Instances of `Exception`, like SIGINT, will *always* be retried, regardless of this attribute’s value. (Default: `true`)
+- `retry_on_unhandled_error` (boolean) causes jobs to be re-queued and retried if they raise an instance of `StandardError`. Be advised this may lead to jobs being repeated infinitely ([see below for more on retries](#retries)). Instances of `Exception`, like SIGINT, will *always* be retried, regardless of this attribute’s value. (Default: `false`)
 - `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. Example:
 
     ```ruby
@@ -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,12 @@ 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.
+- For pessimistic usecases that collisions are expected, use number of threads/processes (e.g., `good_job --queue "serial:1;-serial:5"`) to control concurrency. It is also a good idea to use `perform_limit` as backstop.
 
 ### Cron-style repeating/recurring jobs
 

data/app/models/good_job/cron_entry.rb

@@ -106,7 +106,9 @@ module GoodJob # :nodoc:
         current_thread.cron_at = cron_at
 
         configured_job = job_class.constantize.set(set_value)
-        kwargs_value.present? ? configured_job.perform_later(*args_value, **kwargs_value) : configured_job.perform_later(*args_value)
+        I18n.with_locale(I18n.default_locale) do
+          kwargs_value.present? ? configured_job.perform_later(*args_value, **kwargs_value) : configured_job.perform_later(*args_value)
+        end
       end
     rescue ActiveRecord::RecordNotUnique
       false

data/app/views/good_job/shared/_filter.erb

@@ -5,6 +5,7 @@
     <%= form_with(url: "", method: :get, local: true, id: "filter_form", class: "container-fluid") do |form| %>
       <%= hidden_field_tag :poll, params[:poll] %>
       <%= hidden_field_tag :state, params[:state] %>
+      <%= hidden_field_tag :locale, params[:locale] if params[:locale] %>
       <div class="d-flex flex-row w-100">
         <div class="me-2">
           <select name="queue_name" id="job_queue_filter" class="form-select form-select-sm">

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/log_subscriber.rb

@@ -32,7 +32,7 @@ module GoodJob
       return unless exception
 
       error do
-        "GoodJob error: #{exception}\n #{exception.backtrace}"
+        "GoodJob error: #{exception.class}: #{exception}\n #{exception.backtrace}"
       end
     end
 
@@ -42,7 +42,7 @@ module GoodJob
       return unless exception
 
       error do
-        "GoodJob error: #{exception}\n #{exception.backtrace}"
+        "GoodJob error: #{exception.class}: #{exception}\n #{exception.backtrace}"
       end
     end
 
@@ -123,10 +123,10 @@ module GoodJob
 
     # @!macro notification_responder
     def notifier_notify_error(event)
-      error = event.payload[:error]
+      exception = event.payload[:error]
 
       error do
-        "Notifier errored: #{error}"
+        "Notifier errored: #{exception.class}: #{exception}\n #{exception.backtrace}"
       end
     end
 

data/lib/good_job/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 3.4.1
+  version: 3.4.4
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-08-06 00:00:00.000000000 Z
+date: 2022-08-20 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