sidekiq-throttled 1.4.0 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7746a966e9feb8f571468c3f9f790b618faacdb6a6b405183acce7afc9210fb0
-  data.tar.gz: 7b4a320e9ed8bab632e7834f67015b6b377071c77ac0838cf2a2db662c34ec81
+  metadata.gz: 7a601fd050b147fd24ab88416d29273f0cca950c7e540c6303e1c0bb9c47f66d
+  data.tar.gz: 72ebc4a88c60c09faa9922c4f305fbe4374a90ebcafa62f149b83cbae6a356a6
 SHA512:
-  metadata.gz: ed36a36f934b607f08c132db2296a02741d4fad2a4436f4c475bc66f6a0cda49ece9e95782092603e4a3146de4c9b4dc7eec95223d4ba15a3c92715d861a2c91
-  data.tar.gz: c99428f6499ddcc70d89c9b73c8dcbcae275a6a81533645dcc7d8d0d0a7f04492b876afb4d651a934e5df2ad82996925b1f551ff16a9309beba99a146c0726f9
+  metadata.gz: a41505e78b80af968f4aa3ab5076298d8acb62ab4b79046bbb8ff3d7cdb83d456546d066c3c431033418d5754b300cb16c30443b4f66bf82c30b14c5043b3ab4
+  data.tar.gz: 95b3c4839f01711aa6ff3fca8f390ab49981f7e7cf1cf3cd9c289276f945943ada4a3ec9adf96413cf1435f58fe9ea8c08f2b31fc3133e4fbbfca646d0c677b0

data/README.adoc

@@ -31,7 +31,6 @@ Or install it yourself as:
 
   $ gem install sidekiq-throttled
 
-
 == Usage
 
 Add somewhere in your app's bootstrap (e.g. `config/initializers/sidekiq.rb` if
@@ -81,6 +80,17 @@ end
 ----
 
 
+=== Web UI
+
+To add a Throttled tab to your sidekiq web dashboard, require it durring your
+application initialization.
+
+[source,ruby]
+----
+require "sidekiq/throttled/web"
+----
+
+
 === Configuration
 
 [source,ruby]
@@ -89,16 +99,27 @@ Sidekiq::Throttled.configure do |config|
   # Period in seconds to exclude queue from polling in case it returned
   # {config.cooldown_threshold} amount of throttled jobs in a row. Set
   # this value to `nil` to disable cooldown manager completely.
-  # Default: 2.0
-  config.cooldown_period = 2.0
+  # Default: 1.0
+  config.cooldown_period = 1.0
 
   # Exclude queue from polling after it returned given amount of throttled
   # jobs in a row.
-  # Default: 1 (cooldown after first throttled job)
-  config.cooldown_threshold = 1
+  # Default: 100 (cooldown after hundredth throttled job in a row)
+  config.cooldown_threshold = 100
 end
 ----
 
+[WARNING]
+.Cooldown Settings
+====
+If a queue contains a thousand jobs in a row that will be throttled,
+the cooldown will kick-in 10 times in a row, meaning it will take 10 seconds
+before all those jobs are put back at the end of the queue and you actually
+start processing other jobs.
+
+You may want to adjust the cooldown_threshold and cooldown_period,
+keeping in mind that this will also impact the load on your Redis server.
+====
 
 ==== Middleware(s)
 
@@ -290,7 +311,6 @@ dropped.
 
 This library aims to support and work with following Sidekiq versions:
 
-* Sidekiq 6.5.x
 * Sidekiq 7.0.x
 * Sidekiq 7.1.x
 * Sidekiq 7.2.x

data/lib/sidekiq/throttled/config.rb

@@ -19,9 +19,18 @@ module Sidekiq
       # @return [Integer]
       attr_reader :cooldown_threshold
 
