inst-jobs 2.2.1 → 2.4.0

data/lib/delayed/core_ext/kernel.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Kernel
-  def sender(i = 0)
+  def sender(idx = 0)
     frame_self = nil
     # 3. one for the block, one for this method, one for the method calling this
     # method, and _then_ we get to the self for who sent the message we want
-    RubyVM::DebugInspector.open { |dc| frame_self = dc.frame_self(3 + i) }
+    RubyVM::DebugInspector.open { |dc| frame_self = dc.frame_self(3 + idx) }
     frame_self
   end
 end

data/lib/delayed/daemon.rb

@@ -1,97 +1,93 @@
 # frozen_string_literal: true
 
-require 'fileutils'
+require "fileutils"
 
 module Delayed
-# Daemon controls the parent proces that runs the Pool and monitors the Worker processes.
-class Daemon
-  attr_reader :pid_folder
+  # Daemon controls the parent proces that runs the Pool and monitors the Worker processes.
+  class Daemon
+    attr_reader :pid_folder
 
-  def initialize(pid_folder)
-    @pid_folder = pid_folder
-  end
+    def initialize(pid_folder)
+      @pid_folder = pid_folder
+    end
 
-  def status(print: true, pid: self.pid)
-    alive = pid && (Process.kill(0, pid) rescue false) && :running
-    alive ||= :draining if pid && Process.kill(0, -pid) rescue false
-    if alive
-      puts "Delayed jobs #{alive}, pool PID: #{pid}" if print
-    else
-      puts "No delayed jobs pool running" if print && print != :alive
+    def status(print: true, pid: self.pid)
+      alive = pid && (Process.kill(0, pid) rescue false) && :running
+      alive ||= :draining if pid && Process.kill(0, -pid) rescue false
+      if alive
+        puts "Delayed jobs #{alive}, pool PID: #{pid}" if print
+      elsif print && print != :alive
+        puts "No delayed jobs pool running"
+      end
+      alive
     end
-    alive
-  end
 
-  def daemonize!
-    FileUtils.mkdir_p(pid_folder)
-    puts "Daemonizing..."
+    def daemonize!
+      FileUtils.mkdir_p(pid_folder)
+      puts "Daemonizing..."
 
-    exit if fork
-    Process.setsid
-    exit if fork
-    Process.setpgrp
+      exit if fork
+      Process.setsid
+      exit if fork
+      Process.setpgrp
 
-    @daemon = true
-    lock_file = File.open(pid_file, 'wb')
-    # someone else is already running; just exit
-    unless lock_file.flock(File::LOCK_EX | File::LOCK_NB)
-      exit
-    end
-    at_exit { lock_file.flock(File::LOCK_UN) }
-    lock_file.puts(Process.pid.to_s)
-    lock_file.flush
+      @daemon = true
+      lock_file = File.open(pid_file, "wb")
+      # someone else is already running; just exit
+      exit unless lock_file.flock(File::LOCK_EX | File::LOCK_NB)
+      at_exit { lock_file.flock(File::LOCK_UN) }
+      lock_file.puts(Process.pid.to_s)
+      lock_file.flush
 
-    # if we blow up so badly that we can't syslog the error, try to send
-    # it somewhere useful
-    last_ditch_logfile = Settings.last_ditch_logfile || "log/delayed_job.log"
-    if last_ditch_logfile[0] != '|'
-      last_ditch_logfile = Settings.expand_rails_path(last_ditch_logfile)
+      # if we blow up so badly that we can't syslog the error, try to send
+      # it somewhere useful
+      last_ditch_logfile = Settings.last_ditch_logfile || "log/delayed_job.log"
+      last_ditch_logfile = Settings.expand_rails_path(last_ditch_logfile) if last_ditch_logfile[0] != "|"
+      $stdin.reopen("/dev/null")
+      $stdout.reopen(open(last_ditch_logfile, "a")) # rubocop:disable Security/Open
+      $stderr.reopen($stdout)
+      $stdout.sync = $stderr.sync = true
     end
