good_job 3.10.1 → 3.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e632ae76e69e8601479181fb0093e9c6777510ac0743184a8f578b3c4dacee8
-  data.tar.gz: 577f36ad182e6f4ff841abcd073925f4477f1086b1a0c7a454c12037f781ace7
+  metadata.gz: '0298665dd1e0d426def8cd08d422e41bfaf308f26de80e7079f80f4ae3403259'
+  data.tar.gz: 6ed8d5a5891515f4ef6404c1776a9147df1625d5be1a654b0407eb94cc96f36e
 SHA512:
-  metadata.gz: f9211423d43cee468602aa1476d0d4b71a3831448157dc7dc540f98e0d1cb476e60bed884679ef10733af21c21e1c595dac14dc2d1c0b25d4b49b8d246f7be98
-  data.tar.gz: 25a51a4196ea6618ca44ac73ed6cb9f97b63d99596bd144a9d51f439033a22d15ab16a73cd9d48954dc9b447b19cc9f03a21a9e5667d5021c85b5510ad7ca577
+  metadata.gz: c0d4b598ee46722d8a23c6e1d044ba2a6ab9933998b096a1749896bc4fba7b50f19ec71ce02fc5924732210a0ea0a442a79ff66e34c12b94c3b7e79048f1cae9
+  data.tar.gz: 39fee537236f2304305dc9b5ae794a6045d5fb66450f67e40a859b4f62c05c88dcea2cb85b328839fff94989f260a40a7bc4a76fffffd1107a861bbe7ac19a2b

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [v3.11.0](https://github.com/bensheldon/good_job/tree/v3.11.0) (2023-02-06)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v3.10.1...v3.11.0)
+
+**Implemented enhancements:**
+
+- Create ActiveJob extension to disable sending a NOTIFY on enqueue and retry [\#814](https://github.com/bensheldon/good_job/pull/814) ([bensheldon](https://github.com/bensheldon))
+- Add global enable\_listen\_notify configuration to disable both notify and listen [\#810](https://github.com/bensheldon/good_job/pull/810) ([mitchellhenke](https://github.com/mitchellhenke))
+
+**Merged pull requests:**
+
+- Test Matrix: Use Ruby 3.2 to test against all Postgres versions; add PG 15, remove PG 10 [\#828](https://github.com/bensheldon/good_job/pull/828) ([bensheldon](https://github.com/bensheldon))
+- Bump nokogiri from 1.14.0 to 1.14.1 [\#827](https://github.com/bensheldon/good_job/pull/827) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Bump rubocop-performance from 1.15.2 to 1.16.0 [\#826](https://github.com/bensheldon/good_job/pull/826) ([dependabot[bot]](https://github.com/apps/dependabot))
+
 ## [v3.10.1](https://github.com/bensheldon/good_job/tree/v3.10.1) (2023-02-06)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v3.10.0...v3.10.1)

data/README.md

@@ -176,6 +176,7 @@ Options:
   [--max-cache=COUNT]          # Maximum number of scheduled jobs to cache in memory (env var: GOOD_JOB_MAX_CACHE, default: 10000)
   [--shutdown-timeout=SECONDS] # Number of seconds to wait for jobs to finish when shutting down before stopping the thread. (env var: GOOD_JOB_SHUTDOWN_TIMEOUT, default: -1 (forever))
   [--enable-cron]              # Whether to run cron process (default: false)
+  [--enable-listen-notify]     # Whether to enqueue and read jobs with Postgres LISTEN/NOTIFY (default: true)
   [--daemonize]                # Run as a background daemon (default: false)
   [--pidfile=PIDFILE]          # Path to write daemonized Process ID (env var: GOOD_JOB_PIDFILE, default: tmp/pids/good_job.pid)
   [--probe-port=PORT]          # Port for http health check (env var: GOOD_JOB_PROBE_PORT, default: nil)
@@ -272,6 +273,7 @@ Available configuration options are:
 - `max_cache` (integer) sets the maximum number of scheduled jobs that will be stored in memory to reduce execution latency when also polling for scheduled jobs. Caching 10,000 scheduled jobs uses approximately 20MB of memory. You can also set this with the environment variable `GOOD_JOB_MAX_CACHE`.
 - `shutdown_timeout` (integer) number of seconds to wait for jobs to finish when shutting down before stopping the thread. Defaults to forever: `-1`. You can also set this with the environment variable `GOOD_JOB_SHUTDOWN_TIMEOUT`.
 - `enable_cron` (boolean) whether to run cron process. Defaults to `false`. You can also set this with the environment variable `GOOD_JOB_ENABLE_CRON`.
+- `enable_listen_notify` (boolean) whether to enqueue and read jobs with Postgres LISTEN/NOTIFY. Defaults to `true`. You can also set this with the environment variable `GOOD_JOB_ENABLE_LISTEN_NOTIFY`.
 - `cron` (hash) cron configuration. Defaults to `{}`. You can also set this as a JSON string with the environment variable `GOOD_JOB_CRON`
 - `cleanup_discarded_jobs` (boolean) whether to destroy discarded jobs when cleaning up preserved jobs using the `$ good_job cleanup_preserved_jobs` CLI command or calling `GoodJob.cleanup_preserved_jobs`. Defaults to `true`. Can also be set with  the environment variable `GOOD_JOB_CLEANUP_DISCARDED_JOBS`. _This configuration is only used when {GoodJob.preserve_job_records} is `true`._
 - `cleanup_preserved_jobs_before_seconds_ago` (integer) number of seconds to preserve jobs when using the `$ good_job cleanup_preserved_jobs` CLI command or calling `GoodJob.cleanup_preserved_jobs`. Defaults to `1209600` (14 days). Can also be set with  the environment variable `GOOD_JOB_CLEANUP_PRESERVED_JOBS_BEFORE_SECONDS_AGO`.  _This configuration is only used when {GoodJob.preserve_job_records} is `true`._

data/lib/good_job/active_job_extensions/notify_options.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+module GoodJob
+  module ActiveJobExtensions
+    # Allows configuring whether GoodJob should emit a NOTIFY event when a job is enqueued.
+    # Configuration will apply either globally to the Job Class, or individually to jobs
+    # on initial enqueue and subsequent retries.
+    #
+    # @example
+    #   # Include the concern to your job class:
+    #   class MyJob < ApplicationJob
+    #     include GoodJob::ActiveJobExtensions::Notify
+    #     self.good_job_notify = false
+    #   end
+    #
+    #   # Or, configure jobs individually to not notify:
+    #   MyJob.set(good_job_notify: false).perform_later
+    #
+    module NotifyOptions
+      extend ActiveSupport::Concern
+
+      module Prepends
+        def enqueue(options = {})
+          self.good_job_notify = options[:good_job_notify] if options.key?(:good_job_notify)
+          super
+        end
+
+        def serialize
+          super.tap do |job_data|
+            # Only serialize the value if present to reduce the size of the serialized job
+            job_data["good_job_notify"] = good_job_notify unless good_job_notify.nil?
+          end
+        end
+
+        def deserialize(job_data)
+          super
+          self.good_job_notify = job_data["good_job_notify"]
+        end
+      end
+
+      included do
+        prepend Prepends
+        class_attribute :good_job_notify, instance_accessor: false, instance_predicate: false, default: nil
+        attr_accessor :good_job_notify
+      end
+    end
+  end
+end

data/lib/good_job/adapter.rb

@@ -90,14 +90,20 @@ module GoodJob
         inline_executions.each(&:advisory_unlock)
       end
 
-      executions.reject(&:finished_at).group_by(&:queue_name).each do |queue_name, executions_by_queue|
-        executions_by_queue.group_by(&:scheduled_at).each do |scheduled_at, executions_by_queue_and_scheduled_at|
-          # TODO: have Adapter#create_thread handle state[:count] values
-          state = { queue_name: queue_name, count: executions_by_queue_and_scheduled_at.size }
-          state[:scheduled_at] = scheduled_at if scheduled_at
-
-          executed_locally = execute_async? && @scheduler&.create_thread(state)
-          Notifier.notify(state) unless executed_locally
+      non_inline_executions = executions.reject(&:finished_at)
+      if non_inline_executions.any?
+        job_id_to_active_jobs = active_jobs.index_by(&:job_id)
+        non_inline_executions.group_by(&:queue_name).each do |queue_name, executions_by_queue|
+          executions_by_queue.group_by(&:scheduled_at).each do |scheduled_at, executions_by_queue_and_scheduled_at|
+            state = { queue_name: queue_name, count: executions_by_queue_and_scheduled_at.size }
+            state[:scheduled_at] = scheduled_at if scheduled_at
+
+            executed_locally = execute_async? && @scheduler&.create_thread(state)
+            unless executed_locally
+              state[:count] = job_id_to_active_jobs.values_at(*executions_by_queue_and_scheduled_at.map(&:active_job_id)).count { |active_job| send_notify?(active_job) }
+              Notifier.notify(state) unless state[:count].zero?
+            end
+          end
         end
       end
 
@@ -136,7 +142,7 @@ module GoodJob
         job_state[:scheduled_at] = execution.scheduled_at if execution.scheduled_at
 
         executed_locally = execute_async? && @scheduler&.create_thread(job_state)
-        Notifier.notify(job_state) unless executed_locally
+        Notifier.notify(job_state) if !executed_locally && send_notify?(active_job)
       end
 
       execution
@@ -193,7 +199,7 @@ module GoodJob
     def start_async
       return unless execute_async?
 
-      @notifier = GoodJob::Notifier.new
+      @notifier = GoodJob::Notifier.new(enable_listening: GoodJob.configuration.enable_listen_notify)
       @poller = GoodJob::Poller.new(poll_interval: GoodJob.configuration.poll_interval)
       @scheduler = GoodJob::Scheduler.from_configuration(GoodJob.configuration, warm_cache_on_initialize: true)
       @notifier.recipients << [@scheduler, :create_thread]
@@ -226,5 +232,12 @@ module GoodJob
           (Concurrent.on_jruby? && self_caller.grep(%r{jruby/rack/rails_booter}).any?) # EXAMPLE: uri:classloader:/jruby/rack/rails_booter.rb:83:in `load_environment'
       end
     end
+
+    def send_notify?(active_job)
+      return true unless active_job.respond_to?(:good_job_notify)
+      return false unless GoodJob.configuration.enable_listen_notify
+
+      !(active_job.good_job_notify == false || (active_job.class.good_job_notify == false && active_job.good_job_notify.nil?))
+    end
   end
 end

data/lib/good_job/cli.rb

@@ -95,7 +95,7 @@ module GoodJob
 
       Daemon.new(pidfile: configuration.pidfile).daemonize if configuration.daemonize?
 
-      notifier = GoodJob::Notifier.new
+      notifier = GoodJob::Notifier.new(enable_listening: GoodJob.configuration.enable_listen_notify)
       poller = GoodJob::Poller.new(poll_interval: configuration.poll_interval)
       scheduler = GoodJob::Scheduler.from_configuration(configuration, warm_cache_on_initialize: true)
       notifier.recipients << [scheduler, :create_thread]

data/lib/good_job/configuration.rb

@@ -26,6 +26,8 @@ module GoodJob
     DEFAULT_SHUTDOWN_TIMEOUT = -1
     # Default to not running cron
     DEFAULT_ENABLE_CRON = false
+    # Default to enabling LISTEN/NOTIFY
+    DEFAULT_ENABLE_LISTEN_NOTIFY = true
 
     def self.validate_execution_mode(execution_mode)
       raise ArgumentError, "GoodJob execution mode must be one of #{EXECUTION_MODES.join(', ')}. It was '#{execution_mode}' which is not valid." unless execution_mode.in?(EXECUTION_MODES)
@@ -331,6 +333,14 @@ module GoodJob
         env['GOOD_JOB_PROBE_PORT']
     end
 
+    def enable_listen_notify
+      return options[:enable_listen_notify] unless options[:enable_listen_notify].nil?
+      return rails_config[:enable_listen_notify] unless rails_config[:enable_listen_notify].nil?
+      return ActiveModel::Type::Boolean.new.cast(env['GOOD_JOB_ENABLE_LISTEN_NOTIFY']) unless env['GOOD_JOB_ENABLE_LISTEN_NOTIFY'].nil?
+
+      DEFAULT_ENABLE_LISTEN_NOTIFY
+    end
+
     private
 
     def rails_config

data/lib/good_job/notifier.rb

@@ -68,11 +68,14 @@ module GoodJob # :nodoc:
     attr_reader :recipients
 
     # @param recipients [Array<#call, Array(Object, Symbol)>]
-    def initialize(*recipients)
+    # @param enable_listening [true, false]
+    def initialize(*recipients, enable_listening: true)
       @recipients = Concurrent::Array.new(recipients)
+      @connected = Concurrent::AtomicBoolean.new(false)
       @listening = Concurrent::AtomicBoolean.new(false)
       @connection_errors_count = Concurrent::AtomicFixnum.new(0)
       @connection_errors_reported = Concurrent::AtomicBoolean.new(false)
+      @enable_listening = enable_listening
 
       self.class.instances << self
 
@@ -80,7 +83,13 @@ module GoodJob # :nodoc:
       listen
     end
 
-    # Tests whether the notifier is active and listening for new messages.
+    # Tests whether the notifier is active and has acquired a dedicated database connection.
+    # @return [true, false, nil]
+    def connected?
+      @connected.true?
+    end
+
+    # Tests whether the notifier is listening for new messages.
     # @return [true, false, nil]
     def listening?
       @listening.true?
@@ -165,15 +174,17 @@ module GoodJob # :nodoc:
     end
 
     def listen(delay: 0)
-      future = Concurrent::ScheduledTask.new(delay, args: [@recipients, executor, @listening], executor: @executor) do |thr_recipients, thr_executor, thr_listening|
+      future = Concurrent::ScheduledTask.new(delay, args: [@recipients, executor, @enable_listening, @listening], executor: @executor) do |thr_recipients, thr_executor, thr_enable_listening, thr_listening|
         with_connection do
           begin
             Rails.application.executor.wrap do
               run_callbacks :listen do
-                ActiveSupport::Notifications.instrument("notifier_listen.good_job") do
-                  connection.execute("LISTEN #{CHANNEL}")
+                if thr_enable_listening
+                  ActiveSupport::Notifications.instrument("notifier_listen.good_job") do
+                    connection.execute("LISTEN #{CHANNEL}")
+                    thr_listening.make_true
+                  end
                 end
-                thr_listening.make_true
               end
             end
 
@@ -195,9 +206,11 @@ module GoodJob # :nodoc:
         ensure
           Rails.application.executor.wrap do
             run_callbacks :unlisten do
-              thr_listening.make_false
-              ActiveSupport::Notifications.instrument("notifier_unlisten.good_job") do
-                connection.execute("UNLISTEN *")
+              if thr_enable_listening
+                ActiveSupport::Notifications.instrument("notifier_unlisten.good_job") do
+                  thr_listening.make_false
+                  connection.execute("UNLISTEN *")
+                end
               end
             end
           end
@@ -215,20 +228,22 @@ module GoodJob # :nodoc:
         end
       end
       connection.execute("SET application_name = #{connection.quote(self.class.name)}")
+      @connected.make_true
 
       yield
     ensure
+      @connected.make_false
       connection&.disconnect!
       self.connection = nil
     end
 
     def wait_for_notify
       raw_connection = connection.raw_connection
-      if raw_connection.respond_to?(:wait_for_notify)
+      if @enable_listening && raw_connection.respond_to?(:wait_for_notify)
         raw_connection.wait_for_notify(WAIT_INTERVAL) do |channel, _pid, payload|
           yield(channel, payload)
         end
-      elsif raw_connection.respond_to?(:jdbc_connection)
+      elsif @enable_listening && raw_connection.respond_to?(:jdbc_connection)
         raw_connection.execute_query("SELECT 1")
         notifications = raw_connection.jdbc_connection.getNotifications
         Array(notifications).each do |notification|

data/lib/good_job/version.rb

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

data/lib/good_job.rb

@@ -7,8 +7,9 @@ require "good_job/engine"
 
 require "good_job/adapter"
 require "active_job/queue_adapters/good_job_adapter"
-require "good_job/active_job_extensions/concurrency"
 require "good_job/active_job_extensions/batches"
+require "good_job/active_job_extensions/concurrency"
+require "good_job/active_job_extensions/notify_options"
 
 require "good_job/assignable_connection"
 require "good_job/bulk"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 3.10.1
+  version: 3.11.0
 platform: ruby
 authors:
 - Ben Sheldon
@@ -403,6 +403,7 @@ files:
 - lib/good_job.rb
 - lib/good_job/active_job_extensions/batches.rb
 - lib/good_job/active_job_extensions/concurrency.rb
+- lib/good_job/active_job_extensions/notify_options.rb
 - lib/good_job/adapter.rb
 - lib/good_job/assignable_connection.rb
 - lib/good_job/bulk.rb