good_job 4.0.3 → 4.1.1

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

@@ -49,8 +49,8 @@ module GoodJob
 
         lock_condition = "#{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)"
         query = cte_table.project(cte_table[:id])
-                         .with(composed_cte)
-                         .where(defined?(Arel::Nodes::BoundSqlLiteral) ? Arel::Nodes::BoundSqlLiteral.new(lock_condition, [], {}) : Arel::Nodes::SqlLiteral.new(lock_condition))
+                  .with(composed_cte)
+                  .where(defined?(Arel::Nodes::BoundSqlLiteral) ? Arel::Nodes::BoundSqlLiteral.new(lock_condition, [], {}) : Arel::Nodes::SqlLiteral.new(lock_condition))
 
         limit = original_query.arel.ast.limit
         query.limit = limit.value if limit.present?
@@ -174,8 +174,11 @@ module GoodJob
           if unlock_session
             advisory_unlock_session
           else
-            records.each do |record|
-              record.advisory_unlock(key: record.lockable_column_key(column: column), function: advisory_unlockable_function(function))
+            unlock_function = advisory_unlockable_function(function)
+            if unlock_function
+              records.each do |record|
+                record.advisory_unlock(key: record.lockable_column_key(column: column), function: unlock_function)
+              end
             end
           end
         end
@@ -209,7 +212,8 @@ module GoodJob
         begin
           yield
         ensure
-          advisory_unlock_key(key, function: advisory_unlockable_function(function))
+          unlock_function = advisory_unlockable_function(function)
+          advisory_unlock_key(key, function: unlock_function) if unlock_function
         end
       end
 
@@ -220,6 +224,9 @@ module GoodJob
       # @param function [String, Symbol] Postgres Advisory Lock function name to use
       # @return [Boolean] whether the lock was released.
       def advisory_unlock_key(key, function: advisory_unlockable_function)
+        raise ArgumentError, "Cannot unlock transactional locks" if function.include? "_xact_"
+        raise ArgumentError, "No unlock function provide" if function.blank?
+
         query = <<~SQL.squish
           SELECT #{function}(('x'||substr(md5($1::text), 1, 16))::bit(64)::bigint) AS unlocked
         SQL
@@ -284,6 +291,8 @@ module GoodJob
       # @param function [String, Symbol] name of advisory lock or unlock function
       # @return [Boolean]
       def advisory_unlockable_function(function = advisory_lockable_function)
+        return nil if function.include? "_xact_" # Cannot unlock transactional locks
+
         function.to_s.sub("_lock", "_unlock").sub("_try_", "_")
       end
 
@@ -358,7 +367,8 @@ module GoodJob
       begin
         yield
       ensure
-        advisory_unlock(key: key, function: self.class.advisory_unlockable_function(function))
+        unlock_function = self.class.advisory_unlockable_function(function)
+        advisory_unlock(key: key, function: unlock_function) if unlock_function
       end
     end
 
@@ -403,7 +413,7 @@ module GoodJob
     # @param key [String, Symbol] Key to lock against
     # @param function [String, Symbol] Postgres Advisory Lock function name to use
     # @return [void]
-    def advisory_unlock!(key: lockable_key, function: self.class.advisory_unlockable_function(advisory_lockable_function))
+    def advisory_unlock!(key: lockable_key, function: self.class.advisory_unlockable_function)
       advisory_unlock(key: key, function: function) while advisory_locked?
     end
 

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

@@ -5,41 +5,20 @@ module GoodJob
   module ErrorEvents
     extend ActiveSupport::Concern
 
-    ERROR_EVENTS = [
-      ERROR_EVENT_INTERRUPTED = 'interrupted',
-      ERROR_EVENT_UNHANDLED = 'unhandled',
-      ERROR_EVENT_HANDLED = 'handled',
-      ERROR_EVENT_RETRIED = 'retried',
-      ERROR_EVENT_RETRY_STOPPED = 'retry_stopped',
-      ERROR_EVENT_DISCARDED = 'discarded',
-    ].freeze
-
-    ERROR_EVENT_ENUMS = {
-      ERROR_EVENT_INTERRUPTED => 0,
-      ERROR_EVENT_UNHANDLED => 1,
-      ERROR_EVENT_HANDLED => 2,
-      ERROR_EVENT_RETRIED => 3,
-      ERROR_EVENT_RETRY_STOPPED => 4,
-      ERROR_EVENT_DISCARDED => 5,
-    }.freeze
-
-    # TODO: GoodJob v4 can make this an `enum` once migrations are guaranteed.
-    def error_event
-      return unless self.class.columns_hash['error_event']
-
-      enum = read_attribute(:error_event)
-      return unless enum
-
-      ERROR_EVENT_ENUMS.key(enum)
-    end
-
-    def error_event=(event)
-      return unless self.class.columns_hash['error_event']
-
-      enum = ERROR_EVENT_ENUMS[event]
-      raise(ArgumentError, "Invalid error_event: #{event}") if event && !enum
-
-      write_attribute(:error_event, enum)
+    included do
+      error_event_enum = {
+        interrupted: 0,
+        unhandled: 1,
+        handled: 2,
+        retried: 3,
+        retry_stopped: 4,
+        discarded: 5,
+      }
+      if Gem::Version.new(Rails.version) >= Gem::Version.new('7.1.0.a')
+        enum :error_event, error_event_enum, validate: { allow_nil: true }
+      else
+        enum error_event: error_event_enum
+      end
     end
   end
 end

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

