sidekiq-delay_extensions 7.0.0 → 7.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95dda38ae3c61ad156898807a993f2e4ed94a1e9fa84e0acefc55e9eda8c563f
-  data.tar.gz: c01d2df0317cb993a90ea42edf54c8cd8555a47abc6e9fc5aeca30cd3c609970
+  metadata.gz: '09822a56faaa3bddfd6accbbff7d36e709cd62d41123b3b42c54523ef74460a7'
+  data.tar.gz: f4c9f5b96cd11aff2f7790b5384b698f52c331a99260651f16f106632a96d15b
 SHA512:
-  metadata.gz: c8ff4ae1215e5f1feb5b69c776711e9bdbd788d485d67f539e6b04aa47712149eff81f3a8148ad18fde812254107d1954754e67559847821cfd22cb414d64321
-  data.tar.gz: 1c829791c9f5c30a59fd236864f07d9e3ae635bd928bc4df8d25bce692b1323f0a8f851692d49cafac4da446b8c87b4f84d8d33fcfe8e8151201f5de7ade08a4
+  metadata.gz: 1ec8ced317007db2bd65436b7c575c01d741efc86273f2d8407637612864636f4757bf8efe5c28f021435fa6f88d20b86f33915bc0bf81b22bdebeb5d4aa145f
+  data.tar.gz: 9f43ee40a9aad89506d1a2aa51ed041b97ce499e8fb8d156e67c4b6e3c21e308e3337eb46ac0f8b1d156d39fe0e61ceaee88533cc840f5dcf20fd99bcd2875bd

data/Changes.md

