good_job 3.4.2 → 3.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c31e9dc63de3bff82d55ba85e17690ad52dcf2d9b8ebc8bcb0d8dc7eab261b0
-  data.tar.gz: bab18a8d7b7328f172a6b66adba1767281cba281a8f38e76c8bfd303fd6a25a9
+  metadata.gz: 844b8a9661a1a6eefe86a2e58d829405b92bc7b54ad51ba6aeafea22c11ca080
+  data.tar.gz: c09eab3a34fe0ba218d79c0576bc1d9fe8cb41182c6d2bbf0af28c9bbbd4ce9a
 SHA512:
-  metadata.gz: d93aa0c5246d5e7be37f5887b7b3c8618815b88558360bb351ce9df7529460994506ddbdd84f1c57d4066216ea0fa98afdb937468c60aafd4966a2de88967656
-  data.tar.gz: b25da80ce2ca30517c4ec89187e062db7c1fd1e0b16ce7adaec33fb7da53ce1d56163a58595b57b4919d9d9cdbdf81ef6cf61664c48d2940c1f06fc70aaa6589
+  metadata.gz: 9d492d0763ab41e64f3670bc15176f6eec58d4fea9b4be7aa850cb2eaff4dba56d94ce42c6b0d123046dc2f0f2d183ad69e1fe6792b3e0b7fc077a32fecdff78
+  data.tar.gz: bb956e43b86d88a4492d715ddef00710d5667d6aed2a33b9fe9c532cfb1515f74a03e8bc7d7b86b4655296ed5ab22ad8813d9794c281304f1672853364928d1e

data/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog
 