-    STDIN.reopen("/dev/null")
-    STDOUT.reopen(open(last_ditch_logfile, 'a'))
-    STDERR.reopen(STDOUT)
-    STDOUT.sync = STDERR.sync = true
-  end
 
-  # stop the currently running daemon (not this current process, the one in the pid_file)
-  def stop(kill: false, pid: self.pid)
-    alive = status(pid: pid, print: false)
-    if alive == :running || (kill && alive == :draining)
-      puts "Stopping pool #{pid}..."
-      signal = kill ? 'TERM' : 'QUIT'
-      begin
-        Process.kill(signal, pid)
-      rescue Errno::ESRCH
-        # ignore if the pid no longer exists
+    # stop the currently running daemon (not this current process, the one in the pid_file)
+    def stop(kill: false, pid: self.pid)
+      alive = status(pid: pid, print: false)
+      if alive == :running || (kill && alive == :draining)
+        puts "Stopping pool #{pid}..."
+        signal = kill ? "TERM" : "QUIT"
+        begin
+          Process.kill(signal, pid)
+        rescue Errno::ESRCH
+          # ignore if the pid no longer exists
+        end
+        wait(kill)
+      else
+        status
       end
-      wait(kill)
-    else
-      status
     end
-  end
 
-  def wait(kill)
-    if kill
-      sleep(0.5) while status(pid: pid, print: false)
-    else
-      sleep(0.5) while status(pid: pid, print: false) == :running
+    def wait(kill)
+      if kill
+        sleep(0.5) while status(pid: pid, print: false)
+      else
+        sleep(0.5) while status(pid: pid, print: false) == :running
+      end
     end
-  end
 
-  def pid_file
-    File.join(pid_folder, 'delayed_jobs_pool.pid')
-  end
+    def pid_file
+      File.join(pid_folder, "delayed_jobs_pool.pid")
+    end
 
-  def pid
-    if File.file?(pid_file)
-      pid = File.read(pid_file).to_i
-      pid = nil unless pid > 0
+    def pid
+      if File.file?(pid_file)
+        pid = File.read(pid_file).to_i
+        pid = nil unless pid.positive?
+      end
+      pid
     end
-    pid
-  end
 
-  def daemonized?
-    !!@daemon
+    def daemonized?
+      !!@daemon
+    end
   end
 end
-end

data/lib/delayed/job_tracking.rb

@@ -1,33 +1,34 @@
 # frozen_string_literal: true
 
 module Delayed
-# Used when a block of code wants to track what jobs are created,
-# for instance in tests.
-# Delayed::Job.track_jobs { ...block... } returns a JobTracking object
-# Right now this just tracks created jobs, it could be expanded to track a
-# lot more about what's going on in Delayed Jobs as it's needed.
-class JobTracking < Struct.new(:created)
-  def self.track
-    @current_tracking = self.new
-    yield
-    tracking = @current_tracking
-    @current_tracking = nil
-    tracking
-  end
+  # Used when a block of code wants to track what jobs are created,
+  # for instance in tests.
+  # Delayed::Job.track_jobs { ...block... } returns a JobTracking object
+  # Right now this just tracks created jobs, it could be expanded to track a
+  # lot more about what's going on in Delayed Jobs as it's needed.
+  JobTracking = Struct.new(:created) do
+    def self.track
+      @current_tracking = new
+      yield
+      tracking = @current_tracking
+      @current_tracking = nil
+      tracking
+    end
 
-  def self.job_created(job)
-    @current_tracking.try(:job_created, job)
-  end
+    def self.job_created(job)
+      @current_tracking.try(:job_created, job)
+    end
 
-  def job_created(job)
-    return unless job
-    @lock.synchronize { self.created << job }
-  end
+    def job_created(job)
+      return unless job
 
