sidekiq-throttled 0.18.0 → 1.0.0.alpha

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9709e5805bd1bf11ef204afb08a988a4c5998e16ecf8a7a0b8e0c1b4b753ce4d
-  data.tar.gz: 21b5bdd50945f807e11884a18449be0155cb8bdf2b6ee37b633148b198db615d
+  metadata.gz: 7659ca0e722a87bc85f4e9d73a38075cf005b72515bbaf06604eabaab77d8fdd
+  data.tar.gz: 28c53a85bb5d346d09d8ec08c6d23cecc687b6ec35e4c9779c07eba32bc635d6
 SHA512:
-  metadata.gz: 613164a091883655c4bd879b3dab25198ffc88e49eb7f1e1b0bab33eb2a7eb004b2f6d407e65ccfea52727e347f1b5d8c05015117b5da8500a2a933228044ef4
-  data.tar.gz: 9b2dde3fd9ecdf25301597bd86609f531f7a8b5d8a90833f7f0d42399501a3d49252fa78af3cc576007cdf8b7025b86223c1a9d1391ab9069c6277220adb7524
+  metadata.gz: 2b03a9d8f51981c778c4a7b0fb84d7c20dabf902eefb00518a98a4c5a028119e820cd93920946516a51e0a399e05cf2692d12e7b59b814b37045b4dc6f852c43
+  data.tar.gz: 37478b95ae4f5426f82dceec1aa918722772c9a2c785b7c94420460b897c52cc0eee1cce02f5d03214c5d28113c3c798f5c13e31fb342ae935d92a07bc60f9b7

data/{README.md → README.adoc}

@@ -1,37 +1,51 @@
-# Sidekiq::Throttled
+= 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 Status](https://github.com/ixti/sidekiq-throttled/actions/workflows/ci.yml/badge.svg)](https://github.com/ixti/sidekiq-throttled/actions/workflows/ci.yml)
-[![Latest Version](https://badge.fury.io/rb/sidekiq-throttled.svg)](http://rubygems.org/gems/sidekiq-throttled)
-[![API Docs](https://img.shields.io/badge/yard-docs-blue.svg)](http://www.rubydoc.info/gems/sidekiq-throttled)
+****
+{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 [Sidekiq][sidekiq].
+NOTE: This is the 1.x *development* branch. For the 0.x *stable* branch, please
+  see: https://github.com/ixti/sidekiq-throttled/tree/0-x-stable[0-x-stable]
 
-## Installation
+Concurrency and threshold throttling for https://github.com/mperham/sidekiq[Sidekiq].
+
+
+== Installation
 
 Add this line to your application's Gemfile:
 
-``` ruby
+[source,ruby]
+----
 gem "sidekiq-throttled"
-```
+----
 
 And then execute:
 
-    $ bundle
+  $ bundle
 
 Or install it yourself as:
 
-    $ gem install sidekiq-throttled
+  $ gem install sidekiq-throttled
 
 
-## Usage
+== Usage
 
 Add somewhere in your app's bootstrap (e.g. `config/initializers/sidekiq.rb` if
 you are using Rails):
 
-``` ruby
+[source,ruby]
+----
 require "sidekiq/throttled"
 Sidekiq::Throttled.setup!
-```
+----
 
 Load order can be an issue if you are using other Sidekiq plugins and/or middleware.
 To prevent any problems, add the `.setup!` call to the bottom of your init file.
@@ -39,7 +53,8 @@ To prevent any problems, add the `.setup!` call to the bottom of your init file.
 Once you've done that you can include `Sidekiq::Throttled::Job` to your
 job classes and configure throttling:
 
-``` ruby
+[source,ruby]
+----
 class MyJob
   include Sidekiq::Job
   include Sidekiq::Throttled::Job
@@ -48,37 +63,39 @@ class MyJob
 
   sidekiq_throttle(
     # Allow maximum 10 concurrent jobs of this class at a time.
-    :concurrency => { :limit => 10 },
+    concurrency: { limit: 10 },
     # Allow maximum 1K jobs being processed within one hour window.
-    :threshold => { :limit => 1_000, :period => 1.hour }
+    threshold: { limit: 1_000, period: 1.hour }
   )
 
   def perform
     # ...
   end
 end
-```
+----
 
-**NOTE:** `Sidekiq::Throttled::Job` is aliased as `Sidekiq::Throttled::Worker`,
-thus if you're using Sidekiq prior 6.3.0 version, or you using `Sidekiq::Worker`
-naming convention, you can use the alias for consistency:
+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:
 
-``` ruby
+[source,ruby]
+----
 class MyWorker
   include Sidekiq::Worker
   include Sidekiq::Throttled::Worker
 
   # ...
 end
-```
+----
 
 
-### Observer
+=== Observer
 
 You can specify an observer that will be called on throttling. To do so pass an
 `:observer` option with callable object:
 
-``` ruby
+[source,ruby]
+----
 class MyJob
   include Sidekiq::Job
   include Sidekiq::Throttled::Job
@@ -87,91 +104,95 @@ class MyJob
     # do something
   end
 
-  sidekiq_options :queue => :my_queue
+  sidekiq_options queue: :my_queue
 
   sidekiq_throttle(
-    :concurrency => { :limit => 10 },
-    :threshold   => { :limit => 100, :period => 1.hour }
-    :observer    => MY_OBSERVER
+    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
+=== Dynamic throttling
 
 You can throttle jobs dynamically with `:key_suffix` option:
 
-``` ruby
+[source,ruby]
+----
 class MyJob
   include Sidekiq::Job
   include Sidekiq::Throttled::Job
 
-  sidekiq_options :queue => :my_queue
+  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 } }
+    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.
 
-``` ruby
+[source,ruby]
+----
 class MyJob
   include Sidekiq::Job
   include Sidekiq::Throttled::Job
 
-  sidekiq_options :queue => :my_queue
+  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" }
+    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" }
+    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.
 
-``` ruby
+[source,ruby]
+----
 class MyJob
   include Sidekiq::Job
   include Sidekiq::Throttled::Job
 
-  sidekiq_options :queue => :my_queue
+  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 } }
+    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
   )