@@ -2,6 +2,23 @@
 
 [See Sidekiq for its changes](https://github.com/mperham/sidekiq/blob/main/Changes.md)
 
+Unreleased
+---------
+
+7.1.0
+---------
+
+- New `Sidekiq::DelayExtensions::GenericJob` superclass for DelayedMailer, DelayedModel, DelayedClass
+  - it has a `_perform` method which accepts the unmarshalled and processed
+    `(target, method_name, *args, **kwargs)` and can be overridden or extended as needed.
+- New (opt-in) `Sidekiq::DelayExtensions::GenericProxy` which can parse JSON or YAML delayed arguments
+  into a `target`, `method_name`, `args`, and `kwargs` before.
+- New (opt-in) setting `Sidekiq::DelayExtensions.use_generic_proxy` (defaults to false).
+  - When false, there is no delayed proxy changes; the original `Sidekiq::DelayExtensions::Proxy` is used.
+  - When true, the new `Sidekiq::DelayExtensions::GenericProxy` is used, which handles both `*args` and `**kwargs` more naturally.
+    Be sure to test this works for you as expected when turning this on.
+- Chore: Load YAML consistently via `::Sidekiq::DelayExtensions::YAML`
+
 7.0.0
 ---------
 

data/README.md

@@ -32,6 +32,8 @@ In your initializers, include the line:
 Upgrading (IMPORTANT): Also add
 
     # To handle any existing delayed jobs at time of upgrade.
+    module Sidekiq::Extensions
+    end
     Sidekiq::Extensions::DelayedClass = Sidekiq::DelayExtensions::DelayedClass
     Sidekiq::Extensions::DelayedModel = Sidekiq::DelayExtensions::DelayedModel
     Sidekiq::Extensions::DelayedMailer = Sidekiq::DelayExtensions::DelayedMailer

data/lib/sidekiq/delay_extensions/action_mailer.rb

@@ -12,12 +12,14 @@ module Sidekiq
     #    UserMailer.delay.send_welcome_email(new_user)
     #    UserMailer.delay_for(5.days).send_welcome_email(new_user)
     #    UserMailer.delay_until(5.days.from_now).send_welcome_email(new_user)
-    class DelayedMailer
-      include Sidekiq::Job
-
-      def perform(yml)
-        (target, method_name, args) = YAML.load(yml)
-        msg = target.public_send(method_name, *args)
+    class DelayedMailer < GenericJob
+      def _perform(target, method_name, *args, **kwargs)
+        msg =
+          if kwargs.empty?
+            target.public_send(method_name, *args)
+          else
+            target.public_send(method_name, *args, **kwargs)
+          end
         # The email method can return nil, which causes ActionMailer to return
         # an undeliverable empty message.
         if msg
@@ -29,16 +31,24 @@ module Sidekiq
     end
 
     module ActionMailer
+      def sidekiq_delay_proxy
+        if Sidekiq::DelayExtensions.use_generic_proxy
+          GenericProxy
+        else
+          Proxy
+        end
+      end
+
       def sidekiq_delay(options = {})
-        Proxy.new(DelayedMailer, self, options)
+        sidekiq_delay_proxy.new(DelayedMailer, self, options)
       end
 
       def sidekiq_delay_for(interval, options = {})
-        Proxy.new(DelayedMailer, self, options.merge("at" => Time.now.to_f + interval.to_f))
+        sidekiq_delay_proxy.new(DelayedMailer, self, options.merge("at" => Time.now.to_f + interval.to_f))
       end
 
       def sidekiq_delay_until(timestamp, options = {})
-        Proxy.new(DelayedMailer, self, options.merge("at" => timestamp.to_f))
+        sidekiq_delay_proxy.new(DelayedMailer, self, options.merge("at" => timestamp.to_f))
       end
       alias_method :delay, :sidekiq_delay
       alias_method :delay_for, :sidekiq_delay_for

data/lib/sidekiq/delay_extensions/active_record.rb

@@ -14,26 +14,28 @@ module Sidekiq
     # Please note, this is not recommended as this will serialize the entire
     # object to Redis.  Your Sidekiq jobs should pass IDs, not entire instances.
     # This is here for backwards compatibility with Delayed::Job only.
-    class DelayedModel
-      include Sidekiq::Job
-
-      def perform(yml)
-        (target, method_name, args) = YAML.load(yml)
-        target.__send__(method_name, *args)
-      end
+    class DelayedModel < GenericJob
     end
 
     module ActiveRecord
+      def sidekiq_delay_proxy
+        if Sidekiq::DelayExtensions.use_generic_proxy
+          GenericProxy
+        else
+          Proxy
+        end
+      end
+
       def sidekiq_delay(options = {})
-        Proxy.new(DelayedModel, self, options)
+        sidekiq_delay_proxy.new(DelayedModel, self, options)
       end
 
       def sidekiq_delay_for(interval, options = {})
-        Proxy.new(DelayedModel, self, options.merge("at" => Time.now.to_f + interval.to_f))
+        sidekiq_delay_proxy.new(DelayedModel, self, options.merge("at" => Time.now.to_f + interval.to_f))
       end
 
       def sidekiq_delay_until(timestamp, options = {})
-        Proxy.new(DelayedModel, self, options.merge("at" => timestamp.to_f))
+        sidekiq_delay_proxy.new(DelayedModel, self, options.merge("at" => timestamp.to_f))
       end
       alias_method :delay, :sidekiq_delay
       alias_method :delay_for, :sidekiq_delay_for

data/lib/sidekiq/delay_extensions/api.rb

@@ -41,12 +41,13 @@ module Sidekiq
       # vs.
       # https://github.com/mperham/sidekiq/blob/v7.0.1/lib/sidekiq/api.rb#L374-L411
       def safe_load(content, default)
-        yield(*YAML.load(content))
+        yield(*Sidekiq::DelayExtensions::YAML.unsafe_load(content))
       rescue => ex
         # #1761 in dev mode, it's possible to have jobs enqueued which haven't been loaded into
         # memory yet so the YAML can't be loaded.
         # TODO is this still necessary? Zeitwerk reloader should handle?
-        Sidekiq.logger.warn "Unable to load YAML: #{ex.message}" unless Sidekiq.options[:environment] == "development"
+        sidekiq_env = ::Sidekiq.default_configuration[:environment] || ENV["APP_ENV"] || ENV["RAILS_ENV"] || ENV["RACK_ENV"]
+        ::Sidekiq.logger.warn "Unable to load YAML: #{ex.message}" unless sidekiq_env == "development"
         default
       end
     end

data/lib/sidekiq/delay_extensions/class_methods.rb

@@ -12,26 +12,28 @@ module Sidekiq
     #   User.delay.delete_inactive
     #   Wikipedia.delay.download_changes_for(Date.today)
     #
-    class DelayedClass
-      include Sidekiq::Job
-
-      def perform(yml)
-        (target, method_name, args) = YAML.load(yml)
-        target.__send__(method_name, *args)
-      end
+    class DelayedClass < GenericJob
     end
 
     module Klass
+      def sidekiq_delay_proxy
+        if Sidekiq::DelayExtensions.use_generic_proxy
+          GenericProxy
+        else
+          Proxy
+        end
+      end
+
       def sidekiq_delay(options = {})
-        Proxy.new(DelayedClass, self, options)
+        sidekiq_delay_proxy.new(DelayedClass, self, options)
       end
 
       def sidekiq_delay_for(interval, options = {})
-        Proxy.new(DelayedClass, self, options.merge("at" => Time.now.to_f + interval.to_f))
+        sidekiq_delay_proxy.new(DelayedClass, self, options.merge("at" => Time.now.to_f + interval.to_f))
       end
 
       def sidekiq_delay_until(timestamp, options = {})
-        Proxy.new(DelayedClass, self, options.merge("at" => timestamp.to_f))
+        sidekiq_delay_proxy.new(DelayedClass, self, options.merge("at" => timestamp.to_f))
       end
       alias_method :delay, :sidekiq_delay
       alias_method :delay_for, :sidekiq_delay_for

data/lib/sidekiq/delay_extensions/generic_job.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module DelayExtensions
+    class GenericJob
+      include Sidekiq::Job
+
+      def perform(yml)
+        if !Sidekiq::DelayExtensions.use_generic_proxy
+          (target, method_name, args) = ::Sidekiq::DelayExtensions::YAML.unsafe_load(yml)
+          return _perform(target, method_name, *args)
+        end
+        (target, method_name, args, kwargs) = ::Sidekiq::DelayExtensions::YAML.unsafe_load(yml)
+        if target.is_a?(String)
+          target_klass = target.safe_constantize
+          if target_klass
+            target = target_klass
+          else
+            fail NameError, "uninitialized constant #{target}. Peforming: #{yml.inspect}"
+          end
+        end
+        has_no_kwargs = kwargs.nil? || kwargs.empty? # rubocop:disable Rails/Blank
+        if has_no_kwargs
+          if args.is_a?(Array) && args.last.is_a?(Hash) # && args.last.keys.any? { |key| key.is_a?(Symbol) }
+            # rehydrate keys
+            kwargs = args.pop.symbolize_keys
+            has_no_kwargs = kwargs.empty?
+          elsif args.is_a?(Hash)
+            # rehydrate keys
+            kwargs = args.symbolize_keys
+            args = []
+            has_no_kwargs = kwargs.empty?
+          end
+        end
+        if has_no_kwargs
+          _perform(target, method_name, *args)
+        else
+          _perform(target, method_name, *args, **kwargs)
+        end
+      end
+
+      def _perform(target, method_name, *args, **kwargs)
+        if kwargs.empty?
+          target.__send__(method_name, *args)
+        else
+          target.__send__(method_name, *args, **kwargs)
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/delay_extensions/generic_proxy.rb

@@ -6,6 +6,9 @@ module Sidekiq
   module DelayExtensions
     SIZE_LIMIT = 8_192
 
+    singleton_class.attr_accessor :use_generic_proxy
+    self.use_generic_proxy = false
+
     class Proxy < BasicObject
       def initialize(performable, target, options = {})
         @performable = performable
@@ -29,5 +32,59 @@ module Sidekiq
                                   "display_class" => "#{@target}.#{name}"}.merge(@opts))
       end
     end
