inst-jobs 3.0.8 → 3.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f318e6929f6bf9ab751c02abddf2e89f118eec259bd88597812cc6c71e74aa67
-  data.tar.gz: a142ca5ca379e7278f5746becf058e7ae6e7de5351a0d4ba9ec8e8524ca3ce4f
+  metadata.gz: 372437f25842f762a361453b2846ff561868f4f1783e91b090f2dfc40a8b22f6
+  data.tar.gz: '091128e8391c5acf7f12263887af7f79a7253ed721c39978cd1e1a3fbd93157c'
 SHA512:
-  metadata.gz: 4f819854ff0690e7f3eeb22fe098b1e0f69f06d0447540e40ce66ff4fa1db4c1e5d87fbe134121c8c795782825e2007d02349445b5d315d0afe8b10cf331cdb4
-  data.tar.gz: 880295f1cabdc681f022655a5a481476b204c08d6a21a4f2b36b01544d2d9b2bdac55354c3d972d88760e22d5603b876ed4d41252f1bb146f9399c295ff918c8
+  metadata.gz: 17b6e974d17be8d6ccc6d7f01f2747789b37e48461c862666542957fb299cda415c9aecda8885110254c5d0b7ad45768f6f82c6d85856ab430717a0db89a0db5
+  data.tar.gz: 6e093a601037c58be6d04d96c9b2965099a084285cc7ce80908dfaad1e6515ddd007172b96d2e6e8e3d8f9702d7af4bd5dca82041fa362887ae3d170aed4c5ca

data/db/migrate/20200330230722_add_id_to_get_delayed_jobs_index.rb

@@ -9,7 +9,8 @@ class AddIdToGetDelayedJobsIndex < ActiveRecord::Migration[4.2]
 
   def up
     rename_index :delayed_jobs, "get_delayed_jobs_index", "get_delayed_jobs_index_old"
-    add_index :delayed_jobs, %i[queue priority run_at id],
+    add_index :delayed_jobs,
+              %i[queue priority run_at id],
               algorithm: :concurrently,
               where: "locked_at IS NULL AND next_in_strand",
               name: "get_delayed_jobs_index"
@@ -18,7 +19,8 @@ class AddIdToGetDelayedJobsIndex < ActiveRecord::Migration[4.2]
 
   def down
     rename_index :delayed_jobs, "get_delayed_jobs_index", "get_delayed_jobs_index_old"
-    add_index :delayed_jobs, %i[priority run_at queue],
+    add_index :delayed_jobs,
+              %i[priority run_at queue],
               algorithm: :concurrently,
               where: "locked_at IS NULL AND next_in_strand",
               name: "get_delayed_jobs_index"

data/db/migrate/20200825011002_add_strand_order_override.rb

@@ -10,7 +10,8 @@ class AddStrandOrderOverride < ActiveRecord::Migration[4.2]
   def up
     add_column :delayed_jobs, :strand_order_override, :integer, default: 0, null: false
     add_column :failed_jobs, :strand_order_override, :integer, default: 0, null: false
-    add_index :delayed_jobs, %i[strand strand_order_override id],
+    add_index :delayed_jobs,
+              %i[strand strand_order_override id],
               algorithm: :concurrently,
               where: "strand IS NOT NULL",
               name: "next_in_strand_index"

data/db/migrate/20210809145804_add_n_strand_index.rb

@@ -4,7 +4,8 @@ class AddNStrandIndex < ActiveRecord::Migration[5.2]
   disable_ddl_transaction!
 
   def change
-    add_index :delayed_jobs, %i[strand next_in_strand id],
+    add_index :delayed_jobs,
+              %i[strand next_in_strand id],
               name: "n_strand_index",
               where: "strand IS NOT NULL",
               algorithm: :concurrently