+## [v3.4.5](https://github.com/bensheldon/good_job/tree/v3.4.5) (2022-09-12)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v3.4.4...v3.4.5)
+
+**Fixed bugs:**
+
+- Dashboard: Remove translation\_missing red highlighting; remove number\_to\_human.hundreds; add form labels [\#708](https://github.com/bensheldon/good_job/pull/708) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- pg\_xact No Such File error in logs [\#709](https://github.com/bensheldon/good_job/issues/709)
+- Broken upgrade to v3. [\#703](https://github.com/bensheldon/good_job/issues/703)
+
+**Merged pull requests:**
+
+- Sentry integration Docs [\#711](https://github.com/bensheldon/good_job/pull/711) ([remy727](https://github.com/remy727))
+- Add an `Execution` `after_perform_unlocked` callback [\#706](https://github.com/bensheldon/good_job/pull/706) ([bensheldon](https://github.com/bensheldon))
+
+## [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)
@@ -18,7 +65,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)
 
@@ -109,8 +156,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)
 - Simplify Rails initialization to only be a mountable Engine [\#543](https://github.com/bensheldon/good_job/issues/543)

data/README.md

@@ -232,7 +232,7 @@ Rails.application.configure do
   # Configure options individually...
   config.good_job.preserve_job_records = true
   config.good_job.retry_on_unhandled_error = false
-  config.good_job.on_thread_error = -> (exception) { Raven.capture_exception(exception) }
+  config.good_job.on_thread_error = -> (exception) { Sentry.capture_exception(exception) }
   config.good_job.execution_mode = :async
   config.good_job.queues = '*'
   config.good_job.max_threads = 5
@@ -245,7 +245,7 @@ Rails.application.configure do
   config.good_job = {
     preserve_job_records: true,
     retry_on_unhandled_error: false,
-    on_thread_error: -> (exception) { Raven.capture_exception(exception) },
+    on_thread_error: -> (exception) { Sentry.capture_exception(exception) },
     execution_mode: :async,
     queues: '*',
     max_threads: 5,
@@ -283,11 +283,11 @@ 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
-    config.good_job.on_thread_error = -> (exception) { Raven.capture_exception(exception) }
+    config.good_job.on_thread_error = -> (exception) { Sentry.capture_exception(exception) }
     ```
 
 By default, GoodJob configures the following execution modes per environment:
@@ -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
 
@@ -562,7 +567,7 @@ If errors do reach GoodJob, you can assign a callable to `GoodJob.on_thread_erro
 
 ```ruby
 # config/initializers/good_job.rb
-GoodJob.on_thread_error = -> (exception) { Raven.capture_exception(exception) }
+GoodJob.on_thread_error = -> (exception) { Sentry.capture_exception(exception) }
 ```
 
 #### Retries
@@ -596,13 +601,13 @@ class ApplicationJob < ActiveJob::Base
   retry_on StandardError, wait: :exponentially_longer, attempts: Float::INFINITY
 
   retry_on SpecialError, attempts: 5 do |_job, exception|
-    Raven.capture_exception(exception)
+    Sentry.capture_exception(exception)
   end
 
   around_perform do |_job, block|
     block.call
   rescue StandardError => e
-    Raven.capture_exception(e)
+    Sentry.capture_exception(e)
     raise
   end
   # ...
@@ -625,7 +630,7 @@ ActionMailer::MailDeliveryJob.retry_on StandardError, wait: :exponentially_longe
 ActionMailer::MailDeliveryJob.around_perform do |_job, block|
   block.call
 rescue StandardError => e
-  Raven.capture_exception(e)
+  Sentry.capture_exception(e)
   raise
 end
 ```

data/app/assets/good_job/style.css

@@ -35,11 +35,6 @@
   z-index: 1;
 }
 
-.translation_missing {
-  background-color: red;
-  color: white;
-}
-
 .btn-outline-secondary {
   border-color: #ced4da; /* $gray-400 */
 }

data/app/models/good_job/execution.rb

@@ -20,6 +20,8 @@ module GoodJob
     self.table_name = 'good_jobs'
     self.advisory_lockable_column = 'active_job_id'
 
+    define_model_callbacks :perform_unlocked, only: :after
+
     # Parse a string representing a group of queues into a more readable data
     # structure.
     # @param string [String] Queue string
@@ -202,13 +204,18 @@ module GoodJob
     #   raised, if any (if the job raised, then the second array entry will be
     #   +nil+). If there were no jobs to execute, returns +nil+.
     def self.perform_with_advisory_lock(parsed_queues: nil)
+      execution = nil
+      result = nil
       unfinished.dequeueing_ordered(parsed_queues).only_scheduled.limit(1).with_advisory_lock(unlock_session: true) do |executions|
         execution = executions.first
         break if execution.blank?
         break :unlocked unless execution&.executable?
 
-        execution.perform
+        result = execution.perform
       end
+      execution&.run_callbacks(:perform_unlocked)
+
+      result
     end
 
     # Fetches the scheduled execution time of the next eligible Execution(s).

data/app/views/good_job/jobs/_table.erb

@@ -4,6 +4,7 @@
     <header class="list-group-item bg-light">
       <div class="row small text-muted text-uppercase align-items-center">
         <div class="col-auto">
+          <%= label_tag('toggle_job_ids', "Toggle all jobs", class: "visually-hidden") %>
           <%= check_box_tag('toggle_job_ids', "1", false, data: { "checkbox-toggle-all": "job_ids" }) %>
         </div>
         <div class="col-4">

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

@@ -5,8 +5,10 @@
     <%= 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">
+          <%= label_tag "job_queue_filter", "Queue name", class: "visually-hidden" %>
           <select name="queue_name" id="job_queue_filter" class="form-select form-select-sm">
             <option value="" <%= "selected='selected'" if params[:queue_name].blank? %>>All queues</option>
 
@@ -17,6 +19,7 @@
         </div>
 
         <div class="me-2">
+          <%= label_tag "job_class_filter", "Job name", class: "visually-hidden" %>
           <select name="job_class" id="job_class_filter" class="form-select form-select-sm">
             <option value="" <%= "selected='selected'" if params[:job_class].blank? %>>All jobs</option>
 
@@ -27,6 +30,7 @@
         </div>
 
         <div class="me-2 flex-fill">
+          <%= label_tag "query", "Search", class: "visually-hidden" %>
           <%= search_field_tag "query", params[:query], class: "form-control form-control-sm", placeholder: "Search by class, job id, job params, and error text." %>
         </div>
 

data/config/locales/en.yml

@@ -72,7 +72,6 @@ en:
         format: "%n%u"
         units:
           billion: B
-          hundred: ''
           million: M
           quadrillion: Q
           thousand: K

data/config/locales/es.yml

@@ -72,7 +72,6 @@ es:
         format: "%n%u"
         units:
           billion: B
-          hundred: ''
           million: M
           quadrillion: q
           thousand: k

data/config/locales/nl.yml

@@ -72,7 +72,6 @@ nl:
         format: "%n%u"
         units:
           billion: B
-          hundred: ''
           million: M
           quadrillion: Q
           thousand: K

data/config/locales/ru.yml

@@ -96,7 +96,6 @@ ru:
         format: "%n%u"
         units:
           billion: Б
-          hundred: ''
           million: М
           quadrillion: Q
           thousand: К

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

@@ -60,6 +60,7 @@ module GoodJob
           result = execution.perform
         ensure
           execution.advisory_unlock
+          execution.run_callbacks(:perform_unlocked)
         end
         raise result.unhandled_error if result.unhandled_error
       else

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.5'
 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.5
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-08-13 00:00:00.000000000 Z
+date: 2022-09-12 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