-  def initialize
-    super
-    self.created = []
-    @lock = Mutex.new
+      @lock.synchronize { created << job }
+    end
+
+    def initialize
+      super
+      self.created = []
+      @lock = Mutex.new
+    end
   end
 end
-end

data/lib/delayed/lifecycle.rb

@@ -1,29 +1,32 @@
 # frozen_string_literal: true
 
 module Delayed
-  class InvalidCallback < Exception; end
+  class InvalidCallback < RuntimeError; end
 
   class Lifecycle
     EVENTS = {
-      :error            => [:worker, :job, :exception],
-      :exceptional_exit => [:worker, :exception],
-      :execute          => [:worker],
-      :invoke_job       => [:job],
-      :loop             => [:worker],
-      :perform          => [:worker, :job],
-      :pop              => [:worker],
-      :retry            => [:worker, :job, :exception],
-      :work_queue_pop   => [:work_queue, :worker_config],
-      :check_for_work   => [:work_queue],
-    }
+      error: %i[worker job exception],
+      exceptional_exit: %i[worker exception],
+      execute: [:worker],
+      invoke_job: [:job],
+      loop: [:worker],
+      perform: %i[worker job],
+      pop: [:worker],
+      retry: %i[worker job exception],
+      work_queue_pop: %i[work_queue worker_config],
+      check_for_work: [:work_queue]
+    }.freeze
 
     def initialize
       reset!
     end
 
     def reset!
-      @callbacks = EVENTS.keys.inject({}) { |hash, e| hash[e] = Callback.new; hash }
-      Delayed::Worker.plugins.each { |plugin| plugin.reset! }
+      @callbacks = EVENTS.keys.each_with_object({}) do |e, hash|
+        hash[e] = Callback.new
+        hash
+      end
+      Delayed::Worker.plugins.each(&:reset!)
     end
 
     def before(event, &block)
@@ -39,7 +42,7 @@ module Delayed
     end
 
     def run_callbacks(event, *args, &block)
-      missing_callback(event) unless @callbacks.has_key?(event)
+      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(', ')}"
@@ -50,15 +53,15 @@ module Delayed
 
     private
 
-      def add(type, event, &block)
-        missing_callback(event) unless @callbacks.has_key?(event)
+    def add(type, event, &block)
+      missing_callback(event) unless @callbacks.key?(event)
 
-        @callbacks[event].add(type, &block)
-      end
+      @callbacks[event].add(type, &block)
+    end
 
-      def missing_callback(event)
-        raise InvalidCallback, "Unknown callback event: #{event}"
-      end
+    def missing_callback(event)
+      raise InvalidCallback, "Unknown callback event: #{event}"
+    end
   end
 
   class Callback
@@ -67,7 +70,7 @@ module Delayed
       @after = []
 
       # Identity proc. Avoids special cases when there is no existing around chain.
-      @around = lambda { |*args, &block| block.call(*args) }
+      @around = ->(*args, &block) { block.call(*args) }
     end
 
     def execute(*args, &block)
@@ -85,7 +88,7 @@ module Delayed
         @after << callback
       when :around
         chain = @around # use a local variable so that the current chain is closed over in the following lambda
-        @around = lambda { |*a, &block| chain.call(*a) { |*b| callback.call(*b, &block) } }
+        @around = ->(*a, &block) { chain.call(*a) { |*b| callback.call(*b, &block) } }
       else
         raise InvalidCallback, "Invalid callback type: #{type}"
       end

data/lib/delayed/log_tailer.rb

@@ -1,24 +1,24 @@
 # frozen_string_literal: true
 
 module Delayed
