sidekiq-throttled 0.16.2 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f13258e6221758892919e37d8d233b33b52f46d3e6ae4f61700f009f1bb0553
-  data.tar.gz: a50132e8af4521c5c2d4f8edc3bcdc8d823160bd7c7ad2980bce6c4b10a29087
+  metadata.gz: 7746a966e9feb8f571468c3f9f790b618faacdb6a6b405183acce7afc9210fb0
+  data.tar.gz: 7b4a320e9ed8bab632e7834f67015b6b377071c77ac0838cf2a2db662c34ec81
 SHA512:
-  metadata.gz: 5cb7186478fa6eced7c69086aee8b7ba626b504db5d2b594bd416a3ce24254d9670047216c92290cc023c578c8cb83ab4cce952f6dc568055ca00a7707b8ef27
-  data.tar.gz: 44d7b64362ef7fd1fbf97e588c3048f249610f6613d3517ad3aa8a78f31447c93dd52ee2fa9fde84f84dc602620c1fa78081e29d96e78c43f327527f683ac953
+  metadata.gz: ed36a36f934b607f08c132db2296a02741d4fad2a4436f4c475bc66f6a0cda49ece9e95782092603e4a3146de4c9b4dc7eec95223d4ba15a3c92715d861a2c91
+  data.tar.gz: c99428f6499ddcc70d89c9b73c8dcbcae275a6a81533645dcc7d8d0d0a7f04492b876afb4d651a934e5df2ad82996925b1f551ff16a9309beba99a146c0726f9

data/README.adoc