+      # Specifies how we should return throttled jobs to the queue so they can be executed later.
+      # Expects a hash with keys that may include :with and :to
+      # For :with, options are `:enqueue` (put them on the end of the queue) and `:schedule` (schedule for later).
+      # For :to, the name of a sidekiq queue should be specified. If none is specified, jobs will by default be
+      # requeued to the same queue they were originally enqueued in.
+      # Default: {with: `:enqueue`}
+      #
+      # @return [Hash]
+      attr_reader :default_requeue_options
+
       def initialize
-        @cooldown_period    = 2.0
-        @cooldown_threshold = 1
+        reset!
       end
 
       # @!attribute [w] cooldown_period
@@ -39,6 +48,19 @@ module Sidekiq
 
         @cooldown_threshold = value
       end
+
+      # @!attribute [w] default_requeue_options
+      def default_requeue_options=(options)
+        requeue_with = options.delete(:with).intern || :enqueue
+
+        @default_requeue_options = options.merge({ with: requeue_with })
+      end
+
+      def reset!
+        @cooldown_period    = 1.0
+        @cooldown_threshold = 100
+        @default_requeue_options = { with: :enqueue }
+      end
     end
   end
 end

data/lib/sidekiq/throttled/job.rb

@@ -13,8 +13,9 @@ module Sidekiq
     #       include Sidekiq::Job
     #       include Sidekiq::Throttled::Job
     #
-    #       sidekiq_options :queue => :my_queue
-    #       sidekiq_throttle :threshold => { :limit => 123, :period => 1.hour }
+    #       sidkiq_options :queue => :my_queue
+    #       sidekiq_throttle :threshold => { :limit => 123, :period => 1.hour },
+    #                        :requeue => { :to => :other_queue, :with => :schedule }
     #
     #       def perform
     #         # ...
@@ -30,6 +31,7 @@ module Sidekiq
       #
       # @private
       def self.included(base)
+        base.sidekiq_class_attribute :sidekiq_throttled_requeue_options
         base.extend(ClassMethods)
       end
 
@@ -71,6 +73,19 @@ module Sidekiq
         #       })
         #     end
         #
+        # @example Allow max 123 MyJob jobs per hour; when jobs are throttled, schedule them for later in :other_queue
+        #
+        #     class MyJob
+        #       include Sidekiq::Job
+        #       include Sidekiq::Throttled::Job
+        #
+        #       sidekiq_throttle({
+        #         :threshold => { :limit => 123, :period => 1.hour },
+        #         :requeue => { :to => :other_queue, :with => :schedule }
+        #       })
+        #     end
+        #
+        # @param [Hash] requeue What to do with jobs that are throttled
         # @see Registry.add
         # @return [void]
         def sidekiq_throttle(**kwargs)

data/lib/sidekiq/throttled/patches/basic_fetch.rb

@@ -15,17 +15,6 @@ module Sidekiq
 
         private
 
-        # Pushes job back to the head of the queue, so that job won't be tried
-        # immediately after it was requeued (in most cases).
-        #
-        # @note This is triggered when job is throttled. So it is same operation
-        #   Sidekiq performs upon `Sidekiq::Worker.perform_async` call.
-        #
-        # @return [void]
-        def requeue_throttled(work)
-          redis { |conn| conn.lpush(work.queue, work.job) }
-        end
-
         # Returns list of queues to try to fetch jobs from.
         #
         # @note It may return an empty array.

data/lib/sidekiq/throttled/patches/super_fetch.rb

@@ -14,19 +14,6 @@ module Sidekiq
 
         private
 
-        # Calls SuperFetch UnitOfWork's requeue to remove the job from the
-        # temporary queue and push job back to the head of the queue, so that
-        # the job won't be tried immediately after it was requeued (in most cases).
-        #
-        # @note This is triggered when job is throttled.
-        #
-        # @return [void]
-        def requeue_throttled(work)
-          # SuperFetch UnitOfWork's requeue will remove it from the temporary
-          # queue and then requeue it, so no acknowledgement call is needed.
-          work.requeue
-        end
-
         # Returns list of non-paused queues to try to fetch jobs from.
         #
         # @note It may return an empty array.

data/lib/sidekiq/throttled/patches/throttled_retriever.rb