-class LogTailer
-  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
-    else
-      return
-    end
-    Rails.logger.auto_flushing = true if Rails.logger.respond_to?(:auto_flushing=)
-    Thread.new do
-      f = File.open(log_path, 'r')
-      f.seek(0, IO::SEEK_END)
-      loop do
-        content = f.read
-        content.present? ? STDOUT.print(content) : sleep(0.5)
+  class LogTailer
+    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
+      else
+        return
+      end
+      Rails.logger.auto_flushing = true if Rails.logger.respond_to?(:auto_flushing=)
+      Thread.new do
+        f = File.open(log_path, "r")
+        f.seek(0, IO::SEEK_END)
+        loop do
+          content = f.read
+          content.present? ? $stdout.print(content) : sleep(0.5)
+        end
       end
     end
   end
 end
-end

data/lib/delayed/logging.rb

@@ -1,30 +1,27 @@
 # frozen_string_literal: true
 
-require 'date'
+require "date"
 
 module Delayed
   module Logging
-    TIMESTAMP_FORMAT = '%Y-%m-%dT%H:%M:%S.%6N'.freeze
+    TIMESTAMP_FORMAT = "%Y-%m-%dT%H:%M:%S.%6N"
     private_constant :TIMESTAMP_FORMAT
 
-    FORMAT = '%s - %s'
+    FORMAT = "%s - %s"
     private_constant :FORMAT
 
-
     def self.logger
       return @logger if @logger
-      if defined?(Rails.logger) && Rails.logger
-        @logger = Rails.logger
-      else
-        @logger = ::Logger.new(STDOUT).tap do |logger|
-          logger.formatter = ->(_, time, _, msg) {
-            FORMAT % [
-              time.strftime(TIMESTAMP_FORMAT),
-              msg
-            ]
-          }
-        end
-      end
+
+      @logger = if defined?(Rails.logger) && Rails.logger
+                  Rails.logger
+                else
+                  ::Logger.new($stdout).tap do |logger|
+                    logger.formatter = lambda { |_, time, _, msg|
+                      format(FORMAT, time.strftime(TIMESTAMP_FORMAT), msg)
+                    }
+                  end
+                end
     end
 
     def logger

data/lib/delayed/message_sending.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-if ::Rails.env.test? || ::Rails.env.development?
-  require 'debug_inspector'
-end
+require "debug_inspector" if ::Rails.env.test? || ::Rails.env.development?
 
 module Delayed
   module MessageSending
@@ -14,12 +12,12 @@ module Delayed
         @sender = sender
       end
 
-      def method_missing(method, *args, **kwargs)
+      def method_missing(method, *args, **kwargs) # rubocop:disable Style/MissingRespondToMissing
         # method doesn't exist? must be method_missing; assume private access
         @sender = nil if !@sender.nil? &&
-         !@object.methods.include?(method) &&
-         !@object.protected_methods.include?(method) &&
-         !@object.private_methods.include?(method)
+                         @object.methods.exclude?(method) &&
+                         @object.protected_methods.exclude?(method) &&
+                         @object.private_methods.exclude?(method)
 
         sender_is_object = @sender == @object
         sender_is_class = @sender.is_a?(@object.class)
@@ -34,50 +32,46 @@ module Delayed
 
         if @synchronous
           if @sender.nil? || sender_is_object || sender_is_class && @object.protected_methods.include?(method)
-            if kwargs.empty?
-              return @object.send(method, *args)
-            else
-              return @object.send(method, *args, **kwargs)
-            end
-          end
-          
-          if kwargs.empty?
-            return @object.public_send(method, *args)
-          else
-            return @object.public_send(method, *args, **kwargs)
+            return @object.send(method, *args) if kwargs.empty?
+
+            return @object.send(method, *args, **kwargs)
           end
+
+          return @object.public_send(method, *args) if kwargs.empty?
+
+          @object.public_send(method, *args, **kwargs)
         end
 
         ignore_transaction = @enqueue_args.delete(:ignore_transaction)
         on_failure = @enqueue_args.delete(:on_failure)
         on_permanent_failure = @enqueue_args.delete(:on_permanent_failure)
-        if !ignore_transaction
+        unless ignore_transaction
           # delay queuing up the job in another database until the results of the current
           # transaction are visible
           connection = @object.class.connection if @object.class.respond_to?(:connection)
           connection ||= @object.connection if @object.respond_to?(:connection)
           connection ||= ::ActiveRecord::Base.connection
 