@@ -0,0 +1,332 @@
+= Sidekiq::Throttled
+:ci-link: https://github.com/ixti/sidekiq-throttled/actions/workflows/ci.yml
+:ci-badge: https://img.shields.io/github/actions/workflow/status/ixti/sidekiq-throttled/ci.yml?branch=main&style=for-the-badge
+:gem-link: http://rubygems.org/gems/sidekiq-throttled
+:gem-badge: https://img.shields.io/gem/v/sidekiq-throttled?style=for-the-badge
+:doc-link: http://www.rubydoc.info/gems/sidekiq-throttled
+:doc-badge: https://img.shields.io/badge/Documentation-API-blue?style=for-the-badge
+
+****
+{ci-link}[image:{ci-badge}[CI Status]]
+{gem-link}[image:{gem-badge}[Latest Version]]
+{doc-link}[image:{doc-badge}[API Documentation]]
+****
+
+Concurrency and threshold throttling for https://github.com/sidekiq/sidekiq[Sidekiq].
+
+== Installation
+
+Add this line to your application's Gemfile:
+
+[source,ruby]
+----
+gem "sidekiq-throttled"
+----
+
+And then execute:
+
+  $ bundle
+
+Or install it yourself as:
+
+  $ gem install sidekiq-throttled
+
+
+== Usage
+
+Add somewhere in your app's bootstrap (e.g. `config/initializers/sidekiq.rb` if
+you are using Rails):
+
+[source,ruby]
+----
+require "sidekiq/throttled"
+----
+
+Once you've done that you can include `Sidekiq::Throttled::Job` to your
+job classes and configure throttling:
+
+[source,ruby]
+----
+class MyJob
+  include Sidekiq::Job
+  include Sidekiq::Throttled::Job
+
+  sidekiq_options :queue => :my_queue
+
+  sidekiq_throttle(
+    # Allow maximum 10 concurrent jobs of this class at a time.
+    concurrency: { limit: 10 },
+    # Allow maximum 1K jobs being processed within one hour window.
+    threshold: { limit: 1_000, period: 1.hour }
+  )
+
+  def perform
+    # ...
+  end
+end
+----
+
+TIP: `Sidekiq::Throttled::Job` is aliased as `Sidekiq::Throttled::Worker`,
+  thus if you're using `Sidekiq::Worker` naming convention, you can use the
+  alias for consistency:
+
+[source,ruby]
+----
+class MyWorker
+  include Sidekiq::Worker
+  include Sidekiq::Throttled::Worker
+
+  # ...
+end
+----
+
+
+=== Configuration
+
+[source,ruby]
+----
+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
+
+  # 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
+end
+----
+
+
+==== Middleware(s)
+
+`Sidekiq::Throttled` relies on following bundled middlewares:
+
+* `Sidekiq::Throttled::Middlewares::Server`
+
+The middleware is automatically injected when you require `sidekiq/throttled`.
+In rare cases, when this causes an issue, you can change middleware order manually:
+
+[source,ruby]
+----
+Sidekiq.configure_server do |config|
+  # ...
+
+  config.server_middleware do |chain|
+    chain.prepend(Sidekiq::Throttled::Middlewares::Server)
+  end
+end
+----
+
+See: https://github.com/sidekiq/sidekiq/blob/main/lib/sidekiq/middleware/chain.rb
+
+
+=== Observer
+
+You can specify an observer that will be called on throttling. To do so pass an
+`:observer` option with callable object:
+
+[source,ruby]
+----
+class MyJob
+  include Sidekiq::Job
+  include Sidekiq::Throttled::Job
+
+  MY_OBSERVER = lambda do |strategy, *args|
+    # do something
+  end
+
+  sidekiq_options queue: :my_queue
+
+  sidekiq_throttle(
+    concurrency: { limit: 10 },
+    threshold:   { limit: 100, period: 1.hour },
+    observer:    MY_OBSERVER
+  )
+
+  def perform(*args)
+    # ...
+  end
+end
+----
+
+Observer will receive `strategy, *args` arguments, where `strategy` is a Symbol
+`:concurrency` or `:threshold`, and `*args` are the arguments that were passed
+to the job.
+
+
+=== Dynamic throttling
+
+You can throttle jobs dynamically with `:key_suffix` option:
+
+[source,ruby]
+----
+class MyJob
+  include Sidekiq::Job
+  include Sidekiq::Throttled::Job
+
+  sidekiq_options queue: :my_queue
+
+  sidekiq_throttle(
+    # Allow maximum 10 concurrent jobs per user at a time.
+    concurrency: { limit: 10, key_suffix: -> (user_id) { user_id } }
+  )
+
+  def perform(user_id)
+    # ...
+  end
+end
+----
+
+You can also supply dynamic values for limits and periods by supplying a proc
+for these values. The proc will be evaluated at the time the job is fetched
+and will receive the same arguments that are passed to the job.
+
+[source,ruby]
+----
+class MyJob
+  include Sidekiq::Job
+  include Sidekiq::Throttled::Job
+
+  sidekiq_options queue: :my_queue
+
+  sidekiq_throttle(
+    # Allow maximum 1000 concurrent jobs of this class at a time for VIPs and 10 for all other users.
+    concurrency: {
+      limit:      ->(user_id) { User.vip?(user_id) ? 1_000 : 10 },
+      key_suffix: ->(user_id) { User.vip?(user_id) ? "vip" : "std" }
+    },
+    # Allow 1000 jobs/hour to be processed for VIPs and 10/day for all others
+    threshold: {
+      limit:      ->(user_id) { User.vip?(user_id) ? 1_000 : 10 },
+      period:     ->(user_id) { User.vip?(user_id) ? 1.hour : 1.day },
+      key_suffix: ->(user_id) { User.vip?(user_id) ? "vip" : "std" }
+    }
+  )
+
+  def perform(user_id)
+    # ...
+  end
+end
+----
+
+You also can use several different keys to throttle one worker.
+
+[source,ruby]
+----
+class MyJob
+  include Sidekiq::Job
+  include Sidekiq::Throttled::Job
+
+  sidekiq_options queue: :my_queue
+
+  sidekiq_throttle(
+    # Allow maximum 10 concurrent jobs per project at a time and maximum 2 jobs per user
+    concurrency: [
+      { limit: 10, key_suffix: -> (project_id, user_id) { project_id } },
+      { limit: 2, key_suffix: -> (project_id, user_id) { user_id } }
+    ]
+    # For :threshold it works the same
+  )
+
+  def perform(project_id, user_id)
+    # ...
+  end
+end
+----
+
+IMPORTANT: Don't forget to specify `:key_suffix` and make it return different
+  values if you are using dynamic limit/period options. Otherwise, you risk
+  getting into some trouble.
+
+
+=== Concurrency throttling fine-tuning
+
+Concurrency throttling is based on distributed locks. Those locks have default
+time to live (TTL) set to 15 minutes. If your job takes more than 15 minutes
+to finish, lock will be released and you might end up with more jobs running
+concurrently than you expect.
+
+This is done to avoid deadlocks - when by any reason (e.g. Sidekiq process was
+OOM-killed) cleanup middleware wasn't executed and locks were not released.
+
+If your job takes more than 15 minutes to complete, you can tune concurrency
+lock TTL to fit your needs:
+
+[source,ruby]
+----
+# Set concurrency strategy lock TTL to 1 hour.
+sidekiq_throttle(concurrency: { limit: 20, ttl: 1.hour.to_i })
+----
+
+
+== Supported Ruby Versions
+
+This library aims to support and is tested against the following Ruby versions:
+
+* Ruby 2.7.x
+* Ruby 3.0.x
+* Ruby 3.1.x
+* Ruby 3.2.x
+* Ruby 3.3.x
+
+If something doesn't work on one of these versions, it's a bug.
+
+This library may inadvertently work (or seem to work) on other Ruby versions,
+however support will only be provided for the versions listed above.
+
+If you would like this library to support another Ruby version or
+implementation, you may volunteer to be a maintainer. Being a maintainer
+entails making sure all tests run and pass on that implementation. When
+something breaks on your implementation, you will be responsible for providing
+patches in a timely fashion. If critical issues for a particular implementation
+exist at the time of a major release, support for that Ruby version may be
+dropped.
+
+
+== Supported Sidekiq Versions
+
+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
+
+And the following Sidekiq Pro versions:
+
+* Sidekiq Pro 7.0.x
+* Sidekiq Pro 7.1.x
+* Sidekiq Pro 7.2.x
+
+== Development
+
+  bundle install
+  bundle exec appraisal generate
+  bundle exec appraisal install
+  bundle exec rake
+
+=== Sidekiq-Pro
+
+If you're working on Sidekiq-Pro support make sure that you have Sidekiq-Pro
+license set either in the global config, or in `BUNDLE_GEMS\__CONTRIBSYS__COM`
+environment variable.
+
+== Contributing
+
+* Fork sidekiq-throttled on GitHub
+* Make your changes
+* Ensure all tests pass (`bundle exec rake`)
+* Send a pull request
+* If we like them we'll merge them
+* If we've accepted a patch, feel free to ask for commit access!
+
+
+== Endorsement
+
+https://github.com/sensortower[image:sensortower.svg[SensorTower]]
+
+The initial work on the project was initiated to address the needs of
+https://github.com/sensortower[SensorTower].