data/db/migrate/20220328152900_add_failed_jobs_indicies.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class AddFailedJobsIndicies < ActiveRecord::Migration[5.2]
+  disable_ddl_transaction!
+
+  def change
+    add_index :failed_jobs, :failed_at, algorithm: :concurrently
+    add_index :failed_jobs, :strand, where: "strand IS NOT NULL", algorithm: :concurrently
+    add_index :failed_jobs, :singleton, where: "singleton IS NOT NULL", algorithm: :concurrently
+    add_index :failed_jobs, :tag, algorithm: :concurrently
+  end
+end

data/db/migrate/20220519204546_add_requeued_job_id_to_failed_jobs.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddRequeuedJobIdToFailedJobs < ActiveRecord::Migration[6.0]
+  def change
+    add_column :failed_jobs, :requeued_job_id, :integer, limit: 8
+  end
+end

data/lib/delayed/backend/active_record.rb

@@ -28,7 +28,11 @@ module Delayed
         scope :next_in_strand_order, -> { order(:strand_order_override, :id) }
 
         def self.reconnect!
-          clear_all_connections!
+          if Rails.version < "6.1"
+            ::ActiveRecord::Base.connection_handler.clear_all_connections!
+          else
+            ::ActiveRecord::Base.connection_handler.clear_all_connections!(nil)
+          end
         end
 
         class << self
@@ -62,11 +66,21 @@ module Delayed
             _write_attribute(column, current_time) unless attribute_present?(column)
           end
 
-          attribute_names = attribute_names_for_partial_writes
+          attribute_names = if Rails.version < "7.0"
+                              attribute_names_for_partial_writes
+                            else
+                              attribute_names_for_partial_inserts
+                            end
           attribute_names = attributes_for_create(attribute_names)
           values = attributes_with_values(attribute_names)
 
-          im = self.class.arel_table.compile_insert(self.class.send(:_substitute_values, values))
+          im = if Rails.version < "7.0"
+                 self.class.arel_table.compile_insert(self.class.send(:_substitute_values, values))
+               else
+                 im = Arel::InsertManager.new(self.class.arel_table)
+                 im.insert(values.transform_keys { |name| self.class.arel_table[name] })
+                 im
+               end
 
           lock_and_insert = values["strand"] && instance_of?(Job)
           # can't use prepared statements if we're combining multiple statemenets
@@ -101,7 +115,8 @@ module Delayed
             # but we don't need to lock when inserting into Delayed::Failed
             if values["strand"] && instance_of?(Job)
               fn_name = connection.quote_table_name("half_md5_as_bigint")
-              sql = "SELECT pg_advisory_xact_lock(#{fn_name}(#{connection.quote(values['strand'])})); #{sql}"
+              quoted_strand = connection.quote((Rails.version < "7.0") ? values["strand"] : values["strand"].value)
+              sql = "SELECT pg_advisory_xact_lock(#{fn_name}(#{quoted_strand})); #{sql}"
             end
             result = connection.execute(sql, "#{self.class} Create")
             self.id = result.values.first&.first
@@ -238,7 +253,7 @@ module Delayed
                            offset = 0,
                            query = nil)
           scope = scope_for_flavor(flavor, query)
-          order = flavor.to_s == "future" ? "run_at" : "id desc"
+          order = (flavor.to_s == "future") ? "run_at" : "id desc"
           scope.order(order).limit(limit).offset(offset).to_a
         end
 
@@ -305,6 +320,24 @@ module Delayed
           scope.order(Arel.sql("COUNT(tag) DESC")).count.map { |t, c| { tag: t, count: c } }
         end
 
+        # given a scope of non-stranded queued jobs, apply a temporary strand to throttle their execution
+        # returns [job_count, new_strand]
+        # (this is designed for use in a Rails console or the Canvas Jobs interface)
+        def self.apply_temp_strand!(job_scope, max_concurrent: 1)
+          if job_scope.where("strand IS NOT NULL OR singleton IS NOT NULL").exists?
+            raise ArgumentError, "can't apply strand to already stranded jobs"
+          end
+
+          job_count = 0
+          new_strand = "tmp_strand_#{SecureRandom.alphanumeric(16)}"
+          ::Delayed::Job.transaction do
+            job_count = job_scope.update_all(strand: new_strand, max_concurrent: max_concurrent, next_in_strand: false)
+            ::Delayed::Job.where(strand: new_strand).order(:id).limit(max_concurrent).update_all(next_in_strand: true)
+          end
+
+          [job_count, new_strand]
+        end
+
         def self.maybe_silence_periodic_log(&block)
           if Settings.silence_periodic_log
             ::ActiveRecord::Base.logger.silence(&block)