+
+    class GenericProxy < BasicObject
+      def initialize(performable, target, options = {})
+        @performable = performable
+        @target = target
+        @opts = options
+      end
+
+      def method_missing(name, *args, **kwargs) # rubocop:disable Style/MissingRespondToMissing
+        begin
+          has_no_kwargs = kwargs.nil? || kwargs.empty?
+          valid_json_args =
+            if has_no_kwargs
+              # if args.last.is_a?(Hash) && args.last.keys.any? { |key| key.is_a?(Symbol) }
+              #   kwargs = args.pop.symbolize_keys
+              [*args]
+            else
+              [*args, ::JSON.parse(::JSON.dump(kwargs))]
+            end
+          obj = [@target.name, name&.to_s, valid_json_args]
+          marshalled = ::JSON.dump(obj)
+        rescue ::JSON::ParserError
+          obj = if kwargs&.any?
+            [@target.name, name&.to_s, *args, **kwargs]
+          else
+            [@target.name, name&.to_s, *args]
+          end
+          ::Sidekiq.logger.warn {
+            "Non-JSON args passed to Sidekiq delayed job. obj=#{obj.inspect}"
+          }
+          marshalled = ::YAML.dump(obj)
+        end
+        # Debug notes:
+        # marshalled = ::YAML.dump(valid_json_args)
+        # marshalled = ::YAML.to_json(valid_json_args)
+        # value = {
+        #   target_name: @target.name,
+        #   name: name,
+        #   args: args,
+        #   kwargs: kwargs,
+        #   valid_json_args: valid_json_args,
+        #   obj: obj,
+        #   marshalled: marshalled,
+        # }
+        # ::STDOUT.puts value.inspect
+        if marshalled.size > SIZE_LIMIT
+          ::Sidekiq.logger.warn { "#{@target}.#{name} job argument is #{marshalled.bytesize} bytes, you should refactor it to reduce the size" }
+        end
+        valid_opts = @opts.stringify_keys
+        @performable.client_push({"class" => @performable,
+                                  "args" => [marshalled],
+                                  "display_class" => "#{@target}.#{name}"}.merge(valid_opts))
+      end
+    end
   end
 end

data/lib/sidekiq/delay_extensions/testing.rb

@@ -14,7 +14,7 @@ module Sidekiq
       jobs.select do |job|
         marshalled = job["args"][0]
         next unless marshalled.index(klass.to_s)