data/lib/sidekiq/throttled/config.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module Throttled
+    # Configuration object.
+    class Config
+      # Period in seconds to exclude queue from polling in case it returned
+      # {#cooldown_threshold} amount of throttled jobs in a row.
+      #
+      # Set this to `nil` to disable cooldown completely.
+      #
+      # @return [Float, nil]
+      attr_reader :cooldown_period
+
+      # Amount of throttled jobs returned from the queue subsequently after
+      # which queue will be excluded from polling for the durations of
+      # {#cooldown_period}.
+      #
+      # @return [Integer]
+      attr_reader :cooldown_threshold
+
+      def initialize
+        @cooldown_period    = 2.0
+        @cooldown_threshold = 1
+      end
+
+      # @!attribute [w] cooldown_period
+      def cooldown_period=(value)
+        raise TypeError, "unexpected type #{value.class}" unless value.nil? || value.is_a?(Float)
+        raise ArgumentError, "period must be positive"    unless value.nil? || value.positive?
+
+        @cooldown_period = value
+      end
+
+      # @!attribute [w] cooldown_threshold
+      def cooldown_threshold=(value)
+        raise TypeError, "unexpected type #{value.class}" unless value.is_a?(Integer)
+        raise ArgumentError, "threshold must be positive" unless value.positive?
+
+        @cooldown_threshold = value
+      end
+    end
+  end
+end