@@ -16,27 +16,23 @@ module GoodJob
     # @return [Symbol]
     def status
       if finished_at.present?
-        if error.present? && retried_good_job_id.present?
-          :retried
-        elsif error.present? && retried_good_job_id.nil?
+        if error.present?
           :discarded
         else
           :succeeded
         end
-      elsif (scheduled_at || created_at) > DateTime.current
-        if serialized_params.fetch('executions', 0) > 1
-          :retried
-        else
-          :scheduled
-        end
-      elsif running?
+      elsif performed_at.present?
         :running
-      else
+      elsif (scheduled_at || created_at) <= DateTime.current
         :queued
+      elsif error.present?
+        :retried
+      else
+        :scheduled
       end
     end
 
-    # The last relevant timestamp for this execution
+    # The last relevant timestamp for this job
     def last_status_at
       finished_at || performed_at || scheduled_at || created_at
     end

data/app/models/good_job/batch.rb

@@ -102,12 +102,17 @@ module GoodJob
       active_jobs = add(active_jobs, &block)
 
       Rails.application.executor.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)
+        buffer = GoodJob::Adapter::InlineBuffer.capture do
+          record.transaction do
+            record.with_advisory_lock(function: "pg_advisory_xact_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
         end
+        buffer.call
       end
 
       active_jobs

data/app/models/good_job/batch_record.rb

@@ -53,22 +53,25 @@ module GoodJob
     end
 
     def _continue_discard_or_finish(execution = nil, lock: true)
-      execution_discarded = execution && execution.error.present? && execution.finished_at && execution.retried_good_job_id.nil?
-      take_advisory_lock(lock) do
-        Batch.within_thread(batch_id: nil, batch_callback_id: id) do
-          reload
-          if execution_discarded && !discarded_at
-            update(discarded_at: Time.current)
-            on_discard.constantize.set(priority: callback_priority, queue: callback_queue_name).perform_later(to_batch, { event: :discard }) if on_discard.present?
-          end
-
-          if enqueued_at && !finished_at && jobs.where(finished_at: nil).count.zero?
-            update(finished_at: Time.current)
-            on_success.constantize.set(priority: callback_priority, queue: callback_queue_name).perform_later(to_batch, { event: :success }) if !discarded_at && on_success.present?
-            on_finish.constantize.set(priority: callback_priority, queue: callback_queue_name).perform_later(to_batch, { event: :finish }) if on_finish.present?
+      execution_discarded = execution && execution.finished_at.present? && execution.error.present?
+      buffer = GoodJob::Adapter::InlineBuffer.capture do
+        advisory_lock_maybe(lock) do
+          Batch.within_thread(batch_id: nil, batch_callback_id: id) do
+            reload
+            if execution_discarded && !discarded_at
+              update(discarded_at: Time.current)
+              on_discard.constantize.set(priority: callback_priority, queue: callback_queue_name).perform_later(to_batch, { event: :discard }) if on_discard.present?
+            end
+
+            if enqueued_at && !finished_at && jobs.where(finished_at: nil).count.zero?
+              update(finished_at: Time.current)
+              on_success.constantize.set(priority: callback_priority, queue: callback_queue_name).perform_later(to_batch, { event: :success }) if !discarded_at && on_success.present?
+              on_finish.constantize.set(priority: callback_priority, queue: callback_queue_name).perform_later(to_batch, { event: :finish }) if on_finish.present?
+            end
           end
         end
       end
+      buffer.call
     end
 
     class PropertySerializer
@@ -100,9 +103,9 @@ module GoodJob
 
     private
 
-    def take_advisory_lock(value, &block)
+    def advisory_lock_maybe(value, &block)
       if value
-        with_advisory_lock(function: "pg_advisory_lock", &block)
+        transaction { with_advisory_lock(function: "pg_advisory_xact_lock", &block) }
       else
         yield
       end

data/app/models/good_job/discrete_execution.rb

@@ -1,64 +1,10 @@
 # frozen_string_literal: true
 
-module GoodJob # :nodoc:
-  class DiscreteExecution < BaseRecord
-    include ErrorEvents
-
-    self.table_name = 'good_job_executions'
-    self.implicit_order_column = 'created_at'
-
-    belongs_to :execution, class_name: 'GoodJob::Execution', foreign_key: 'active_job_id', primary_key: 'active_job_id', inverse_of: :discrete_executions, optional: true
-    belongs_to :job, class_name: 'GoodJob::Job', foreign_key: 'active_job_id', primary_key: 'active_job_id', inverse_of: :discrete_executions, optional: true
-
-    scope :finished, -> { where.not(finished_at: nil) }
-
-    alias_attribute :performed_at, :created_at
-
-    # TODO: Remove when support for Rails 6.1 is dropped
-    attribute :duration, :interval if ActiveJob.version.canonical_segments.take(2) == [6, 1]
-
-    def number
-      serialized_params.fetch('executions', 0) + 1
-    end
-
-    # Time between when this job was expected to run and when it started running
-    def queue_latency
-      created_at - scheduled_at
-    end
-
-    # Monotonic time between when this job started and finished
-    def runtime_latency
-      duration
-    end
-
-    def last_status_at
-      finished_at || created_at
-    end
-
-    def status
-      if finished_at.present?
-        if error.present? && job.finished_at.present?
-          :discarded
-        elsif error.present?
-          :retried
-        else
-          :succeeded
-        end
-      else
-        :running
-      end
-    end
-
-    def display_serialized_params
-      serialized_params.merge({
-                                _good_job_execution: attributes.except('serialized_params'),
-                              })
-    end
-
-    def filtered_error_backtrace
-      Rails.backtrace_cleaner.clean(error_backtrace || [])
-    end
+module GoodJob
+  # Deprecated, use +Execution+ instead.
+  class DiscreteExecution < Execution
   end
-end
 
-ActiveSupport.run_load_hooks(:good_job_execution, GoodJob::DiscreteExecution)
+  include ActiveSupport::Deprecation::DeprecatedConstantAccessor
+  deprecate_constant :DiscreteExecution, 'Execution', deprecator: GoodJob.deprecator
+end

data/app/models/good_job/execution.rb

@@ -1,8 +1,63 @@
 # frozen_string_literal: true
 
-module GoodJob
-  # Created at the time a Job begins executing.
-  # Behavior from +DiscreteExecution+ will be merged into this class.
-  class Execution < DiscreteExecution
+module GoodJob # :nodoc:
+  class Execution < BaseRecord
+    include ErrorEvents
+
+    self.table_name = 'good_job_executions'
+    self.implicit_order_column = 'created_at'
+
+    belongs_to :job, class_name: 'GoodJob::Job', foreign_key: 'active_job_id', primary_key: 'id', inverse_of: :executions, optional: true
+
+    scope :finished, -> { where.not(finished_at: nil) }
+
+    alias_attribute :performed_at, :created_at
+
+    # TODO: Remove when support for Rails 6.1 is dropped
+    attribute :duration, :interval if ActiveJob.version.canonical_segments.take(2) == [6, 1]
+
+    def number
+      serialized_params.fetch('executions', 0) + 1
+    end
+
+    # Time between when this job was expected to run and when it started running
+    def queue_latency
+      created_at - scheduled_at
+    end
+
+    # Monotonic time between when this job started and finished
+    def runtime_latency
+      duration
+    end
+
+    def last_status_at
+      finished_at || created_at
+    end
+
+    def status
+      if finished_at.present?
+        if error.present? && job.finished_at.present?
+          :discarded
+        elsif error.present?
+          :retried
+        else
+          :succeeded
+        end
+      else
+        :running
+      end
+    end
+
+    def display_serialized_params
+      serialized_params.merge({
+                                _good_job_execution: attributes.except('serialized_params'),
+                              })
+    end
+
+    def filtered_error_backtrace
+      Rails.backtrace_cleaner.clean(error_backtrace || [])
+    end
   end
 end
+
+ActiveSupport.run_load_hooks(:good_job_execution, GoodJob::Execution)

data/app/models/good_job/execution_result.rb

@@ -13,22 +13,22 @@ module GoodJob
     attr_reader :error_event
     # @return [Boolean, nil]
     attr_reader :unexecutable
-    # @return [GoodJob::Execution, nil]
-    attr_reader :retried
+    # @return [GoodJob::Job, nil]
+    attr_reader :retried_job
 
     # @param value [Object, nil]
     # @param handled_error [Exception, nil]
     # @param unhandled_error [Exception, nil]
     # @param error_event [String, nil]
     # @param unexecutable [Boolean, nil]
-    # @param retried [Boolean, nil]
-    def initialize(value:, handled_error: nil, unhandled_error: nil, error_event: nil, unexecutable: nil, retried: nil)
+    # @param retried_job [GoodJob::Job, nil]
+    def initialize(value:, handled_error: nil, unhandled_error: nil, error_event: nil, unexecutable: nil, retried_job: nil)
       @value = value
       @handled_error = handled_error
       @unhandled_error = unhandled_error
       @error_event = error_event
       @unexecutable = unexecutable
-      @retried = retried
+      @retried_job = retried_job
     end
 
     # @return [Boolean]
@@ -38,7 +38,7 @@ module GoodJob
 
     # @return [Boolean]
     def retried?
-      retried.present?
+      retried_job.present?
     end
   end
 end