inst-jobs 0.15.22 → 1.0.3

data/lib/delayed/backend/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Delayed
   module Backend
     class DeserializationError < StandardError
@@ -28,19 +30,31 @@ module Delayed
         # The first argument should be an object that respond_to?(:perform)
         # The rest should be named arguments, these keys are expected:
         # :priority, :run_at, :queue, :strand, :singleton
-        # Example: Delayed::Job.enqueue(object, :priority => 0, :run_at => time, :queue => queue)
-        def enqueue(*args)
-          object = args.shift
+        # Example: Delayed::Job.enqueue(object, priority: 0, run_at: time, queue: queue)
+        def enqueue(object,
+          priority: default_priority,
+          run_at: nil,
+          expires_at: nil,
+          queue: Delayed::Settings.queue,
+          strand: nil,
+          singleton: nil,
+          n_strand: nil,
+          max_attempts: Delayed::Settings.max_attempts,
+          **kwargs)
+
           unless object.respond_to?(:perform)
             raise ArgumentError, 'Cannot enqueue items which do not respond to perform'
           end
 
-          options = Settings.default_job_options.merge(args.first || {})
-          options[:priority] ||= self.default_priority
-          options[:payload_object] = object
-          options[:queue] = Delayed::Settings.queue unless options.key?(:queue)
-          options[:max_attempts] ||= Delayed::Settings.max_attempts
-          options[:source] = Marginalia::Comment.construct_comment if defined?(Marginalia) && Marginalia::Comment.components
+          kwargs = Settings.default_job_options.merge(kwargs)
+          kwargs[:payload_object] = object
+          kwargs[:priority] = priority
+          kwargs[:run_at] = run_at if run_at
+          kwargs[:strand] = strand
+          kwargs[:max_attempts] = max_attempts
+          kwargs[:source] = Marginalia::Comment.construct_comment if defined?(Marginalia) && Marginalia::Comment.components
+          kwargs[:expires_at] = expires_at
+          kwargs[:queue] = queue
 
           # 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
@@ -49,8 +63,8 @@ module Delayed
           # For instance, you can pass ["my_job_type", # root_account.global_id]
           # to get a set of n strands per root account, and you can apply the
           # same default to all.
-          if options[:n_strand]
-            strand_name, ext = options.delete(:n_strand)
+          if n_strand
+            strand_name, ext = n_strand
 
             if ext
               full_strand_name = "#{strand_name}/#{ext}"
@@ -62,18 +76,18 @@ module Delayed
             num_strands ||= Delayed::Settings.num_strands.call(strand_name)
             num_strands = num_strands ? num_strands.to_i : 1
 
-            options.merge!(n_strand_options(full_strand_name, num_strands))
+            kwargs.merge!(n_strand_options(full_strand_name, num_strands))
           end
 
-          if options[:singleton]
-            options[:strand] = options.delete :singleton
-            job = self.create_singleton(options)
-          elsif batches && options.slice(:strand, :run_at).empty?
-            batch_enqueue_args = options.slice(*self.batch_enqueue_args)
-            batches[batch_enqueue_args] << options
+          if singleton
+            kwargs[:strand] = singleton
+            job = self.create_singleton(**kwargs)
+          elsif batches && strand.nil? && run_at.nil?
+            batch_enqueue_args = kwargs.slice(*self.batch_enqueue_args)
+            batches[batch_enqueue_args] << kwargs
             return true
           else
-            job = self.create(options)
+            job = self.create(**kwargs)
           end
 
           JobTracking.job_created(job)
@@ -87,7 +101,7 @@ module Delayed
         def n_strand_options(strand_name, num_strands)
           strand_num = num_strands > 1 ? rand(num_strands) + 1 : 1
           strand_name += ":#{strand_num}" if strand_num > 1
-          {:strand => strand_name}
+          { strand: strand_name }
         end
 
         def in_delayed_job?

data/lib/delayed/backend/redis/functions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'redis/scripting'
 
 # This module handles loading the Lua functions into Redis and running them

data/lib/delayed/backend/redis/job.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This can't currently be made compatible with redis cluster, because the Lua functions
 # access keys that aren't in their keys argument list (since they pop jobs off
 # a queue and then update the job with that id).

data/lib/delayed/batch.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Delayed
   module Batch
     class PerformableBatch < Struct.new(:mode, :items)
@@ -18,7 +20,7 @@ module Delayed
       end
 
       def jobs
-        items.map { |opts| Delayed::Job.new(opts) }
+        items.map { |opts| Delayed::Job.new(**opts) }
       end
     end
 
@@ -45,9 +47,9 @@ module Delayed
           elsif batch.size == 1
             args = batch.first.merge(batch_args)
             payload_object = args.delete(:payload_object)
-            Delayed::Job.enqueue(payload_object, args)
+            Delayed::Job.enqueue(payload_object, **args)
           else