data/lib/sidekiq/throttled/cooldown.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "concurrent"
+
+require_relative "./expirable_set"
+
+module Sidekiq
+  module Throttled
+    # @api internal
+    #
+    # Queues cooldown manager. Tracks list of queues that should be temporarily
+    # (for the duration of {Config#cooldown_period}) excluded from polling.
+    class Cooldown
+      class << self
+        # Returns new {Cooldown} instance if {Config#cooldown_period} is not `nil`.
+        #
+        # @param config [Config]
+        # @return [Cooldown, nil]
+        def [](config)
+          new(config) if config.cooldown_period
+        end
+      end
+
+      # @param config [Config]
+      def initialize(config)
+        @queues    = ExpirableSet.new(config.cooldown_period)
+        @threshold = config.cooldown_threshold
+        @tracker   = Concurrent::Map.new
+      end
+
+      # Notify that given queue returned job that was throttled.
+      #
+      # @param queue [String]
+      # @return [void]
+      def notify_throttled(queue)
+        @queues.add(queue) if @threshold <= @tracker.merge_pair(queue, 1, &:succ)
+      end
+
+      # Notify that given queue returned job that was not throttled.
+      #
+      # @param queue [String]
+      # @return [void]
+      def notify_admitted(queue)
+        @tracker.delete(queue)
+      end
+
+      # List of queues that should not be polled
+      #
+      # @return [Array<String>]
+      def queues
+        @queues.to_a
+      end
+    end
+  end
+end

data/lib/sidekiq/throttled/expirable_set.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "concurrent"
+
+module Sidekiq
+  module Throttled
+    # @api internal
+    #
+    # Set of elements with expirations.
+    #
+    # @example
+    #   set = ExpirableSet.new(10.0)
+    #   set.add("a")
+    #   sleep(5)
+    #   set.add("b")
+    #   set.to_a # => ["a", "b"]
+    #   sleep(5)
+    #   set.to_a # => ["b"]
+    class ExpirableSet
+      include Enumerable
+
+      # @param ttl [Float] expiration is seconds
+      # @raise [ArgumentError] if `ttl` is not positive Float
+      def initialize(ttl)
+        raise ArgumentError, "ttl must be positive Float" unless ttl.is_a?(Float) && ttl.positive?
+
+        @elements = Concurrent::Map.new
+        @ttl      = ttl
+      end
+
+      # @param element [Object]
+      # @return [ExpirableSet] self
+      def add(element)
+        # cleanup expired elements to avoid mem-leak
+        horizon = now
+        expired = @elements.each_pair.select { |(_, sunset)| expired?(sunset, horizon) }
+        expired.each { |pair| @elements.delete_pair(*pair) }
+
+        # add new element
+        @elements[element] = now + @ttl
+
+        self
+      end
+
+      # @yield [Object] Gives each live (not expired) element to the block
+      def each
+        return to_enum __method__ unless block_given?
+
+        horizon = now
+
+        @elements.each_pair do |element, sunset|
+          yield element unless expired?(sunset, horizon)
+        end
+
+        self
+      end
+
+      private
+
+      # @return [Float]
+      def now
+        ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      end
+
+      def expired?(sunset, horizon)
+        sunset <= horizon
+      end
+    end
+  end
+end

