sidekiq-throttled 0.18.0 → 1.0.0.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9709e5805bd1bf11ef204afb08a988a4c5998e16ecf8a7a0b8e0c1b4b753ce4d
-  data.tar.gz: 21b5bdd50945f807e11884a18449be0155cb8bdf2b6ee37b633148b198db615d
+  metadata.gz: 714915692e57a08eeea5dd0e0be79f3becfa915669f559f3457509073b89e4fe
+  data.tar.gz: 190b4e6d013712725bb64277c00c74c82da5149f73368dbb19890090d638a372
 SHA512:
-  metadata.gz: 613164a091883655c4bd879b3dab25198ffc88e49eb7f1e1b0bab33eb2a7eb004b2f6d407e65ccfea52727e347f1b5d8c05015117b5da8500a2a933228044ef4
-  data.tar.gz: 9b2dde3fd9ecdf25301597bd86609f531f7a8b5d8a90833f7f0d42399501a3d49252fa78af3cc576007cdf8b7025b86223c1a9d1391ab9069c6277220adb7524
+  metadata.gz: 7627db53db315ec4acdaf15e715186522c3dbbdc4084aadd65cd0f081845b247f92eb106bcf2e5bf41b5098400adaed00377104b21205b5914495bcacff9d625
+  data.tar.gz: 1caca54490b41115389b6ce111c4264a911aba84f656546bce0c62846d6f3828c91a1c681bfb0520f04230c6e113b9d1cd5553c500e6a65a7f6d77c2d36903a2

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/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/patches/basic_fetch.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+require "sidekiq/fetch"
+
+module Sidekiq
+  module Throttled
+    module Patches
+      module BasicFetch
+        class << self
+          def apply!
+            Sidekiq::BasicFetch.prepend(self) unless Sidekiq::BasicFetch.include?(self)
+          end
+        end
+
+        # 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
+end

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

@@ -19,8 +19,7 @@ module Sidekiq
       # @param [#to_s] name
       # @param [#call] key_suffix Dynamic key suffix generator.
       def initialize(strategies, strategy:, name:, key_suffix:)
-        strategies = (strategies.is_a?(Hash) ? [strategies] : Array(strategies))
-        @strategies = strategies.map do |options|
+        @strategies = (strategies.is_a?(Hash) ? [strategies] : Array(strategies)).map do |options|
           make_strategy(strategy, name, key_suffix, options)
         end
       end
@@ -61,7 +60,7 @@ module Sidekiq
         return unless options
 
         strategy.new("throttled:#{name}",
-          :key_suffix => key_suffix,
+          key_suffix: key_suffix,
           **options)
       end
     end

data/lib/sidekiq/throttled/version.rb

@@ -3,6 +3,6 @@
 module Sidekiq
   module Throttled
     # Gem version
-    VERSION = "0.18.0"
+    VERSION = "1.0.0.alpha.1"
   end
 end