-            Delayed::Job.enqueue(Delayed::Batch::PerformableBatch.new(mode, batch), enqueue_args.merge(batch_args))
+            Delayed::Job.enqueue(Delayed::Batch::PerformableBatch.new(mode, batch), **enqueue_args.merge(batch_args))
           end
         end
       end

data/lib/delayed/cli.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'optparse'
 
 module Delayed

data/lib/delayed/core_ext/kernel.rb

@@ -0,0 +1,9 @@
+module Kernel
+  def sender(i = 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) }
+    frame_self
+  end
+end

data/lib/delayed/daemon.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 
 module Delayed

data/lib/delayed/engine.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Delayed
   class Engine < ::Rails::Engine
   end

data/lib/delayed/job_tracking.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Delayed
 # Used when a block of code wants to track what jobs are created,
 # for instance in tests.

data/lib/delayed/lifecycle.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Delayed
   class InvalidCallback < Exception; end
 

data/lib/delayed/log_tailer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Delayed
 class LogTailer
   def run

data/lib/delayed/logging.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'date'
 
 module Delayed

data/lib/delayed/message_sending.rb

@@ -1,109 +1,114 @@
+# frozen_string_literal: true
+
+if ::Rails.env.test? || ::Rails.env.development?
+  require 'debug_inspector'
+end
+
 module Delayed
   module MessageSending
-    def send_later(method, *args)
-      send_later_enqueue_args(method, {}, *args)
-    end
+    class DelayProxy < BasicObject
+      def initialize(object, synchronous: false, sender: nil, **enqueue_args)
+        @object = object
+        @enqueue_args = enqueue_args
+        @synchronous = synchronous
+        @sender = sender
+      end
 
-    def send_later_enqueue_args(method, enqueue_args = {}, *args)
-      enqueue_args = enqueue_args.dup
-      # support procs/methods as enqueue arguments
-      enqueue_args.each do |k,v|
-        if v.respond_to?(:call)
-          enqueue_args[k] = v.call(self)
+      def method_missing(method, *args, **kwargs)
+        # 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)
+
+        sender_is_object = @sender == @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
+        # so that the error is generated immediately, instead of waiting for it to fail in a job,
+        # which might go unnoticed
+        if !@sender.nil? && !@synchronous
+          @synchronous = true if !sender_is_object && @object.private_methods.include?(method)
+          @synchronous = true if !sender_is_class && @object.protected_methods.include?(method)
         end
-      end
 
-      no_delay = enqueue_args.delete(:no_delay)
-      on_failure = enqueue_args.delete(:on_failure)
-      on_permanent_failure = enqueue_args.delete(:on_permanent_failure)
-      if !no_delay
-        # delay queuing up the job in another database until the results of the current
-        # transaction are visible
-        connection = self.class.connection if self.class.respond_to?(:connection)
-        connection ||= self.connection if respond_to?(:connection)
-        connection ||= ActiveRecord::Base.connection
-
-        if (Delayed::Job != Delayed::Backend::ActiveRecord::Job || connection != Delayed::Job.connection)
-          connection.after_transaction_commit do
-            Delayed::Job.enqueue(Delayed::PerformableMethod.new(self, method.to_sym, args,
-                                                                on_failure, on_permanent_failure), enqueue_args)
+        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)
           end
-          return nil
         end
-      end
-
-      result = Delayed::Job.enqueue(Delayed::PerformableMethod.new(self, method.to_sym, args,
-                                                                   on_failure, on_permanent_failure), enqueue_args)
-      result = nil unless no_delay
-      result
-    end
-
-    def send_later_with_queue(method, queue, *args)
-      send_later_enqueue_args(method, { :queue => queue }, *args)
-    end
 
-    def send_at(time, method, *args)
-      send_later_enqueue_args(method,
-                          { :run_at => time }, *args)
-    end
-
-    def send_at_with_queue(time, method, queue, *args)
-      send_later_enqueue_args(method,
-                          { :run_at => time, :queue => queue },
-                          *args)
-    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
+          # 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)
+            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)
+            end
+            return nil
+          end
+        end
 
-    def send_later_unless_in_job(method, *args)
-      if Delayed::Job.in_delayed_job?
-        send(method, *args)
-      else
-        send_later(method, *args)
+        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)
+        result = nil unless ignore_transaction
+        result
       end
-      nil # can't rely on the type of return value, so return nothing
     end
 
-    def send_later_if_production(*args)
-      if Rails.env.production?
-        send_later(*args)
-      else
-        send(*args)
+    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
       end
-    end
 
-    def send_later_if_production_enqueue_args(method, enqueue_args, *args)
-      if Rails.env.production?
-        send_later_enqueue_args(method, enqueue_args, *args)
-      else
-        send(method, *args)
-      end
-    end
+      sender ||= __calculate_sender_for_delay
 