data/lib/sidekiq/throttled/job.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # internal
-require "sidekiq/throttled/registry"
+require_relative "./registry"
 
 module Sidekiq
   module Throttled
@@ -13,7 +13,7 @@ module Sidekiq
     #       include Sidekiq::Job
     #       include Sidekiq::Throttled::Job
     #
-    #       sidkiq_options :queue => :my_queue
+    #       sidekiq_options :queue => :my_queue
     #       sidekiq_throttle :threshold => { :limit => 123, :period => 1.hour }
     #
     #       def perform
@@ -29,8 +29,8 @@ module Sidekiq
       #   in order to make API inline with `include Sidekiq::Job`.
       #
       # @private
-      def self.included(worker)
-        worker.send(:extend, ClassMethods)
+      def self.included(base)
+        base.extend(ClassMethods)
       end
 
       # Helper methods added to the singleton class of destination

data/lib/sidekiq/throttled/message.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  module Throttled
+    class Message
+      def initialize(item)
+        @item = item.is_a?(Hash) ? item : parse(item)
+      end
+
+      def job_class
+        @item.fetch("wrapped") { @item["class"] }
+      end
+
+      def job_args
+        @item.key?("wrapped") ? @item.dig("args", 0, "arguments") : @item["args"]
+      end
+
+      def job_id
+        @item["jid"]
+      end
+
+      private
+
+      def parse(item)
+        item = Sidekiq.load_json(item)
+        item.is_a?(Hash) ? item : {}
+      rescue JSON::ParserError
+        {}
+      end
+    end
+  end
+end

data/lib/sidekiq/throttled/middlewares/server.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# internal
+require_relative "../message"
+require_relative "../registry"
+
+module Sidekiq
+  module Throttled
+    module Middlewares
+      # Server middleware required for Sidekiq::Throttled functioning.
+      class Server
+        include Sidekiq::ServerMiddleware
+
+        def call(_worker, msg, _queue)
+          yield
+        ensure
+          message = Message.new(msg)
+
+          if message.job_class && message.job_id
+            Registry.get(message.job_class) do |strategy|
+              strategy.finalize!(message.job_id, *message.job_args)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+require "sidekiq/fetch"
+
+require_relative "./throttled_retriever"
+
+module Sidekiq
+  module Throttled
+    module Patches
+      module BasicFetch
+        def self.prepended(base)
+          base.prepend(ThrottledRetriever)
+        end
+
+        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.
+        # @param [Array<String>] queues
+        # @return [Array<String>]
+        def queues_cmd
+          throttled_queues = Throttled.cooldown&.queues
+          return super if throttled_queues.nil? || throttled_queues.empty?
+
+          super - throttled_queues
+        end
+      end
+    end
+  end
+end
+
+Sidekiq::BasicFetch.prepend(Sidekiq::Throttled::Patches::BasicFetch)

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+
+require_relative "./throttled_retriever"
+
+module Sidekiq
+  module Throttled
+    module Patches
+      module SuperFetch
+        def self.prepended(base)
+          base.prepend(ThrottledRetriever)
+        end
+
+        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.
+        # @return [Array<Array(String, String)>]
+        def active_queues
+          # Create a hash of throttled queues for fast lookup
+          throttled_queues = Throttled.cooldown&.queues&.to_h { |queue| [queue, true] }
+          return super if throttled_queues.nil? || throttled_queues.empty?
+
+          # Reject throttled queues from the list of active queues
+          super.reject { |queue, _private_queue| throttled_queues[queue] }
+        end
+      end
+    end
+  end
+end
+
+begin
+  require "sidekiq/pro/super_fetch"
+  Sidekiq::Pro::SuperFetch.prepend(Sidekiq::Throttled::Patches::SuperFetch)
+rescue LoadError
+  # Sidekiq Pro is not available
+end