redis-throttle 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df74619037a1515419ebbf8381326577c540376855146fece1b9624f9ee443f6
-  data.tar.gz: 4b465e4412d3fa8408b48470b867576457737524cded5b41ea8bb04aef53a39b
+  metadata.gz: 6dbef2b5249fc1cd8ff9c199e00b11b98dafa0ec8f0a707e9da8af4c5fa3ed1d
+  data.tar.gz: 2a8ddfd1fe58e6f9a3e63cb219ab42450518f804cce806e7778aaca251563cb1
 SHA512:
-  metadata.gz: cfcdaef05593dd858baef2d65ae0a1240cea10cbb3adda0989f5bba724672233c4ec8551040b746421a8d40eb5240a0338de5f027bafa3eabe6a3c6a28071c0d
-  data.tar.gz: e2a761f5962106a211ed285f527a73e24d040c414053a707c26fa11dad1b2477f73ecd38248b4ba639c32c47a773719af788dd02918af8259af1c283f100e979
+  metadata.gz: 74c91479a17ea0759cb6d9a9bcf78c27d1454339a3dca5678cb90aa28c582ed6f11f5d825ff38401a51e9a039728f3d4494887466674f2c29aae4615b376af41
+  data.tar.gz: 4e299f8ae32084daf1c5941629601ba48d4af09d5cec9504421e05a462e0be1a24131929c56c3913f5edf70b4aa53a3a8a57d0d72d90a494193695d8fffb3db5

data/README.adoc

@@ -23,16 +23,16 @@ Or install it yourself as:
 # Allow 1 concurrent calls. If call takes more than 10 seconds, consider it
 # gone (as if process died, or by any other reason did not called `#release`):
 concurrency = RedisThrottle.concurrency(:bucket_name,
-  :limit => 1,
+  limit: 1,
   :ttl   => 10
 )
 
-concurrency.acquire(:token => "abc") # => "abc"
-concurrency.acquire(:token => "xyz") # => nil
+concurrency.acquire(redis, token: "abc") # => "abc"
+concurrency.acquire(redis, token: "xyz") # => nil
 
-concurrency.release(:token => "abc")
+concurrency.release(redis, token: "abc")
 
-concurrency.acquire(:token => "xyz") # => "xyz"
+concurrency.acquire(redis, token: "xyz") # => "xyz"
 ----
 
 === Rate Limit
@@ -42,15 +42,15 @@ concurrency.acquire(:token => "xyz") # => "xyz"
 # Allow 1 calls per 10 seconds:
 rate_limit = RedisThrottle.rate_limit(:bucket_name,
   :limit  => 1,
-  :period => 10
+  period: 10
 )
 
-rate_limit.acquire # => "6a6c6546-268d-4216-bcf3-3139b8e11609"
-rate_limit.acquire # => nil
+rate_limit.acquire(redis) # => "6a6c6546-268d-4216-bcf3-3139b8e11609"
+rate_limit.acquire(redis) # => nil
 
 sleep 10
 
-rate_limit.acquire # => "e2926a90-2cf4-4bff-9401-65f3a70d32bd"
+rate_limit.acquire(redis) # => "e2926a90-2cf4-4bff-9401-65f3a70d32bd"
 ----
 
 
@@ -59,11 +59,11 @@ rate_limit.acquire # => "e2926a90-2cf4-4bff-9401-65f3a70d32bd"
 [source,ruby]
 ----
 throttle = RedisThrottle
-  .concurrency(:db, :limit => 3, :ttl => 900)
-  .rate_limit(:api_minutely, :limit => 1, :period => 60)
-  .rate_limit(:api_hourly, :limit => 10, :period => 3600)
+  .concurrency(:db, limit: 3, ttl: 900)
+  .rate_limit(:api_minutely, limit: 1, period: 60)
+  .rate_limit(:api_hourly, limit: 10, period: 3600)
 
-throttle.call(:token => "abc") do
+throttle.call(redis, token: "abc") do
   # do something if all strategies are resolved
 end
 ----
@@ -72,46 +72,17 @@ You can also compose multiple throttlers together:
 
 [source,ruby]
 ----
-db_limiter  = RedisThrottle.concurrency(:db, :limit => 3, :ttl => 900)
+db_limiter  = RedisThrottle.concurrency(:db, limit: 3, ttl: 900)
 api_limiter = RedisThrottle