-          if (::Delayed::Job != ::Delayed::Backend::ActiveRecord::Job || connection != ::Delayed::Job.connection)
+          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,
-                                                                  on_failure: on_failure,
-                                                                  on_permanent_failure: on_permanent_failure,
-                                                                  sender: @sender),
-                                                                  **@enqueue_args)
+                                                                      args: args, kwargs: kwargs,
+                                                                      on_failure: on_failure,
+                                                                      on_permanent_failure: on_permanent_failure,
+                                                                      sender: @sender),
+                                     **@enqueue_args)
             end
             return nil
           end
         end
 
         result = ::Delayed::Job.enqueue(::Delayed::PerformableMethod.new(@object, method,
-                                                                    args: args,
-                                                                    kwargs: kwargs,
-                                                                    on_failure: on_failure,
-                                                                    on_permanent_failure: on_permanent_failure,
-                                                                    sender: @sender),
-                                                                    **@enqueue_args)
+                                                                         args: args,
+                                                                         kwargs: kwargs,
+                                                                         on_failure: on_failure,
+                                                                         on_permanent_failure: on_permanent_failure,
+                                                                         sender: @sender),
+                                        **@enqueue_args)
         result = nil unless ignore_transaction
         result
       end
@@ -85,10 +79,8 @@ module Delayed
 
     def delay(sender: nil, **enqueue_args)
       # support procs/methods as enqueue arguments
-      enqueue_args.each do |k,v|
-        if v.respond_to?(:call)
-          enqueue_args[k] = v.call(self)
-        end
+      enqueue_args.each do |k, v|
+        enqueue_args[k] = v.call(self) if v.respond_to?(:call)
       end
 
       sender ||= __calculate_sender_for_delay
@@ -103,33 +95,32 @@ module Delayed
     end
 
     module ClassMethods
-      KWARG_ARG_TYPES = %i{key keyreq keyrest}.freeze
+      KWARG_ARG_TYPES = %i[key keyreq keyrest].freeze
       private_constant :KWARG_ARG_TYPES
 
       def handle_asynchronously(method_name, **enqueue_args)
-        aliased_method, punctuation = method_name.to_s.sub(/([?!=])$/, ''), $1
-
-        if public_method_defined?(method_name)
-          visibility = :public
-        elsif private_method_defined?(method_name)
-          visibility = :private
-        else
-          visibility = :protected
-        end
-
-        if has_kwargs? method_name
+        visibility = if public_method_defined?(method_name)
+                       :public
+                     elsif private_method_defined?(method_name)
+                       :private
+                     else
+                       :protected
+                     end
+
+        if kwargs? method_name
           generated_delayed_methods.class_eval do
-            define_method(method_name, -> (*args, synchronous: false, **kwargs) do
+            define_method(method_name, lambda do |*args, synchronous: false, **kwargs|
               if synchronous
                 super(*args, **kwargs)
               else
-                delay(sender: __calculate_sender_for_delay, **enqueue_args).method_missing(method_name, *args, synchronous: true, **kwargs)
+                delay(sender: __calculate_sender_for_delay, **enqueue_args)
+                  .method_missing(method_name, *args, synchronous: true, **kwargs)
               end
             end)
           end
         else
           generated_delayed_methods.class_eval do
-            define_method(method_name, -> (*args, synchronous: false) do
+            define_method(method_name, lambda do |*args, synchronous: false|
               if synchronous
                 super(*args)
               else
@@ -150,7 +141,7 @@ module Delayed
         end
       end
 
-      def has_kwargs?(method_name)
+      def kwargs?(method_name)
         original_arg_types = instance_method(method_name).parameters.map(&:first)
         original_arg_types.any? { |arg_type| KWARG_ARG_TYPES.include?(arg_type) }
       end