-    def send_now_or_later(_when, *args)
-      if _when == :now
-        send(*args)
-      else
-        send_later(*args)
-      end
+      DelayProxy.new(self, sender: sender, **enqueue_args)
     end
 
-    def send_now_or_later_if_production(_when, *args)
-      if _when == :now
-        send(*args)
-      else
-        send_later_if_production(*args)
-      end
+    def __calculate_sender_for_delay
+      # enforce public send in dev and test, but not prod (since it uses
+      # debug APIs, it's expensive)
+      return sender(1) if ::Rails.env.test? || ::Rails.env.development?
     end
 
     module ClassMethods
       KWARG_ARG_TYPES = %i{key keyreq keyrest}.freeze
       private_constant :KWARG_ARG_TYPES
 
-      def add_send_later_methods(method_name, enqueue_args={}, default_async=false)
+      def handle_asynchronously(method_name, **enqueue_args)
         aliased_method, punctuation = method_name.to_s.sub(/([?!=])$/, ''), $1
 
-        # we still need this for backwards compatibility
-        without_method = "#{aliased_method}_without_send_later#{punctuation}"
-
         if public_method_defined?(method_name)
           visibility = :public
         elsif private_method_defined?(method_name)
@@ -114,49 +119,28 @@ module Delayed
 
         if has_kwargs? method_name
           generated_delayed_methods.class_eval do
-            define_method without_method do |*args, **kwargs|
-              send(method_name, *args, synchronous: true, **kwargs)
-            end
-
-            define_method(method_name, -> (*args, synchronous: !default_async, **kwargs) do
+            define_method(method_name, -> (*args, synchronous: false, **kwargs) do
               if synchronous
                 super(*args, **kwargs)
               else
-                send_later_enqueue_args(method_name, enqueue_args, *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 without_method do |*args|
-              send(method_name, *args, synchronous: true)
-            end
-
-            define_method(method_name, -> (*args, synchronous: !default_async) do
+            define_method(method_name, -> (*args, synchronous: false) do
               if synchronous
                 super(*args)
               else
-                send_later_enqueue_args(method_name, enqueue_args, *args, synchronous: true)
+                delay(**enqueue_args).method_missing(method_name, *args, synchronous: true)
               end
             end)
           end
         end
-        generated_delayed_methods.send(visibility, without_method)
         generated_delayed_methods.send(visibility, method_name)
       end
 
-      def handle_asynchronously(method, enqueue_args={})
-        add_send_later_methods(method, enqueue_args, true)
-      end
-
-      def handle_asynchronously_with_queue(method, queue)
-        add_send_later_methods(method, {:queue => queue}, true)
-      end
-
-      def handle_asynchronously_if_production(method, enqueue_args={})
-        add_send_later_methods(method, enqueue_args, Rails.env.production?)
-      end
-
       private
 
       def generated_delayed_methods

data/lib/delayed/performable_method.rb

@@ -1,13 +1,23 @@
+# frozen_string_literal: true
+
 module Delayed
-  class PerformableMethod < Struct.new(:object, :method, :args, :fail_cb, :permanent_fail_cb)
-    def initialize(object, method, args = [], fail_cb = nil, permanent_fail_cb = nil)
+  class PerformableMethod < Struct.new(:object, :method, :args, :kwargs, :fail_cb, :permanent_fail_cb, :sender)
+    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)
 
       self.object = object
       self.args   = args
+      self.kwargs = kwargs
       self.method = method.to_sym
-      self.fail_cb           = fail_cb
-      self.permanent_fail_cb = permanent_fail_cb
+      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
     end
 
     def display_name
@@ -20,7 +30,24 @@ module Delayed
     alias_method :tag, :display_name
 
     def perform
-      object.send(method, *args)
+      kwargs = self.kwargs || {}
+
+      sender_is_object = sender == object
+      sender_is_class = sender.is_a?(object.class)
+
+      if sender.nil? || sender_is_object || sender_is_class && object.protected_methods.include?(method)
+        if kwargs.empty?
+          object.send(method, *args)
+        else
+          object.send(method, *args, **kwargs)
+        end
+      else
+        if kwargs.empty?
+          object.public_send(method, *args)
+        else
+          object.public_send(method, *args, **kwargs)
+        end
+      end
     end
 
     def on_failure(error)
@@ -46,7 +73,8 @@ module Delayed
 
     def full_name
       obj_name = object.is_a?(ActiveRecord::Base) ? "#{object.class}.find(#{object.id}).#{method}" : display_name
-      "#{obj_name}(#{args.map { |a| deep_de_ar_ize(a) }.join(', ')})"
+      kwargs_str = kwargs.map { |(k, v)| ", #{k}: #{deep_de_ar_ize(v)}"}.join("")
+      "#{obj_name}(#{args.map { |a| deep_de_ar_ize(a) }.join(', ')}#{kwargs_str})"
     end
   end
 end