-  .rate_limit(:api_minutely, :limit => 1, :period => 60)
-  .rate_limit(:api_hourly, :limit => 10, :period => 3600)
+  .rate_limit(:api_minutely, limit: 1, period: 60)
+  .rate_limit(:api_hourly, limit: 10, period: 3600)
 
-(db_limiter + api_limiter).call do
+(db_limiter + api_limiter).call(redis) do
   # ...
 end
 ----
 
 
-=== With ConnectionPool
-
-If you're using [connection_pool](https://github.com/mperham/connection_pool),
-you can pass its `#with` method as connection builder:
-
-[source,ruby]
-----
-pool     = ConnectionPool.new { Redis.new }
-throttle = RedisThrottle.new(:redis => pool.method(:with))
-----
-
-=== With Sidekiq
-
-[Sidekiq](https://github.com/mperham/sidekiq): uses ConnectionPool, so you can
-use the same approach:
-
-[source,ruby]
-----
-throttle = RedisThrottle.new(:redis => Sidekiq.redis_pool.method(:with))
-----
-
-Or, you can use its `.redis` method directly:
-
-[source,ruby]
-----
-throttle = RedisThrottle.new(:redis => Sidekiq.method(:redis))
-----
-
-
 == Compatibility
 
 This library aims to support and is tested against:
@@ -132,8 +103,15 @@ This library aims to support and is tested against:
 ** 4.4.x
 ** 4.5.x
 ** 4.6.x
+** 4.7.x
+** 4.8.x
+** 5.0.x
 * https://github.com/resque/redis-namespace[redis-namespace]
 ** 1.10.x
+* https://github.com/redis-rb/redis-client[redis-client]
+** 0.12.x
+** 0.13.x
+** 0.14.x
 
 If something doesn't work on one of these versions, it's a bug.
 
@@ -148,7 +126,8 @@ 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.
 
-The same applies to *Redis Server*, *redis-rb*, and *redis-namespace* support.
+The same applies to *Redis Server*, *redis-rb*, *redis-namespace*,
+and *redis-client* support.
 
 
 == Development

data/lib/redis-throttle.rb

@@ -1,4 +1,3 @@
 # frozen_string_literal: true
 
 require_relative "./redis_throttle"
-require_relative "./redis/throttle"

data/lib/redis_throttle/api.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-require "redis"
-require "redis-prescription"
+require "redis_prescription"
 
 require_relative "./concurrency"
 require_relative "./rate_limit"
@@ -26,14 +25,9 @@ class RedisThrottle
     SCRIPT = RedisPrescription.new(File.read("#{__dir__}/api.lua"))
     private_constant :SCRIPT
 
-    # @param redis [Redis, Redis::Namespace, #to_proc]
-    def initialize(redis: nil)
-      @redis =
-        if redis.respond_to?(:to_proc)
-          redis.to_proc
-        else
-          ->(&b) { b.call(redis || Redis.current) }
-        end
+    # @param redis [Redis, Redis::Namespace, RedisClient, RedisClient::Decorator::Client]
+    def initialize(redis)
+      @redis = redis
     end
 
     # @param strategies [Enumerable<Concurrency, RateLimit>]
@@ -60,12 +54,12 @@ class RedisThrottle
     # @return [Array<Concurrency, RateLimit>]
     def strategies(match:)
       results = []
+      block   = ->(key) { from_key(key)&.then { |strategy| results << strategy } }
 
-      @redis.call do |redis|
-        redis.scan_each(match: "#{NAMESPACE}:*:#{match}:*:*") do |key|
-          strategy = from_key(key)
-          results << strategy if strategy
-        end
+      if redis_client?
+        @redis.scan("MATCH", "#{NAMESPACE}:*:#{match}:*:*", &block)
+      else
+        @redis.scan_each(match: "#{NAMESPACE}:*:#{match}:*:*", &block)
       end
 
       results
@@ -77,16 +71,17 @@ class RedisThrottle
       strategies.zip(execute(:INFO, to_params(strategies) << :TS << Time.now.to_i)).to_h
     end
 
-    # @note Used for specs only.
-    # @return [void]
-    def ping
-      @redis.call(&:ping)
-    end
-
     private
 
+    def redis_client?
+      return true if defined?(::RedisClient) && @redis.is_a?(::RedisClient)
+      return true if defined?(::RedisClient::Decorator::Client) && @redis.is_a?(::RedisClient::Decorator::Client)
+
+      false
+    end
+
     def execute(command, argv)
-      @redis.call { |redis| SCRIPT.call(redis, keys: [NAMESPACE], argv: [command, *argv]) }
+      SCRIPT.call(@redis, keys: [NAMESPACE], argv: [command, *argv])
     end
 
     def from_key(key)

data/lib/redis_throttle/version.rb

@@ -2,5 +2,5 @@
 
 class RedisThrottle
   # Gem version.
-  VERSION = "1.1.0"
+  VERSION = "2.0.0"
 end

data/lib/redis_throttle.rb

@@ -4,18 +4,46 @@ require "concurrent/set"
 require "securerandom"
 
 require_relative "./redis_throttle/api"
-require_relative "./redis_throttle/class_methods"
 require_relative "./redis_throttle/concurrency"
 require_relative "./redis_throttle/rate_limit"
 require_relative "./redis_throttle/version"
 
 class RedisThrottle
-  extend ClassMethods
+  class << self
+    # Syntax sugar for `RedisThrottle.new.concurrency(...)`.
+    #
+    # @see #concurrency
+    # @param (see #concurrency)
+    # @return (see #concurrency)
+    def concurrency(...)
+      new.concurrency(...)
+    end
+
+    # Syntax sugar for `RedisThrottle.new.rate_limit(...)`.
+    #
+    # @see #rate_limit
+    # @param (see #rate_limit)
+    # @return (see #rate_limit)
+    def rate_limit(...)
+      new.rate_limit(...)
+    end
+
+    # Return usage info for all known (in use) strategies.
+    #
+    # @example
+    #   RedisThrottle.info(:match => "*_api").each do |strategy, current_value|
+    #     # ...
+    #   end
+    #
+    # @param redis (see Api#initialize)
+    # @param match [#to_s]
+    # @return (see Api#info)
+    def info(redis, match: "*")
+      Api.new(redis).then { |api| api.info(strategies: api.strategies(match: match.to_s)) }
+    end
+  end
 
-  # @param (see Api#initialize)
-  def initialize(redis: nil)
-    # TODO: fix api cloning/duping
-    @api        = Api.new(redis: redis)
+  def initialize
     @strategies = Concurrent::Set.new
   end
 
@@ -48,15 +76,15 @@ class RedisThrottle
   #   throttle = RedisThrottle.new
   #
   #   # Allow max 2 concurrent execution units
-  #   throttle.concurrency(:xxx, :limit => 2, :ttl => 10)
+  #   throttle.concurrency(:xxx, limit: 2, ttl: 10)
   #
-  #   throttle.acquire(:token => "a") && :aye || :nay # => :aye
-  #   throttle.acquire(:token => "b") && :aye || :nay # => :aye
-  #   throttle.acquire(:token => "c") && :aye || :nay # => :nay
+  #   throttle.acquire(redis, token: "a") && :aye || :nay # => :aye
+  #   throttle.acquire(redis, token: "b") && :aye || :nay # => :aye
+  #   throttle.acquire(redis, token: "c") && :aye || :nay # => :nay
   #
-  #   throttle.release(:token => "a")
+  #   throttle.release(redis, token: "a")
   #
-  #   throttle.acquire(:token => "c") && :aye || :nay # => :aye
+  #   throttle.acquire(redis, token: "c") && :aye || :nay # => :aye
   #
   #
   # @param (see Concurrency#initialize)
@@ -76,17 +104,17 @@ class RedisThrottle
   #   throttle = RedisThrottle.new
   #
   #   # Allow 2 execution units per 10 seconds
-  #   throttle.rate_limit(:xxx, :limit => 2, :period => 10)
+  #   throttle.rate_limit(:xxx, limit: 2, period: 10)
   #
-  #   throttle.acquire && :aye || :nay # => :aye
+  #   throttle.acquire(redis) && :aye || :nay # => :aye
   #   sleep 5
   #
-  #   throttle.acquire && :aye || :nay # => :aye
-  #   throttle.acquire && :aye || :nay # => :nay
+  #   throttle.acquire(redis) && :aye || :nay # => :aye
+  #   throttle.acquire(redis) && :aye || :nay # => :nay
   #
   #   sleep 6
-  #   throttle.acquire && :aye || :nay # => :aye
-  #   throttle.acquire && :aye || :nay # => :nay
+  #   throttle.acquire(redis) && :aye || :nay # => :aye
+  #   throttle.acquire(redis) && :aye || :nay # => :nay
   #
   # @param (see RateLimit#initialize)
   # @return [Throttle] self
@@ -101,11 +129,11 @@ class RedisThrottle
   # Merge in strategies of the `other` throttle.
   #
   # @example
-  #   a = RedisThrottle.concurrency(:a, :limit => 1, :ttl => 2)
-  #   b = RedisThrottle.rate_limit(:b, :limit => 3, :period => 4)
+  #   a = RedisThrottle.concurrency(:a, limit: 1, ttl: 2)
+  #   b = RedisThrottle.rate_limit(:b, limit: 3, period: 4)
   #   c = RedisThrottle
-  #     .concurrency(:a, :limit => 1, :ttl => 2)
-  #     .rate_limit(:b, :limit => 3, :period => 4)
+  #     .concurrency(:a, limit: 1, ttl: 2)
+  #     .rate_limit(:b, limit: 3, period: 4)
   #
   #   a.merge!(b)
   #
@@ -120,17 +148,15 @@ class RedisThrottle
     self
   end
 
-  alias << merge!
-
-  # Non-destructive version of {#merge!}. Returns new {Throttle} instance with
-  # union of `self` and `other` strategies.
+  # Non-destructive version of {#merge!}. Returns new {RedisThrottle} instance
+  # with union of `self` and `other` strategies.
   #
   # @example
-  #   a = RedisThrottle.concurrency(:a, :limit => 1, :ttl => 2)
-  #   b = RedisThrottle.rate_limit(:b, :limit => 3, :period => 4)
+  #   a = RedisThrottle.concurrency(:a, limit: 1, ttl: 2)
+  #   b = RedisThrottle.rate_limit(:b, limit: 3, period: 4)
   #   c = RedisThrottle
-  #     .concurrency(:a, :limit => 1, :ttl => 2)
-  #     .rate_limit(:b, :limit => 3, :period => 4)
+  #     .concurrency(:a, limit: 1, ttl: 2)
+  #     .rate_limit(:b, limit: 3, period: 4)
   #
   #   a.merge(b) == c # => true
   #   a == c          # => false
@@ -142,9 +168,6 @@ class RedisThrottle
 
   alias + merge
 
-  # @deprecated will be removed in 2.0.0
-  alias | merge
-
   # Prevents further modifications to the throttle instance.
   #
   # @see https://docs.ruby-lang.org/en/master/Object.html#method-i-freeze
@@ -155,17 +178,17 @@ class RedisThrottle
     super
   end
 
-  # Returns `true` if the `other` is an instance of {Throttle} with the same
-  # set of strategies.
+  # Returns `true` if the `other` is an instance of {RedisThrottle} with
+  # the same set of strategies.
   #
   # @example
   #   a = RedisThrottle
-  #     .concurrency(:a, :limit => 1, :ttl => 2)
-  #     .rate_limit(:b, :limit => 3, :period => 4)
+  #     .concurrency(:a, limit: 1, ttl: 2)
+  #     .rate_limit(:b, limit: 3, period: 4)
   #
   #   b = RedisThrottle
-  #     .rate_limit(:b, :limit => 3, :period => 4)
-  #     .concurrency(:a, :limit => 1, :ttl => 2)
+  #     .rate_limit(:b, limit: 3, period: 4)
+  #     .concurrency(:a, limit: 1, ttl: 2)
   #
   #   a == b # => true
   #
@@ -180,69 +203,72 @@ class RedisThrottle
   # it after the block.
   #
   # @example
-  #   throttle = RedisThrottle.concurrency(:xxx, :limit => 1, :ttl => 10)
+  #   throttle = RedisThrottle.concurrency(:xxx, limit: 1, ttl: 10)
   #
-  #   throttle.call { :aye } # => :aye
-  #   throttle.call { :aye } # => :aye
+  #   throttle.call(redis) { :aye } # => :aye
+  #   throttle.call(redis) { :aye } # => :aye
   #
-  #   throttle.acquire
+  #   throttle.acquire(redis)
   #
-  #   throttle.call { :aye } # => nil
+  #   throttle.call(redis) { :aye } # => nil
   #
-  # @param (see #acquire)
+  # @param redis (see Api#initialize)
+  # @param token (see #acquire)
   # @return [Object] last satement of the block if execution lock was acquired.
   # @return [nil] otherwise
-  def call(token: SecureRandom.uuid)
-    return unless acquire(token: token)
+  def call(redis, token: SecureRandom.uuid)
+    return unless acquire(redis, token: token)
 
     begin
       yield
     ensure
-      release(token: token)
+      release(redis, token: token)
     end
   end
 
   # Acquire execution lock.
   #
   # @example
-  #   throttle = RedisThrottle.concurrency(:xxx, :limit => 1, :ttl => 10)
+  #   throttle = RedisThrottle.concurrency(:xxx, limit: 1, ttl: 10)
   #
-  #   if (token = throttle.acquire)
+  #   if (token = throttle.acquire(redis))
   #     # ... do something
   #   end
   #
-  #   throttle.release(:token => token) if token
+  #   throttle.release(redis, token: token) if token
   #
   # @see #call
   # @see #release
+  # @param redis (see Api#initialize)
   # @param token [#to_s] Unit of work ID
   # @return [#to_s] `token` as is if lock was acquired
   # @return [nil] otherwise
-  def acquire(token: SecureRandom.uuid)
-    token if @api.acquire(strategies: @strategies, token: token.to_s)
+  def acquire(redis, token: SecureRandom.uuid)
+    token if Api.new(redis).acquire(strategies: @strategies, token: token.to_s)
   end
 
   # Release acquired execution lock. Notice that this affects {#concurrency}
   # locks only.
   #
   # @example
-  #   concurrency = RedisThrottle.concurrency(:xxx, :limit => 1, :ttl => 60)
-  #   rate_limit  = RedisThrottle.rate_limit(:xxx, :limit => 1, :period => 60)
+  #   concurrency = RedisThrottle.concurrency(:xxx, limit: 1, ttl: 60)
+  #   rate_limit  = RedisThrottle.rate_limit(:xxx, limit: 1, period: 60)
   #   throttle    = concurrency + rate_limit
   #
-  #   throttle.acquire(:token => "uno")
-  #   throttle.release(:token => "uno")
+  #   throttle.acquire(redis, token: "uno")
+  #   throttle.release(redis, token: "uno")
   #
-  #   concurrency.acquire(:token => "dos") # => "dos"
-  #   rate_limit.acquire(:token => "dos")  # => nil
+  #   concurrency.acquire(redis, token: "dos") # => "dos"
+  #   rate_limit.acquire(redis, token: "dos")  # => nil
   #
   # @see #acquire
   # @see #reset
   # @see #call
+  # @param redis (see Api#initialize)
   # @param token [#to_s] Unit of work ID
   # @return [void]
-  def release(token:)
-    @api.release(strategies: @strategies, token: token.to_s)
+  def release(redis, token:)
+    Api.new(redis).release(strategies: @strategies, token: token.to_s)
 
     nil
   end
@@ -250,20 +276,21 @@ class RedisThrottle
   # Flush all counters.
   #
   # @example
-  #   throttle = RedisThrottle.concurrency(:xxx, :limit => 2, :ttl => 60)
+  #   throttle = RedisThrottle.concurrency(:xxx, limit: 2, ttl: 60)
   #
-  #   thottle.acquire(:token => "a") # => "a"
-  #   thottle.acquire(:token => "b") # => "b"
-  #   thottle.acquire(:token => "c") # => nil
+  #   thottle.acquire(redis, token: "a") # => "a"
+  #   thottle.acquire(redis, token: "b") # => "b"
+  #   thottle.acquire(redis, token: "c") # => nil
   #
-  #   throttle.reset
+  #   throttle.reset(redis)
   #
-  #   thottle.acquire(:token => "c") # => "c"
-  #   thottle.acquire(:token => "d") # => "d"
+  #   thottle.acquire(redis, token: "c") # => "c"
+  #   thottle.acquire(redis, token: "d") # => "d"
   #
+  # @param redis (see Api#initialize)
   # @return [void]
-  def reset
-    @api.reset(strategies: @strategies)
+  def reset(redis)
+    Api.new(redis).reset(strategies: @strategies)
 
     nil
   end
@@ -271,13 +298,14 @@ class RedisThrottle
   # Return usage info for all strategies of the throttle.
   #
   # @example
-  #   throttle.info.each do |strategy, current_value|
+  #   throttle.info(redis).each do |strategy, current_value|
   #     # ...
   #   end
   #
+  # @param redis (see Api#initialize)
   # @return (see Api#info)
-  def info
-    @api.info(strategies: @strategies)
+  def info(redis)
+    Api.new(redis).info(strategies: @strategies)
   end
 
   protected

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-throttle
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Alexey Zapparov
@@ -28,16 +28,16 @@ dependencies:
   name: redis-prescription
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.2.0
+        version: '2.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.2.0
+        version: '2.5'
 description:
 email:
 - alexey@zapparov.com
@@ -48,11 +48,9 @@ files:
 - LICENSE.txt
 - README.adoc
 - lib/redis-throttle.rb
-- lib/redis/throttle.rb
 - lib/redis_throttle.rb
 - lib/redis_throttle/api.lua
 - lib/redis_throttle/api.rb
-- lib/redis_throttle/class_methods.rb
 - lib/redis_throttle/concurrency.rb
 - lib/redis_throttle/rate_limit.rb
 - lib/redis_throttle/version.rb
@@ -61,9 +59,9 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://gitlab.com/ixti/redis-throttle
-  source_code_uri: https://gitlab.com/ixti/redis-throttle/tree/v1.1.0
+  source_code_uri: https://gitlab.com/ixti/redis-throttle/tree/v2.0.0
   bug_tracker_uri: https://gitlab.com/ixti/redis-throttle/issues
-  changelog_uri: https://gitlab.com/ixti/redis-throttle/blob/v1.1.0/CHANGES.md
+  changelog_uri: https://gitlab.com/ixti/redis-throttle/blob/v2.0.0/CHANGES.md
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
@@ -80,7 +78,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.2.33
 signing_key:
 specification_version: 4
 summary: Redis based rate limit and concurrency throttling

data/lib/redis/throttle.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../redis_throttle"
-
-class Redis
-  # @deprecated Use ::RedisThrottle
-  class Throttle < RedisThrottle
-    class << self
-      attr_accessor :silence_deprecation_warning
-    end
-
-    self.silence_deprecation_warning = false
-
-    def initialize(*args, **kwargs, &block)
-      super(*args, **kwargs, &block)
-
-      return if self.class.silence_deprecation_warning
-
-      warn "#{self.class} usage was deprecated, please use RedisThrottle instead"
-    end
-  end
-end

data/lib/redis_throttle/class_methods.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "./api"
-
-class RedisThrottle
-  module ClassMethods
-    # Syntax sugar for {Throttle#concurrency}.
-    #
-    # @see #concurrency
-    # @param (see Throttle#initialize)
-    # @param (see Throttle#concurrency)
-    # @return (see Throttle#concurrency)
-    def concurrency(bucket, limit:, ttl:, redis: nil)
-      new(redis: redis).concurrency(bucket, limit: limit, ttl: ttl)
-    end
-
-    # Syntax sugar for {Throttle#rate_limit}.
-    #
-    # @see #concurrency
-    # @param (see Throttle#initialize)
-    # @param (see Throttle#rate_limit)
-    # @return (see Throttle#rate_limit)
-    def rate_limit(bucket, limit:, period:, redis: nil)
-      new(redis: redis).rate_limit(bucket, limit: limit, period: period)
-    end
-
-    # Return usage info for all known (in use) strategies.
-    #
-    # @example
-    #   Redis::Throttle.info(:match => "*_api").each do |strategy, current_value|
-    #     # ...
-    #   end
-    #
-    # @param match [#to_s]
-    # @return (see Api#info)
-    def info(match: "*", redis: nil)
-      api        = Api.new(redis: redis)
-      strategies = api.strategies(match: match.to_s)
-
-      api.info(strategies: strategies)
-    end
-  end
-end