@@ -180,14 +201,14 @@ class MyJob
     # ...
   end
 end
-```
+----
 
-**NB** 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.
+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 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
@@ -200,53 +221,21 @@ 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:
 
-``` ruby
+[source,ruby]
+----
 # Set concurrency strategy lock TTL to 1 hour.
-sidekiq_throttle(:concurrency => { :limit => 20, :ttl => 1.hour.to_i })
-```
-
-
-## Enhanced Queues list
-
-This gem provides ability to pause/resume queues from processing by workers.
-So you may simply pause particular queue without need to stop and reconfigure
-workers by simply pushing a button on sidekiq web UI.
-
-By default we add *Enhanced Queues* tab with this functionality. But if you
-want you can override default *Queues* tab completely (notice that page will
-still be available using it's URL, but tab will be pointing enhanced version).
-To do so, just call `Sidekiq::Throttled::Web.enhance_queues_tab!` somewhere
-in your initializer/bootstrap code. If you are using rails, you might want to
-add it right into your `config/routes.rb` file:
-
-``` ruby
-# file config/routes.rb
-
-require "sidekiq/web"
-require "sidekiq/throttled/web"
-
-Rails.application.routes.draw do
-  # ...
+sidekiq_throttle(concurrency: { limit: 20, ttl: 1.hour.to_i })
+----
 
-  # Replace Sidekiq Queues with enhanced version!
-  Sidekiq::Throttled::Web.enhance_queues_tab!
 
-  # Mount Sidekiq Web UI to `/sidekiq` endpoint
-  mount Sidekiq::Web => "/sidekiq"
+== Supported Ruby Versions
 