@@ -471,7 +504,7 @@ module Delayed
           transaction do
             # for db performance reasons, we only need one process doing this at a time
             # so if we can't get an advisory lock, just abort. we'll try again soon
-            return unless attempt_advisory_lock(prefetch_jobs_lock_name)
+            next unless attempt_advisory_lock(prefetch_jobs_lock_name)
 
             horizon = db_time_now - (Settings.parent_process[:prefetched_jobs_timeout] * 4)
             where("locked_by LIKE 'prefetch:%' AND locked_at<?", horizon).update_all(locked_at: nil, locked_by: nil)
@@ -568,6 +601,30 @@ module Delayed
         class Failed < Job
           include Delayed::Backend::Base
           self.table_name = :failed_jobs
+
+          def self.cleanup_old_jobs(before_date, batch_size: 10_000)
+            where("failed_at < ?", before_date).in_batches(of: batch_size).delete_all
+          end
+
+          def requeue!
+            attrs = attributes.except("id",
+                                      "last_error",
+                                      "locked_at",
+                                      "failed_at",
+                                      "locked_by",
+                                      "original_job_id",
+                                      "requeued_job_id")
+            self.class.transaction do
+              job = nil
+              Delayed::Worker.lifecycle.run_callbacks(:create, attrs.merge("payload_object" => payload_object)) do
+                job = Job.create(attrs)
+              end
+              self.requeued_job_id = job.id
+              save!
+              JobTracking.job_created(job)
+              job
+            end
+          end
         end
       end
     end

data/lib/delayed/backend/base.rb

@@ -62,6 +62,9 @@ module Delayed
           kwargs[:singleton] = singleton
 
           raise ArgumentError, "Only one of strand or n_strand can be used" if strand && n_strand
+          if (strand || n_strand) && run_at && run_at > Job.db_time_now + Settings.stranded_run_at_grace_period
+            raise ArgumentError, "Do not use run_at with strand; you may inadvertently clog the strand"
+          end
 
           # If two parameters are given to n_strand, the first param is used
           # as the strand name for looking up the Setting, while the second
@@ -86,8 +89,12 @@ module Delayed
             kwargs.merge!(n_strand_options(full_strand_name, num_strands))
           end
 
+          job = nil
+
           if singleton
-            job = create(**kwargs)
+            Delayed::Worker.lifecycle.run_callbacks(:create, kwargs) do
+              job = create(**kwargs)
+            end
           elsif batches && strand.nil? && run_at.nil?
             batch_enqueue_args = kwargs.slice(*self.batch_enqueue_args)
             batches[batch_enqueue_args] << kwargs
@@ -95,7 +102,9 @@ module Delayed
           else
             raise ArgumentError, "on_conflict can only be provided with singleton" if kwargs[:on_conflict]
 
-            job = create(**kwargs)
+            Delayed::Worker.lifecycle.run_callbacks(:create, kwargs) do
+              job = create(**kwargs)
+            end
           end
 
           JobTracking.job_created(job)
@@ -107,7 +116,7 @@ module Delayed
         # effectively balancing the load during queueing
         # overwritten in ActiveRecord::Job to use triggers to balance at run time
         def n_strand_options(strand_name, num_strands)
-          strand_num = num_strands > 1 ? rand(num_strands) + 1 : 1
+          strand_num = (num_strands > 1) ? rand(num_strands) + 1 : 1
           strand_name += ":#{strand_num}" if strand_num > 1
           { strand: strand_name }
         end
@@ -208,7 +217,7 @@ module Delayed
       def failed?
         failed_at
       end
-      alias failed failed?
+      alias_method :failed, :failed?
 
       def expired?
         expires_at && (self.class.db_time_now >= expires_at)