@@ -12,7 +12,7 @@ module Sidekiq
 
           if work && Throttled.throttled?(work.job)
             Throttled.cooldown&.notify_throttled(work.queue)
-            requeue_throttled(work)
+            Throttled.requeue_throttled(work)
             return nil
           end
 

data/lib/sidekiq/throttled/strategy/concurrency.rb

@@ -52,6 +52,16 @@ module Sidekiq
           Sidekiq.redis { |redis| 1 == SCRIPT.call(redis, keys: keys, argv: argv) }
         end
 
+        # @return [Float] How long, in seconds, before we'll next be able to take on jobs
+        def retry_in(_jid, *job_args)
+          job_limit = limit(job_args)
+          return 0.0 if !job_limit || count(*job_args) < job_limit
+
+          oldest_jid_with_score = Sidekiq.redis { |redis| redis.zrange(key(job_args), 0, 0, withscores: true) }.first
+          expiry_time = oldest_jid_with_score.last.to_f
+          expiry_time - Time.now.to_f
+        end
+
         # @return [Integer] Current count of jobs
         def count(*job_args)
           Sidekiq.redis { |conn| conn.zcard(key(job_args)) }.to_i

data/lib/sidekiq/throttled/strategy/threshold.rb

@@ -69,6 +69,25 @@ module Sidekiq
           Sidekiq.redis { |redis| 1 == SCRIPT.call(redis, keys: keys, argv: argv) }
         end
 
+        # @return [Float] How long, in seconds, before we'll next be able to take on jobs
+        def retry_in(*job_args)
+          job_limit = limit(job_args)
+          return 0.0 if !job_limit || count(*job_args) < job_limit
+
+          job_period = period(job_args)
+          job_key = key(job_args)
+          time_since_oldest = Time.now.to_f - Sidekiq.redis { |redis| redis.lindex(job_key, -1) }.to_f
+          if time_since_oldest > job_period
+            # The oldest job on our list is from more than the throttling period ago,
+            # which means we have not hit the limit this period.
+            0.0
+          else
+            # If we can only have X jobs every Y minutes, then wait until Y minutes have elapsed
+            # since the oldest job on our list.
+            job_period - time_since_oldest
+          end
+        end
+
         # @return [Integer] Current count of jobs
         def count(*job_args)
           Sidekiq.redis { |conn| conn.llen(key(job_args)) }.to_i

data/lib/sidekiq/throttled/strategy.rb

@@ -11,7 +11,11 @@ module Sidekiq
     # Meta-strategy that couples {Concurrency} and {Threshold} strategies.
     #
     # @private
-    class Strategy
+    class Strategy # rubocop:disable Metrics/ClassLength
+      # :enqueue means put the job back at the end of the queue immediately
+      # :schedule means schedule enqueueing the job for a later time when we expect to have capacity
+      VALID_VALUES_FOR_REQUEUE_WITH = %i[enqueue schedule].freeze
+
       # @!attribute [r] concurrency
       #   @return [Strategy::Concurrency, nil]
       attr_reader :concurrency
@@ -24,6 +28,10 @@ module Sidekiq
       #   @return [Proc, nil]
       attr_reader :observer
 
+      # @!attribute [r] requeue_options
+      #   @return [Hash, nil]
+      attr_reader :requeue_options
+
       # @param [#to_s] name
       # @param [Hash] concurrency Concurrency options.
       #   See keyword args of {Strategy::Concurrency#initialize} for details.
@@ -31,7 +39,8 @@ module Sidekiq
       #   See keyword args of {Strategy::Threshold#initialize} for details.
       # @param [#call] key_suffix Dynamic key suffix generator.
       # @param [#call] observer Process called after throttled.
-      def initialize(name, concurrency: nil, threshold: nil, key_suffix: nil, observer: nil) # rubocop:disable Metrics/MethodLength
+      # @param [#call] requeue What to do with jobs that are throttled.
+      def initialize(name, concurrency: nil, threshold: nil, key_suffix: nil, observer: nil, requeue: nil) # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
         @observer = observer
 
         @concurrency = StrategyCollection.new(concurrency,
@@ -44,9 +53,9 @@ module Sidekiq
           name:       name,
           key_suffix: key_suffix)
 