-  # ...
-end
-```
-
-
-## Supported Ruby Versions
-
-This library aims to support and is [tested against][ci] the following 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
 
 If something doesn't work on one of these versions, it's a bug.
 
@@ -262,15 +251,24 @@ exist at the time of a major release, support for that Ruby version may be
 dropped.
 
 
-## Supported Sidekiq Versions
+== Supported Sidekiq Versions
 
-This library aims to support work with following [Sidekiq][sidekiq] versions:
+This library aims to support and work with following Sidekiq versions:
 
-* Sidekiq 6.4.x
 * Sidekiq 6.5.x
+* Sidekiq 7.0.x
+* Sidekiq 7.1.x
+
+
+== Development
 
+  bundle install
+  bundle exec appraisal generate
+  bundle exec appraisal install
+  bundle exec rake
 
-## Contributing
+
+== Contributing
 
 * Fork sidekiq-throttled on GitHub
 * Make your changes
@@ -278,20 +276,3 @@ This library aims to support work with following [Sidekiq][sidekiq] versions:
 * 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!
-
-
-## Development
-
-```
-bundle update
-bundle exec appraisal install   # install dependencies for all gemfiles
-bundle exec appraisal update    # update dependencies for all gemfiles
-bundle exec appraisal rspec     # run rspec against each gemfile
-bundle exec rubocop             # run static code analysis
-```
-
-Don't forget to run `appraisal update` after any changes to `Gemfile`.
-
-
-[ci]: https://github.com/ixti/sidekiq-throttled/actions/workflows/ci.yml
-[sidekiq]: https://github.com/mperham/sidekiq

data/lib/sidekiq/throttled/basic_fetch.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+require "sidekiq/fetch"
+
+module Sidekiq
+  module Throttled
+    # Default Sidekiq's BasicFetch infused with Throttler.
+    #
+    # @private
+    class BasicFetch < Sidekiq::BasicFetch
+      # Retrieves job from redis.
+      #
+      # @return [Sidekiq::Throttled::UnitOfWork, nil]
+      def retrieve_work
+        work = super
+
+        if work && Throttled.throttled?(work.job)
+          requeue_throttled(work)
+          return nil
+        end
+
+        work
+      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
+        queues = super
+
+        # TODO: Refactor to be prepended as an integration mixin during configuration stage
+        #   Or via configurable queues reducer
+        queues -= Sidekiq::Pauzer.paused_queues.map { |name| "queue:#{name}" } if defined?(Sidekiq::Pauzer)
+
+        queues
+      end
+    end
+  end
+end

data/lib/sidekiq/throttled/fetch.rb

@@ -1,94 +1,10 @@
 # frozen_string_literal: true
 
-require "sidekiq"
-require "sidekiq/throttled/expirable_list"
-require "sidekiq/throttled/fetch/unit_of_work"
-require "sidekiq/throttled/queues_pauser"
-require "sidekiq/throttled/queue_name"
+require_relative "./basic_fetch"
 
 module Sidekiq
   module Throttled
-    # Throttled fetch strategy.
-    #
-    # @private
-    class Fetch
-      # Timeout to sleep between fetch retries in case of no job received,
-      # as well as timeout to wait for redis to give us something to work.
-      TIMEOUT = 2
-
-      # Initializes fetcher instance.
-      # @param options [Hash]
-      # @option options [Integer] :throttled_queue_cooldown (TIMEOUT)
-      #   Min delay in seconds before queue will be polled again after
-      #   throttled job.
-      # @option options [Boolean] :strict (false)
-      # @option options [Array<#to_s>] :queue
-      def initialize(options)
-        @paused = ExpirableList.new(options.fetch(:throttled_queue_cooldown, TIMEOUT))
-
-        @strict = options.fetch(:strict, false)
-        @queues = options.fetch(:queues).map { |q| QueueName.expand q }
-
-        raise ArgumentError, "empty :queues" if @queues.empty?
-
-        @queues.uniq! if @strict
-      end
-
-      # Retrieves job from redis.
-      #
-      # @return [Sidekiq::Throttled::UnitOfWork, nil]
-      def retrieve_work
-        work = brpop
-        return unless work
-
-        work = UnitOfWork.new(*work)
-        return work unless work.throttled?
-
-        work.requeue_throttled
-        @paused << QueueName.expand(work.queue_name)
-
-        nil
-      end
-
-      def bulk_requeue(units, _options)
-        return if units.empty?
-
-        Sidekiq.logger.debug { "Re-queueing terminated jobs" }
-        Sidekiq.redis do |conn|
-          conn.pipelined do |pipeline|
-            units.each { |unit| unit.requeue(pipeline) }
-          end
-        end
-        Sidekiq.logger.info("Pushed #{units.size} jobs back to Redis")
-      rescue => e
-        Sidekiq.logger.warn("Failed to requeue #{units.size} jobs: #{e}")
-      end
-
-      private
-
-      # Tries to pop pair of `queue` and job `message` out of sidekiq queues.
-      #
-      # @see http://redis.io/commands/brpop
-      # @return [Array(String, String), nil]
-      def brpop
-        queues = filter_queues(@strict ? @queues : @queues.shuffle.uniq)
-
-        if queues.empty?
-          sleep TIMEOUT
-          return
-        end
-
-        Sidekiq.redis { |conn| conn.brpop(*queues, :timeout => TIMEOUT) }
-      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 filter_queues(queues)
-        QueuesPauser.instance.filter(queues) - @paused.to_a
-      end
-    end
+    # @deprecated Use Sidekiq::Throttled::BasicFetch
+    Fetch = BasicFetch
   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

data/lib/sidekiq/throttled/middleware.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # internal
-require "sidekiq/throttled/registry"
+require_relative "./registry"
 
 module Sidekiq
   module Throttled
@@ -9,6 +9,8 @@ module Sidekiq
     #
     # @private
     class Middleware
+      include Sidekiq::ServerMiddleware if Sidekiq::VERSION >= "6.5.0"
+
       # Called within Sidekiq job processing
       def call(_worker, msg, _queue)
         yield

data/lib/sidekiq/throttled/registry.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
 # internal
-require "sidekiq/throttled/strategy"
-require "sidekiq/throttled/utils"
+require_relative "./strategy"
 
 module Sidekiq
   module Throttled
@@ -14,8 +13,6 @@ module Sidekiq
       @aliases    = {}
 
       class << self
-        include Utils
-
         # Adds strategy to the registry.
         #
         # @param (see Strategy#initialize)
@@ -107,7 +104,7 @@ module Sidekiq
         def find_by_class(name)
           return unless Throttled.configuration.inherit_strategies?
 
-          const = name.is_a?(Class) ? name : constantize(name)
+          const = name.is_a?(Class) ? name : Object.const_get(name)
           return unless const.is_a?(Class)
 
           const.ancestors.each do |m|

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

@@ -2,7 +2,7 @@
 
 require "redis_prescription"
 
-require "sidekiq/throttled/strategy/base"
+require_relative "./base"
 
 module Sidekiq
   module Throttled
@@ -49,9 +49,7 @@ module Sidekiq
           keys = [key(job_args)]
           argv = [jid.to_s, job_limit, @ttl, Time.now.to_f]
 
-          Sidekiq.redis do |redis|
-            1 == SCRIPT.call(redis, :keys => keys, :argv => argv)
-          end
+          Sidekiq.redis { |redis| 1 == SCRIPT.call(redis, keys: keys, argv: argv) }
         end
 
         # @return [Integer] Current count of jobs

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

@@ -2,7 +2,7 @@
 
 require "redis_prescription"
 
-require "sidekiq/throttled/strategy/base"
+require_relative "./base"
 
 module Sidekiq
   module Throttled
@@ -66,9 +66,7 @@ module Sidekiq
           keys = [key(job_args)]
           argv = [job_limit, period(job_args), Time.now.to_f]
 
-          Sidekiq.redis do |redis|
-            1 == SCRIPT.call(redis, :keys => keys, :argv => argv)
-          end
+          Sidekiq.redis { |redis| 1 == SCRIPT.call(redis, keys: keys, argv: argv) }
         end
 
         # @return [Integer] Current count of jobs

data/lib/sidekiq/throttled/strategy.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 # internal
-require "sidekiq/throttled/errors"
-require "sidekiq/throttled/strategy_collection"
-require "sidekiq/throttled/strategy/concurrency"
-require "sidekiq/throttled/strategy/threshold"
+require_relative "./errors"
+require_relative "./strategy_collection"
+require_relative "./strategy/concurrency"
+require_relative "./strategy/threshold"
 
 module Sidekiq
   module Throttled
@@ -35,14 +35,14 @@ module Sidekiq
         @observer = observer
 
         @concurrency = StrategyCollection.new(concurrency,
-          :strategy   => Concurrency,
-          :name       => name,
-          :key_suffix => key_suffix)
+          strategy:   Concurrency,
+          name:       name,
+          key_suffix: key_suffix)
 
         @threshold = StrategyCollection.new(threshold,
-          :strategy   => Threshold,
-          :name       => name,
-          :key_suffix => key_suffix)
+          strategy:   Threshold,
+          name:       name,
+          key_suffix: key_suffix)
 
         return if @concurrency.any? || @threshold.any?
 

data/lib/sidekiq/throttled/strategy_collection.rb

@@ -61,7 +61,7 @@ module Sidekiq
         return unless options
 
         strategy.new("throttled:#{name}",
-          :key_suffix => key_suffix,
+          key_suffix: key_suffix,
           **options)
       end
     end