@@ -222,8 +231,7 @@ module Delayed
       # Uses an exponential scale depending on the number of failed attempts.
       def reschedule(error = nil, time = nil)
         begin
-          obj = payload_object
-          return_code = obj.on_failure(error) if obj.respond_to?(:on_failure)
+          return_code = invoke_payload_object_cb(:on_failure, error)
         rescue
           # don't allow a failed deserialization to prevent rescheduling
         end
@@ -245,8 +253,7 @@ module Delayed
       def permanent_failure(error)
         begin
           # notify the payload_object of a permanent failure
-          obj = payload_object
-          obj.on_permanent_failure(error) if obj.respond_to?(:on_permanent_failure)
+          invoke_payload_object_cb(:on_permanent_failure, error)
         rescue
           # don't allow a failed deserialization to prevent destroying the job
         end
@@ -263,7 +270,7 @@ module Delayed
       end
 
       def payload_object
-        @payload_object ||= deserialize(self["handler"].untaint)
+        @payload_object ||= deserialize(self["handler"])
       end
 
       def name
@@ -306,7 +313,13 @@ module Delayed
             payload_object.perform
           ensure
             Delayed::Job.in_delayed_job = false
-            ::ActiveRecord::Base.clear_active_connections! unless Rails.env.test?
+            unless Rails.env.test?
+              if Rails.version < "6.1"
+                ::ActiveRecord::Base.clear_active_connections!
+              else
+                ::ActiveRecord::Base.clear_active_connections!(nil)
+              end
+            end
           end
         end
       end
@@ -395,6 +408,11 @@ module Delayed
         md[1].constantize
       end
 
+      def invoke_payload_object_cb(method, ...)
+        obj = payload_object
+        obj.public_send(method, ...) if obj.respond_to?(method)
+      end
+
       public
 
       def initialize_defaults

data/lib/delayed/batch.rb

@@ -44,7 +44,7 @@ module Delayed
         Delayed::Job.batches = nil
         batch_args = opts.slice(:priority)
         batches.each do |enqueue_args, batch|
-          next if batch.size.zero?
+          next if batch.empty?
 
           if batch.size == 1
             args = batch.first.merge(batch_args)

data/lib/delayed/cli.rb

@@ -49,7 +49,7 @@ module Delayed
         daemon.daemonize!
         start
       when nil
-        puts option_parser.to_s
+        puts option_parser.help
       else
         raise("Unknown command: #{command.inspect}")
       end
@@ -82,7 +82,8 @@ module Delayed
         opts.on("-c", "--config [CONFIG_PATH]", "Use alternate config file (default #{@options[:config_file]})") do |c|
           @options[:config_file] = c
         end
