good_job 3.19.3 → 3.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb4912917e34844ff32647321159e6c45ea03d962d94b10ee28186cceab9371b
-  data.tar.gz: 1fb418aa9060e1e5781e044fb33ea27be557e1cc171cb82fe78fc1cb345c3e48
+  metadata.gz: 62d33742278a734dd514fc3147abd1393ee62c3fd644c4c065b10c4fc6a24755
+  data.tar.gz: 83d56214ec454cbc3d910d4cbefb0413877ca3b18577168c0d9b9b456385a7a3
 SHA512:
-  metadata.gz: ad52e1fe639545fcf8d3ef4d3a3e70727493edf397127bda1a68b10535511033620cb7dcc3945c352a1203e765882ac741bf4c4333d9a976f2e9863dc4ce1c11
-  data.tar.gz: 6a6851b391e7651f404ddf42c067d5e2d74380775514799ac159c93f1d63748dc4025fb89e89c1af6f5db8cd14acf3f071dc6354bd3956c8ba7abe0eb29a2674
+  metadata.gz: 90a3730d4989f26837b0ac9cd8f15ea3029f0c1c474159a4798a58d695153cb2067c336d382f971ba42a6faf371f677f7b295741c8ab1557add7c6b403a1fa94
+  data.tar.gz: 684e5d8473b4f460707394fd670067b0aaf7a2749ed525be2893967c0953ed1c5afe4f35e8acfce4acaa7f7fa39ae00d16394b38d186a11f7eb8812839d65ff3

data/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Changelog
 