-        return if @concurrency.any? || @threshold.any?
+        @requeue_options = Throttled.config.default_requeue_options.merge(requeue || {})
 
-        raise ArgumentError, "Neither :concurrency nor :threshold given"
+        validate!
       end
 
       # @return [Boolean] whenever strategy has dynamic config
@@ -74,18 +83,124 @@ module Sidekiq
         false
       end
 
+      # @return [Proc, Symbol] How to requeue the throttled job
+      def requeue_with
+        requeue_options[:with]
+      end
+
+      # @return [String, nil] Name of the queue to re-queue the job to.
+      def requeue_to
+        requeue_options[:to]
+      end
+
+      # Return throttled job to be executed later. Implementation depends on the strategy's `requeue` options.
+      # @return [void]
+      def requeue_throttled(work) # rubocop:disable Metrics/MethodLength
+        # Resolve :with and :to options, calling them if they are Procs
+        job_args = JSON.parse(work.job)["args"]
+        with = requeue_with.respond_to?(:call) ? requeue_with.call(*job_args) : requeue_with
+        target_queue = calc_target_queue(work)
+
+        case with
+        when :enqueue
+          re_enqueue_throttled(work, target_queue)
+        when :schedule
+          # Find out when we will next be able to execute this job, and reschedule for then.
+          reschedule_throttled(work, target_queue)
+        else
+          raise "unrecognized :with option #{with}"
+        end
+      end
+
       # Marks job as being processed.
       # @return [void]
       def finalize!(jid, *job_args)
         @concurrency&.finalize!(jid, *job_args)
       end
 
-      # Resets count of jobs of all avaliable strategies
+      # Resets count of jobs of all available strategies
       # @return [void]
       def reset!
         @concurrency&.reset!
         @threshold&.reset!
       end
+
+      private
+
+      def validate!
+        unless VALID_VALUES_FOR_REQUEUE_WITH.include?(@requeue_options[:with]) ||
+               @requeue_options[:with].respond_to?(:call)
+          raise ArgumentError, "requeue: #{@requeue_options[:with]} is not a valid value for :with"
+        end
+
+        raise ArgumentError, "Neither :concurrency nor :threshold given" unless @concurrency.any? || @threshold.any?
+      end
+
+      def calc_target_queue(work) # rubocop:disable Metrics/MethodLength
+        target = case requeue_to
+                 when Proc, Method
+                   requeue_to.call(*JSON.parse(work.job)["args"])
+                 when NilClass
+                   work.queue
+                 when String, Symbol
+                   requeue_to.to_s
+                 else
+                   raise ArgumentError, "Invalid argument for `to`"
+                 end
+
+        target = work.queue if target.nil? || target.empty?
+
+        target.start_with?("queue:") ? target : "queue:#{target}"
+      end
+
+      # Push the job back to the head of the queue.
+      def re_enqueue_throttled(work, target_queue)
+        case work.class.name
+        when "Sidekiq::Pro::SuperFetch::UnitOfWork"
+          # Calls SuperFetch UnitOfWork's requeue to remove the job from the
+          # temporary queue and push job back to the head of the target queue, so that
+          # the job won't be tried immediately after it was requeued (in most cases).
+          work.queue = target_queue if target_queue
+          work.requeue
+        else
+          # This is the same operation Sidekiq performs upon `Sidekiq::Worker.perform_async` call.
+          Sidekiq.redis { |conn| conn.lpush(target_queue, work.job) }
+        end
+      end
+
+      def reschedule_throttled(work, target_queue)
+        message = JSON.parse(work.job)
+        job_class = message.fetch("wrapped") { message.fetch("class") { return false } }
+        job_args = message["args"]
+
+        # Re-enqueue the job to the target queue at another time as a NEW unit of work
+        # AND THEN mark this work as done, so SuperFetch doesn't think this instance is orphaned
+        # Technically, the job could processed twice if the process dies between the two lines,
+        # but your job should be idempotent anyway, right?
+        # The job running twice was already a risk with SuperFetch anyway and this doesn't really increase that risk.
+        Sidekiq::Client.enqueue_to_in(target_queue, retry_in(work), Object.const_get(job_class), *job_args)
+        work.acknowledge
+      end
+
+      def retry_in(work)
+        message = JSON.parse(work.job)
+        jid = message.fetch("jid") { return false }
+        job_args = message["args"]
+
+        # Ask both concurrency and threshold, if relevant, how long minimum until we can retry.
+        # If we get two answers, take the longer one.
+        intervals = [@concurrency&.retry_in(jid, *job_args), @threshold&.retry_in(*job_args)].compact
+
+        raise "Cannot compute a valid retry interval" if intervals.empty?
+
+        interval = intervals.max
+
+        # Add a random amount of jitter, proportional to the length of the minimum retry time.
+        # This helps spread out jobs more evenly and avoid clumps of jobs on the queue.
+        interval += rand(interval / 5) if interval > 10
+
+        interval
+      end
     end
   end
 end