-        opts.on("-p", "--pid [PID_PATH]",
+        opts.on("-p",
+                "--pid [PID_PATH]",
                 "Use alternate folder for PID files (default #{@options[:pid_folder]})") do |p|
           @options[:pid_folder] = p
         end

data/lib/delayed/lifecycle.rb

@@ -5,6 +5,7 @@ module Delayed
 
   class Lifecycle
     EVENTS = {
+      create: [:args],
       error: %i[worker job exception],
       exceptional_exit: %i[worker exception],
       execute: [:worker],
@@ -45,7 +46,7 @@ module Delayed
       missing_callback(event) unless @callbacks.key?(event)
 
       unless EVENTS[event].size == args.size
-        raise ArgumentError, "Callback #{event} expects #{EVENTS[event].size} parameter(s): #{EVENTS[event].join(', ')}"
+        raise ArgumentError, "Callback #{event} expects #{EVENTS[event].size} parameter(s): #{EVENTS[event].join(", ")}"
       end
 
       @callbacks[event].execute(*args, &block)
@@ -76,7 +77,13 @@ module Delayed
     def execute(*args, &block)
       @before.each { |c| c.call(*args) }
       result = @around.call(*args, &block)
-      @after.each { |c| c.call(*args) }
+      @after.each do |c|
+        if c.arity == args.length + 1 # don't fail for methods that don't define `result:`
+          c.call(*args, result: result)
+        else
+          c.call(*args)
+        end
+      end
       result
     end
 

data/lib/delayed/log_tailer.rb

@@ -5,8 +5,8 @@ module Delayed
     def run
       if Rails.logger.respond_to?(:log_path)
         log_path = Rails.logger.log_path
-      elsif Rails.logger.instance_variable_get("@logdev").try(:instance_variable_get, "@dev").try(:path)
-        log_path = Rails.logger.instance_variable_get("@logdev").instance_variable_get("@dev").path
+      elsif Rails.logger.instance_variable_get(:@logdev).try(:instance_variable_get, "@dev").try(:path)
+        log_path = Rails.logger.instance_variable_get(:@logdev).instance_variable_get(:@dev).path
       else
         return
       end

data/lib/delayed/message_sending.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "debug_inspector" if ::Rails.env.test? || ::Rails.env.development?
+require "debug_inspector" if Rails.env.test? || Rails.env.development?
 
 module Delayed
   module MessageSending
@@ -19,7 +19,7 @@ module Delayed
                          @object.protected_methods.exclude?(method) &&
                          @object.private_methods.exclude?(method)
 
-        sender_is_object = @sender == @object
+        sender_is_object = @sender.equal?(@object)
         sender_is_class = @sender.is_a?(@object.class)
 
         # even if the call is async, if the call is _going_ to generate an error, we make it synchronous
@@ -54,8 +54,10 @@ module Delayed
 
           if ::Delayed::Job != ::Delayed::Backend::ActiveRecord::Job || connection != ::Delayed::Job.connection
             connection.after_transaction_commit do
-              ::Delayed::Job.enqueue(::Delayed::PerformableMethod.new(@object, method,
-                                                                      args: args, kwargs: kwargs,
+              ::Delayed::Job.enqueue(::Delayed::PerformableMethod.new(@object,
+                                                                      method,
+                                                                      args: args,
+                                                                      kwargs: kwargs,
                                                                       on_failure: on_failure,
                                                                       on_permanent_failure: on_permanent_failure,
                                                                       sender: @sender),
@@ -65,7 +67,8 @@ module Delayed
           end
         end
 
-        result = ::Delayed::Job.enqueue(::Delayed::PerformableMethod.new(@object, method,
+        result = ::Delayed::Job.enqueue(::Delayed::PerformableMethod.new(@object,
+                                                                         method,
                                                                          args: args,
                                                                          kwargs: kwargs,
                                                                          on_failure: on_failure,

data/lib/delayed/performable_method.rb

@@ -1,7 +1,15 @@
 # frozen_string_literal: true
 
 module Delayed
-  PerformableMethod = Struct.new(:object, :method, :args, :kwargs, :fail_cb, :permanent_fail_cb, :sender) do # rubocop:disable Lint/StructNewOverride
+  PerformableMethod = Struct.new(:object,
+                                 :method, # rubocop:disable Lint/StructNewOverride
+                                 :args,
+                                 :kwargs,
+                                 :fail_cb,
+                                 :permanent_fail_cb,
+                                 :sender,
+                                 :sender_is_object,
+                                 :sender_is_class) do
     def initialize(object, method, args: [], kwargs: {}, on_failure: nil, on_permanent_failure: nil, sender: nil)
       raise NoMethodError, "undefined method `#{method}' for #{object.inspect}" unless object.respond_to?(method, true)
 
@@ -11,13 +19,10 @@ module Delayed
       self.method = method.to_sym
       self.fail_cb           = on_failure
       self.permanent_fail_cb = on_permanent_failure
-      self.sender = sender
-      begin
-        YAML.load(YAML.dump(sender))
-      rescue
-        # if for some reason you can't dump the sender, just drop it
-        self.sender = nil
-      end
+      self.sender_is_object = sender.equal?(object)
+      self.sender_is_class = sender.is_a?(object.class)
+      # bypass visibility checks (see MessageSending#__calculate_sender_for_delay)
+      self.sender_is_object = true if sender.nil?
     end
 
     def display_name
@@ -32,14 +37,15 @@ module Delayed
     def perform
       kwargs = self.kwargs || {}
 
-      sender_is_object = sender == object
-      sender_is_class = sender.is_a?(object.class)
+      # back-compat for jobs queued before we assigned these in initialize
+      self.sender_is_object = sender.equal?(object) if sender_is_object.nil?
+      self.sender_is_class = sender.is_a?(object.class) if sender_is_class.nil?
 
-      if sender.nil? || sender_is_object || (sender_is_class && object.protected_methods.include?(method))
+      if sender_is_object || (sender_is_class && object.protected_methods.include?(method))
         if kwargs.empty?
-          object.send(method, *args)
+          object.__send__(method, *args)
         else
-          object.send(method, *args, **kwargs)
+          object.__send__(method, *args, **kwargs)
         end
       elsif kwargs.empty?
         object.public_send(method, *args)
@@ -59,9 +65,9 @@ module Delayed
     def deep_de_ar_ize(arg)
       case arg
       when Hash
-        "{#{arg.map { |k, v| "#{deep_de_ar_ize(k)} => #{deep_de_ar_ize(v)}" }.join(', ')}}"
+        "{#{arg.map { |k, v| "#{deep_de_ar_ize(k)} => #{deep_de_ar_ize(v)}" }.join(", ")}}"
       when Array
-        "[#{arg.map { |a| deep_de_ar_ize(a) }.join(', ')}]"
+        "[#{arg.map { |a| deep_de_ar_ize(a) }.join(", ")}]"
       when ActiveRecord::Base
         "#{arg.class}.find(#{arg.id})"
       else
@@ -73,7 +79,7 @@ module Delayed
       obj_name = object.is_a?(ActiveRecord::Base) ? "#{object.class}.find(#{object.id}).#{method}" : display_name
       kgs = kwargs || {}
       kwargs_str = kgs.map { |(k, v)| ", #{k}: #{deep_de_ar_ize(v)}" }.join
-      "#{obj_name}(#{args.map { |a| deep_de_ar_ize(a) }.join(', ')}#{kwargs_str})"
+      "#{obj_name}(#{args.map { |a| deep_de_ar_ize(a) }.join(", ")}#{kwargs_str})"
     end
   end
 end

data/lib/delayed/periodic.rb

@@ -36,7 +36,7 @@ module Delayed
       Delayed::Job.transaction do
         # for db performance reasons, we only need one process doing this at a time
         # so if we can't get an advisory lock, just abort. we'll try again soon
-        return unless Delayed::Job.attempt_advisory_lock("Delayed::Periodic#audit_queue")
+        next unless Delayed::Job.attempt_advisory_lock("Delayed::Periodic#audit_queue")
 
         perform_audit!
       end
@@ -83,7 +83,7 @@ module Delayed
     def tag
       "periodic: #{@name}"
     end
-    alias display_name tag
+    alias_method :display_name, :tag
 
     def self.now
       Time.zone.now

data/lib/delayed/pool.rb

@@ -67,11 +67,21 @@ module Delayed
 
       unlocked_jobs = Delayed::Job.unlock_orphaned_jobs(pid)
       say "Unlocked #{unlocked_jobs} orphaned jobs" if unlocked_jobs.positive?
-      ActiveRecord::Base.connection_handler.clear_all_connections! unless Rails.env.test?
+      return if Rails.env.test?
+
+      if Rails.version < "6.1"
+        ActiveRecord::Base.connection_handler.clear_all_connections!
+      else
+        ActiveRecord::Base.connection_handler.clear_all_connections!(nil)
+      end
     end
 
     def spawn_all_workers
-      ActiveRecord::Base.connection_handler.clear_all_connections!
+      if Rails.version < "6.1"
+        ActiveRecord::Base.connection_handler.clear_all_connections!
+      else
+        ActiveRecord::Base.connection_handler.clear_all_connections!(nil)
+      end
 
       if @config[:work_queue] == "parent_process"
         @work_queue = WorkQueue::ParentProcess.new

data/lib/delayed/server.rb

@@ -16,7 +16,7 @@ module Delayed
       # Rails will take care of establishing the DB connection for us if there is
       # an application present
       if using_active_record? && !ActiveRecord::Base.connected?
-        ActiveRecord::Base.establish_connection(ENV["DATABASE_URL"])
+        ActiveRecord::Base.establish_connection(ENV.fetch("DATABASE_URL", nil))
       end
 
       @allow_update = args.length.positive? && args[0][:update]
@@ -37,7 +37,13 @@ module Delayed
 
     # Release any used connections back to the pool
     after do
-      ActiveRecord::Base.clear_active_connections! if using_active_record?
+      if using_active_record?
+        if Rails.version < "6.1"
+          ::ActiveRecord::Base.clear_active_connections!
+        else
+          ::ActiveRecord::Base.clear_active_connections!(nil)
+        end
+      end
     end
 
     configure :development do

data/lib/delayed/settings.rb

@@ -26,6 +26,7 @@ module Delayed
       :sleep_delay,
       :sleep_delay_stagger,
       :slow_exit_timeout,
+      :stranded_run_at_grace_period,
       :worker_health_check_type,
       :worker_health_check_config,
       :worker_procname_prefix
@@ -33,6 +34,7 @@ module Delayed
 
     SETTINGS_WITH_ARGS = %i[
       job_detailed_log_format
+      job_short_log_format
       num_strands
     ].freeze
 
@@ -131,12 +133,14 @@ module Delayed
     self.fetch_batch_size = 5
     self.select_random_from_batch = false
     self.silence_periodic_log = false
+    self.stranded_run_at_grace_period = 10
 
     self.num_strands = ->(_strand_name) {}
     self.default_job_options = -> { {} }
     self.job_detailed_log_format = lambda { |job|
-      job.to_json(include_root: false, only: %w[tag strand priority attempts created_at max_attempts source])
+      job.to_json(include_root: false, only: %w[tag strand singleton priority attempts created_at max_attempts source])
     }
+    self.job_short_log_format = ->(_job) { "" }
 
     # Send workers KILL after QUIT if they haven't exited within the
     # slow_exit_timeout

data/lib/delayed/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Delayed
-  VERSION = "3.0.8"
+  VERSION = "3.1.11"
 end

data/lib/delayed/work_queue/parent_process/server.rb

@@ -163,7 +163,7 @@ module Delayed
                 forced_latency: forced_latency
               )
               logger.debug(
-                "Fetched and locked #{response.values.flatten.size} new jobs for workers (#{response.keys.join(', ')})."
+                "Fetched and locked #{response.values.flatten.size} new jobs for workers (#{response.keys.join(", ")})."
               )
               response.each do |(worker_name, locked_jobs)|
                 if worker_name == prefetch_owner
@@ -226,7 +226,11 @@ module Delayed
 
             # otherwise just reconnect and let it retry
             logger.warn("failed to unlock prefetched jobs - connection terminated; skipping for now")
-            Delayed::Job.clear_all_connections!
+            if Rails.version < "6.1"
+              ::Delayed::Job.clear_all_connections!
+            else
+              ::Delayed::Job.clear_all_connections!(nil)
+            end
           end
         end
 
@@ -263,7 +267,7 @@ module Delayed
         end
 
         def prefetch_owner
-          "prefetch:#{Socket.gethostname rescue 'X'}"
+          "prefetch:#{Socket.gethostname rescue "X"}"
         end
 
         def parent_exited?

data/lib/delayed/worker/health_check.rb

@@ -34,7 +34,7 @@ module Delayed
             # no other worker is trying to do this right now (and if we abandon the
             # operation, the transaction will end, releasing the advisory lock).
             result = Delayed::Job.attempt_advisory_lock("Delayed::Worker::HealthCheck#reschedule_abandoned_jobs")
-            return unless result
+            next unless result
 
             horizon = 5.minutes.ago