+## [v3.20.0](https://github.com/bensheldon/good_job/tree/v3.20.0) (2023-10-23)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v3.19.4...v3.20.0)
+
+**Closed issues:**
+
+- Dashboard blocked in iframe tag [\#1111](https://github.com/bensheldon/good_job/issues/1111)
+- PG::ConnectionBad: PQsocket\(\) can't get socket descriptor [\#1100](https://github.com/bensheldon/good_job/issues/1100)
+
+**Merged pull requests:**
+
+- Wrap Adapter enqueue methods and Batch callbacks with Rails Reloader; verify in tests that no Advisory locks remain at database connection check-in  [\#1124](https://github.com/bensheldon/good_job/pull/1124) ([bensheldon](https://github.com/bensheldon))
+- Run all RSpec examples within a Rails Executor [\#1122](https://github.com/bensheldon/good_job/pull/1122) ([bensheldon](https://github.com/bensheldon))
+- Print better debugging for retained advisory locks in test [\#1121](https://github.com/bensheldon/good_job/pull/1121) ([bensheldon](https://github.com/bensheldon))
+- Replace Heroku-specific Rake tasks with `db:prepare` now that Demo is upgraded to Rails 7.1 [\#1120](https://github.com/bensheldon/good_job/pull/1120) ([bensheldon](https://github.com/bensheldon))
+- Do not error debug logs if `pg_stat_activity` join is empty [\#1119](https://github.com/bensheldon/good_job/pull/1119) ([bensheldon](https://github.com/bensheldon))
+- Remove pinned psych version [\#1114](https://github.com/bensheldon/good_job/pull/1114) ([bensheldon](https://github.com/bensheldon))
+- Remove `pg_advisory_unlock_all()` after job is run; only verify blank `finished_at` \(and not lock presence\) before performing job [\#1113](https://github.com/bensheldon/good_job/pull/1113) ([bensheldon](https://github.com/bensheldon))
+- Update docs url [\#1112](https://github.com/bensheldon/good_job/pull/1112) ([ur5us](https://github.com/ur5us))
+- Pin psych gem 5.1.0 [\#1108](https://github.com/bensheldon/good_job/pull/1108) ([bensheldon](https://github.com/bensheldon))
+- Add sampling for Skylight traces on Demo [\#1107](https://github.com/bensheldon/good_job/pull/1107) ([bensheldon](https://github.com/bensheldon))
+- Add Rails 7.1 to test matrix [\#1105](https://github.com/bensheldon/good_job/pull/1105) ([bensheldon](https://github.com/bensheldon))
+- Add spec to verify unhandled thread errors are reported [\#1104](https://github.com/bensheldon/good_job/pull/1104) ([bensheldon](https://github.com/bensheldon))
+- Update Codespace configuration [\#1101](https://github.com/bensheldon/good_job/pull/1101) ([bensheldon](https://github.com/bensheldon))
+
+## [v3.19.4](https://github.com/bensheldon/good_job/tree/v3.19.4) (2023-10-04)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v3.19.3...v3.19.4)
+
+**Closed issues:**
+
+- Including GoodJob::ActiveJobExtensions::Concurrency triggers rails deprecation notice [\#1096](https://github.com/bensheldon/good_job/issues/1096)
+- Add retries exhaused callback [\#1080](https://github.com/bensheldon/good_job/issues/1080)
+
+**Merged pull requests:**
+
+- Address rails 7.1 deprecation when using `ActiveJobExtensions::Concurrency` [\#1097](https://github.com/bensheldon/good_job/pull/1097) ([Earlopain](https://github.com/Earlopain))
+
 ## [v3.19.3](https://github.com/bensheldon/good_job/tree/v3.19.3) (2023-09-28)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v3.19.2...v3.19.3)

data/README.md

@@ -816,7 +816,7 @@ GoodJob.on_thread_error = -> (exception) { Rails.error.report(exception) }
 
 By default, GoodJob relies on ActiveJob's retry functionality.
 
-ActiveJob can be configured to retry an infinite number of times, with an exponential backoff. Using ActiveJob's `retry_on` prevents exceptions from reaching GoodJob:
+ActiveJob can be configured to retry an infinite number of times, with a polynomial backoff. Using ActiveJob's `retry_on` prevents exceptions from reaching GoodJob:
 
 ```ruby
 class ApplicationJob < ActiveJob::Base

data/app/models/concerns/good_job/advisory_lockable.rb

@@ -53,7 +53,7 @@ module GoodJob
         composed_cte = Arel::Nodes::As.new(cte_table, Arel::Nodes::SqlLiteral.new([cte_type, "(", cte_query.to_sql, ")"].join(' ')))
         query = cte_table.project(cte_table[:id])
                          .with(composed_cte)
-                         .where(Arel.sql(sanitize_sql_for_conditions(["#{function}(('x' || substr(md5(:table_name || '-' || #{connection.quote_table_name(cte_table.name)}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(64)::bigint)", { table_name: table_name }])))
+                         .where(Arel.sql("#{function}(('x' || substr(md5(#{connection.quote(table_name)} || '-' || #{connection.quote_table_name(cte_table.name)}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(64)::bigint)"))
 
         limit = original_query.arel.ast.limit
         query.limit = limit.value if limit.present?
@@ -74,14 +74,12 @@ module GoodJob
       # @example Get the records that have a session awaiting a lock:
       #   MyLockableRecord.joins_advisory_locks.where("pg_locks.granted = ?", false)
       scope :joins_advisory_locks, (lambda do |column: _advisory_lockable_column|
-        join_sql = <<~SQL.squish
+        joins(<<~SQL.squish)
           LEFT JOIN pg_locks ON pg_locks.locktype = 'advisory'
             AND pg_locks.objsubid = 1
-            AND pg_locks.classid = ('x' || substr(md5(:table_name || '-' || #{quoted_table_name}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(32)::int
-            AND pg_locks.objid = (('x' || substr(md5(:table_name || '-' || #{quoted_table_name}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(64) << 32)::bit(32)::int
+            AND pg_locks.classid = ('x' || substr(md5(#{connection.quote(table_name)} || '-' || #{quoted_table_name}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(32)::int
+            AND pg_locks.objid = (('x' || substr(md5(#{connection.quote(table_name)} || '-' || #{quoted_table_name}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(64) << 32)::bit(32)::int
         SQL
-
-        joins(sanitize_sql_for_conditions([join_sql, { table_name: table_name }]))
       end)
 
       # Joins the current query with Postgres's +pg_locks+ table AND SELECTs the resulting columns
@@ -151,6 +149,10 @@ module GoodJob
       # can (as in {Lockable.advisory_lock}) and only pass those that could be
       # locked to the block.
       #
+      # If the Active Record Relation has WHERE conditions that have the potential
+      # to be updated/changed elsewhere, be sure to verify the conditions are still
+      # satisfied, or check the lock status, as an unlocked and out-of-date record could be returned.
+      #
       # @param column [String, Symbol]  name of advisory lock or unlock function
       # @param function [String, Symbol] Postgres Advisory Lock function name to use
       # @param unlock_session [Boolean] Whether to unlock all advisory locks in the session afterwards

data/app/models/good_job/batch.rb

@@ -101,9 +101,13 @@ module GoodJob
 
       active_jobs = add(active_jobs, &block)
 
-      record.with_advisory_lock(function: "pg_advisory_lock") do
-        record.update!(enqueued_at: Time.current)
-        record._continue_discard_or_finish(lock: false)
+      Rails.application.reloader.wrap do
+        record.with_advisory_lock(function: "pg_advisory_lock") do
+          record.update!(enqueued_at: Time.current)
+
+          # During inline execution, this could enqueue and execute further jobs
+          record._continue_discard_or_finish(lock: false)
+        end
       end
 
       active_jobs

data/app/models/good_job/execution.rb

@@ -256,12 +256,13 @@ module GoodJob
     def self.perform_with_advisory_lock(parsed_queues: nil, queue_select_limit: nil)
       execution = nil
       result = nil
-      unfinished.dequeueing_ordered(parsed_queues).only_scheduled.limit(1).with_advisory_lock(unlock_session: true, select_limit: queue_select_limit) do |executions|
+      unfinished.dequeueing_ordered(parsed_queues).only_scheduled.limit(1).with_advisory_lock(select_limit: queue_select_limit) do |executions|
         execution = executions.first
         break if execution.blank?
 
         unless execution.executable?
           result = ExecutionResult.new(value: nil, unexecutable: true)
+          execution = nil
           break
         end
 
@@ -491,7 +492,9 @@ module GoodJob
     # Tests whether this job is safe to be executed by this thread.
     # @return [Boolean]
     def executable?
-      self.class.unscoped.unfinished.owns_advisory_locked.exists?(id: id)
+      reload.finished_at.blank?
+    rescue ActiveRecord::RecordNotFound
+      false
     end
 
     def make_discrete

data/lib/good_job/active_job_extensions/concurrency.rb

@@ -36,10 +36,16 @@ module GoodJob
           end
         end
 
+        wait_key = if ActiveJob.gem_version >= Gem::Version.new("7.1.0.a")
+                     :polynomially_longer
+                   else
+                     :exponentially_longer
+                   end
+
         retry_on(
           GoodJob::ActiveJobExtensions::Concurrency::ConcurrencyExceededError,
           attempts: Float::INFINITY,
-          wait: :exponentially_longer
+          wait: wait_key
         )
 
         before_perform do |job|

data/lib/good_job/adapter.rb

@@ -49,74 +49,76 @@ module GoodJob
       active_jobs = Array(active_jobs)
       return 0 if active_jobs.empty?
 
-      current_time = Time.current
-      executions = active_jobs.map do |active_job|
-        GoodJob::Execution.build_for_enqueue(active_job).tap do |execution|
-          if GoodJob::Execution.discrete_support?
-            execution.make_discrete
-            execution.scheduled_at = current_time if execution.scheduled_at == execution.created_at
-          end
+      Rails.application.reloader.wrap do
+        current_time = Time.current
+        executions = active_jobs.map do |active_job|
+          GoodJob::Execution.build_for_enqueue(active_job).tap do |execution|
+            if GoodJob::Execution.discrete_support?
+              execution.make_discrete
+              execution.scheduled_at = current_time if execution.scheduled_at == execution.created_at
+            end
 
-          execution.created_at = current_time
-          execution.updated_at = current_time
+            execution.created_at = current_time
+            execution.updated_at = current_time
+          end
         end
-      end
 
-      inline_executions = []
-      GoodJob::Execution.transaction(requires_new: true, joinable: false) do
-        execution_attributes = executions.map do |execution|
-          if GoodJob::Execution.error_event_migrated?
-            execution.attributes
-          else
-            execution.attributes.except('error_event')
+        inline_executions = []
+        GoodJob::Execution.transaction(requires_new: true, joinable: false) do
+          execution_attributes = executions.map do |execution|
+            if GoodJob::Execution.error_event_migrated?
+              execution.attributes
+            else
+              execution.attributes.except('error_event')
+            end
           end
-        end
 
-        results = GoodJob::Execution.insert_all(execution_attributes, returning: %w[id active_job_id]) # rubocop:disable Rails/SkipsModelValidations
+          results = GoodJob::Execution.insert_all(execution_attributes, returning: %w[id active_job_id]) # rubocop:disable Rails/SkipsModelValidations
 
-        job_id_to_provider_job_id = results.each_with_object({}) { |result, hash| hash[result['active_job_id']] = result['id'] }
-        active_jobs.each do |active_job|
-          active_job.provider_job_id = job_id_to_provider_job_id[active_job.job_id]
-          active_job.successfully_enqueued = active_job.provider_job_id.present? if active_job.respond_to?(:successfully_enqueued=)
-        end
-        executions.each do |execution|
-          execution.instance_variable_set(:@new_record, false) if job_id_to_provider_job_id[execution.active_job_id]
-        end
-        executions = executions.select(&:persisted?) # prune unpersisted executions
+          job_id_to_provider_job_id = results.each_with_object({}) { |result, hash| hash[result['active_job_id']] = result['id'] }
+          active_jobs.each do |active_job|
+            active_job.provider_job_id = job_id_to_provider_job_id[active_job.job_id]
+            active_job.successfully_enqueued = active_job.provider_job_id.present? if active_job.respond_to?(:successfully_enqueued=)
+          end
+          executions.each do |execution|
+            execution.instance_variable_set(:@new_record, false) if job_id_to_provider_job_id[execution.active_job_id]
+          end
+          executions = executions.select(&:persisted?) # prune unpersisted executions
 
-        if execute_inline?
-          inline_executions = executions.select { |execution| (execution.scheduled_at.nil? || execution.scheduled_at <= Time.current) }
-          inline_executions.each(&:advisory_lock!)
+          if execute_inline?
+            inline_executions = executions.select { |execution| (execution.scheduled_at.nil? || execution.scheduled_at <= Time.current) }
+            inline_executions.each(&:advisory_lock!)
+          end
         end
-      end
 
-      begin
-        until inline_executions.empty?
-          begin
-            inline_execution = inline_executions.shift
-            inline_result = inline_execution.perform
-          ensure
-            inline_execution.advisory_unlock
-            inline_execution.run_callbacks(:perform_unlocked)
+        begin
+          until inline_executions.empty?
+            begin
+              inline_execution = inline_executions.shift
+              inline_result = inline_execution.perform
+            ensure
+              inline_execution.advisory_unlock
+              inline_execution.run_callbacks(:perform_unlocked)
+            end
+            raise inline_result.unhandled_error if inline_result.unhandled_error
           end
-          raise inline_result.unhandled_error if inline_result.unhandled_error
+        ensure
+          inline_executions.each(&:advisory_unlock)
         end
-      ensure
-        inline_executions.each(&:advisory_unlock)
-      end
 
-      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? && @capsule&.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?
+        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? && @capsule&.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
@@ -137,30 +139,32 @@ module GoodJob
       # job there to be enqueued using enqueue_all
       return if GoodJob::Bulk.capture(active_job, queue_adapter: self)
 
-      will_execute_inline = execute_inline? && (scheduled_at.nil? || scheduled_at <= Time.current)
-      execution = GoodJob::Execution.enqueue(
-        active_job,
-        scheduled_at: scheduled_at,
-        create_with_advisory_lock: will_execute_inline
-      )
+      Rails.application.reloader.wrap do
+        will_execute_inline = execute_inline? && (scheduled_at.nil? || scheduled_at <= Time.current)
+        execution = GoodJob::Execution.enqueue(
+          active_job,
+          scheduled_at: scheduled_at,
+          create_with_advisory_lock: will_execute_inline
+        )
 
-      if will_execute_inline
-        begin
-          result = execution.perform
-        ensure
-          execution.advisory_unlock
-          execution.run_callbacks(:perform_unlocked)
+        if will_execute_inline
+          begin
+            result = execution.perform
+          ensure
+            execution.advisory_unlock
+            execution.run_callbacks(:perform_unlocked)
+          end
+          raise result.unhandled_error if result.unhandled_error
+        else
+          job_state = { queue_name: execution.queue_name }
+          job_state[:scheduled_at] = execution.scheduled_at if execution.scheduled_at
+
+          executed_locally = execute_async? && @capsule&.create_thread(job_state)
+          Notifier.notify(job_state) if !executed_locally && send_notify?(active_job)
         end
-        raise result.unhandled_error if result.unhandled_error
-      else
-        job_state = { queue_name: execution.queue_name }
-        job_state[:scheduled_at] = execution.scheduled_at if execution.scheduled_at
 
-        executed_locally = execute_async? && @capsule&.create_thread(job_state)
-        Notifier.notify(job_state) if !executed_locally && send_notify?(active_job)
+        execution
       end
-
-      execution
     end
 
     # Shut down the thread pool executors.

data/lib/good_job/version.rb

@@ -2,7 +2,7 @@
 
 module GoodJob
   # GoodJob gem version.
-  VERSION = '3.19.3'
+  VERSION = '3.20.0'
 
   # GoodJob version as Gem::Version object
   GEM_VERSION = Gem::Version.new(VERSION)

data/lib/good_job.rb

@@ -237,7 +237,7 @@ module GoodJob
   def self.perform_inline(queue_string = "*")
     job_performer = JobPerformer.new(queue_string)
     loop do
-      result = job_performer.next
+      result = Rails.application.reloader.wrap { job_performer.next }
       break unless result
       raise result.unhandled_error if result.unhandled_error
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 3.19.3
+  version: 3.20.0
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-28 00:00:00.000000000 Z
+date: 2023-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -384,7 +384,7 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/bensheldon/good_job/issues
   changelog_uri: https://github.com/bensheldon/good_job/blob/master/CHANGELOG.md
-  documentation_uri: https://rdoc.info/github/bensheldon/good_job
+  documentation_uri: https://rubydoc.info/gems/good_job
   homepage_uri: https://github.com/bensheldon/good_job
   source_code_uri: https://github.com/bensheldon/good_job
   rubygems_mfa_required: 'true'