data/lib/sidekiq/throttled/strategy_collection.rb

@@ -41,6 +41,11 @@ module Sidekiq
         any? { |s| s.throttled?(...) }
       end
 
+      # @return [Float] How long, in seconds, before we'll next be able to take on jobs
+      def retry_in(*args)
+        max { |s| s.retry_in(*args) }
+      end
+
       # Marks job as being processed.
       # @return [void]
       def finalize!(...)

data/lib/sidekiq/throttled/version.rb

@@ -3,6 +3,6 @@
 module Sidekiq
   module Throttled
     # Gem version
-    VERSION = "1.4.0"
+    VERSION = "1.5.1"
   end
 end

data/lib/sidekiq/throttled.rb

@@ -54,6 +54,11 @@ module Sidekiq
       # @return [Cooldown, nil]
       attr_reader :cooldown
 
+      # @api internal
+      #
+      # @return [Config, nil]
+      attr_reader :config
+
       # @example
       #   Sidekiq::Throttled.configure do |config|
       #     config.cooldown_period = nil # Disable queues cooldown manager
@@ -88,15 +93,16 @@ module Sidekiq
         false
       end
 
-      # @deprecated Will be removed in 2.0.0
-      def setup!
-        warn "Sidekiq::Throttled.setup! was deprecated"
+      # Return throttled job to be executed later, delegating the details of how to do that
+      # to the Strategy for that job.
+      #
+      # @return [void]
+      def requeue_throttled(work)
+        message = JSON.parse(work.job)
+        job_class = Object.const_get(message.fetch("wrapped") { message.fetch("class") { return false } })
 
-        Sidekiq.configure_server do |config|
-          config.server_middleware do |chain|
-            chain.remove(Sidekiq::Throttled::Middlewares::Server)
-            chain.add(Sidekiq::Throttled::Middlewares::Server)
-          end
+        Registry.get job_class do |strategy|
+          strategy.requeue_throttled(work)
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-throttled
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.1
 platform: ruby
 authors:
 - Alexey Zapparov
 autorequire:
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2024-04-07 00:00:00.000000000 Z
+date: 2024-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -90,9 +90,9 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/ixti/sidekiq-throttled
-  source_code_uri: https://github.com/ixti/sidekiq-throttled/tree/v1.4.0
+  source_code_uri: https://github.com/ixti/sidekiq-throttled/tree/v1.5.1
   bug_tracker_uri: https://github.com/ixti/sidekiq-throttled/issues
-  changelog_uri: https://github.com/ixti/sidekiq-throttled/blob/v1.4.0/CHANGES.md
+  changelog_uri: https://github.com/ixti/sidekiq-throttled/blob/v1.5.1/CHANGES.md
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
@@ -109,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.4
+rubygems_version: 3.4.22
 signing_key:
 specification_version: 4
 summary: Concurrency and rate-limit throttling for Sidekiq