-        YAML.load(marshalled)
+        ::Sidekiq::DelayExtensions::YAML.unsafe_load(marshalled)
       end
     end
   end

data/lib/sidekiq/delay_extensions/version.rb

@@ -2,6 +2,6 @@
 
 module Sidekiq
   module DelayExtensions
-    VERSION = "7.0.0"
+    VERSION = "7.1.0"
   end
 end

data/lib/sidekiq/delay_extensions/yaml.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module DelayExtensions
+    module YAML
+      STDLIB_YAML = ::YAML
+
+      if STDLIB_YAML.respond_to?(:unsafe_load)
+        # https://github.com/ruby/psych/blob/v4.0.3/lib/psych.rb#L271-L323
+        # def self.unsafe_load(yaml, filename: nil, fallback: false, symbolize_names: false, freeze: false)
+        def self.unsafe_load(yaml, **kwargs)
+          STDLIB_YAML.unsafe_load(yaml, **kwargs)
+        end
+
+        # def self.safe_load(yaml, permitted_classes: [], permitted_symbols: [], aliases: false, filename: nil, fallback: nil, symbolize_names: false, freeze: false)
+        def self.safe_load(yaml, **kwargs)
+          STDLIB_YAML.safe_load(yaml, **kwargs)
+        end
+
+        # def self.unsafe_load_file(filename, **kwargs)
+        def self.unsafe_load_file(filename, **kwargs)
+          STDLIB_YAML.unsafe_load_file(filename, **kwargs)
+        end
+
+        # def self.safe_load_file(filename, **kwargs)
+        def self.safe_load_file(filename, **kwargs)
+          STDLIB_YAML.safe_load_file(filename, **kwargs)
+        end
+      else
+        # https://github.com/ruby/psych/blob/v3.1.0/lib/psych.rb#L271-L328
+        # vs.
+        # https://github.com/ruby/psych/blob/v4.0.3/lib/psych.rb#L271-L323
+        # def self.load(       yaml, filename: nil, fallback: false, symbolize_names: false)
+        #   vs.
+        # def self.unsafe_load(yaml, filename: nil, fallback: false, symbolize_names: false, freeze: false)
+        def self.unsafe_load(yaml, **kwargs)
+          STDLIB_YAML.load(yaml, **kwargs)
+        end
+
+        # def self.safe_load(yaml, permitted_classes: [], permitted_symbols: [], aliases: false, filename: nil, fallback: nil, symbolize_names: false)
+        #   vs.
+        # def self.safe_load(yaml, permitted_classes: [], permitted_symbols: [], aliases: false, filename: nil, fallback: nil, symbolize_names: false, freeze: false)
+        def self.safe_load(yaml, **kwargs)
+          STDLIB_YAML.safe_load(yaml, **kwargs)
+        end
+
+        # def self.load_file filename, fallback: false
+        #    vs.
+        # def self.unsafe_load_file(filename, **kwargs)
+        def self.unsafe_load_file(filename, **kwargs)
+          STDLIB_YAML.load_file(filename, **kwargs)
+        end
+
+        # n/a
+        #    vs.
+        # def self.safe_load_file(filename, **kwargs)
+        def self.safe_load_file(filename, **kwargs)
+          STDLIB_YAML.load_file(filename, **kwargs)
+        end
+      end
+      # NOTE(BF): In case someone calls YAML.load
+      # from within the gem.
+      singleton_class.alias_method :load, :unsafe_load
+    end
+  end
+end

data/lib/sidekiq/delay_extensions.rb

@@ -5,6 +5,10 @@ require "sidekiq"
 module Sidekiq
   module DelayExtensions
     def self.enable_delay!
+      require "sidekiq/delay_extensions/yaml"
+
+      require "sidekiq/delay_extensions/generic_job"
+
       if defined?(::ActiveSupport)
         require "sidekiq/delay_extensions/active_record"
         require "sidekiq/delay_extensions/action_mailer"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-delay_extensions
 version: !ruby/object:Gem::Version
-  version: 7.0.0
+  version: 7.1.0
 platform: ruby
 authors:
 - Mike Perham
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-26 00:00:00.000000000 Z
+date: 2024-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -42,9 +42,11 @@ files:
 - lib/sidekiq/delay_extensions/active_record.rb
 - lib/sidekiq/delay_extensions/api.rb
 - lib/sidekiq/delay_extensions/class_methods.rb
+- lib/sidekiq/delay_extensions/generic_job.rb
 - lib/sidekiq/delay_extensions/generic_proxy.rb
 - lib/sidekiq/delay_extensions/testing.rb
 - lib/sidekiq/delay_extensions/version.rb
+- lib/sidekiq/delay_extensions/yaml.rb
 - sidekiq-delay_extensions.gemspec
 homepage: https://github.com/gemhome/sidekiq-delay_extensions/wiki/Delayed-extensions
 licenses: