speed_limiter 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49d4e898db4491c876e3cdf95a157aa2b9b832444c10a62598dae6214204e864
-  data.tar.gz: f6c223a5b30ab88f844de353e9d4a893d40e629c7602ab521bf59d30a6e314e8
+  metadata.gz: dcefe51efe099102f75381a902006faa8655f7207c7c971e0e0b0f356dc9c5e0
+  data.tar.gz: c3a3647ea48bb31a95dcd1bc70ddcb72c0402e4474c459e88271666021ba878f
 SHA512:
-  metadata.gz: eb26517138fca5d75e5a43a45765ccc48b54586e9bc38b7b644663a8954f7102a513d36e6a8e94575561ad575256c52aa2c1931f481c1f65c64a6a83c663be08
-  data.tar.gz: 54edbdd81701def3bdc0c1ac738c835198245ca187cfe53393e3887c6a59691332d957d7c0d8cd7362feb3ba18e440524d075bbb493a7b61fc21c929de90a86f
+  metadata.gz: bcfa6c8194738f83b7f688cc8211a79d10d8cee564a9b5099694c2730e71a1305c3d78dedad1b06654105d7da4b9070c9abb9d98aee97eca566eeaff32aed531
+  data.tar.gz: cb88e0be3f91a53919d019009c35cadad7e50a46e719f06405b13912f24f195030a06686e7d28241d30a26bdf516946b7f1ca37cb429473bda189815f85cc1c7

data/.github/workflows/lint.yml

@@ -12,7 +12,7 @@ jobs:
     timeout-minutes: 10
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1

data/.github/workflows/test.yml

@@ -20,22 +20,39 @@ jobs:
     strategy:
       max-parallel: 6
       matrix:
-        ruby-version: ['3.0', '3.1', '3.2', ruby-head]
-        redis-version: ['5.0', '6.0', '6.2', '7.0', '7.2', latest]
+        set:
+          - ruby-version: '3.0'
+            redis-version: '7.2'
+          - ruby-version: '3.1'
+            redis-version: '7.2'
+          - ruby-version: '3.2'
+            redis-version: '5.0'
+          - ruby-version: '3.2'
+            redis-version: '6.0'
+          - ruby-version: '3.2'
+            redis-version: '6.2'
+          - ruby-version: '3.2'
+            redis-version: '7.0'
+          - ruby-version: '3.2'
+            redis-version: '7.2'
+          - ruby-version: '3.2'
+            redis-version: latest
+          - ruby-version: ruby-head
+            redis-version: '7.2'
 
     services:
       redis:
-        image: redis:${{ matrix.redis-version }}
+        image: redis:${{ matrix.set.redis-version }}
         ports:
           - 6379:6379
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
-      - name: Set up Ruby ${{ matrix.ruby-version }}
+      - name: Set up Ruby ${{ matrix.set.ruby-version }}
         uses: ruby/setup-ruby@v1
         with:
-          ruby-version: ${{ matrix.ruby-version }}
+          ruby-version: ${{ matrix.set.ruby-version }}
           bundler-cache: true
 
       - name: Rackup test web server

data/Gemfile

@@ -13,6 +13,7 @@ group :development do
   gem "rack-attack", "~> 6.7"
   gem "rackup", "~> 2.1"
   gem "rake"
+  gem "retryable"
   gem "rspec"
   gem "rubocop"
   gem "rubocop-rake"

data/README.md

@@ -35,6 +35,15 @@ SpeedLimiter.throttle('server_name/method_name', limit: 10, period: 1) do |state
   puts state #=> <SpeedLimiter::State key=server_name/method_name count=1 ttl=0>
   http.get(path)
 end
+
+# or
+
+throttle_limit_10_par_sec = SpeedLimiter.throttle('server_name/method_name', limit: 10, period: 1)
+
+throttle_limit_10_par_sec.call do |state|
+  puts state #=> <SpeedLimiter::State key=server_name/method_name count=1 ttl=0>
+  http.get(path)
+end
 ```
 
 It returns the result of the block execution.
@@ -46,6 +55,8 @@ end
 puts result.code #=> 200
 ```
 
+### on_throttled option
+
 Specify the process when the limit is exceeded.
 
 ```ruby
@@ -73,9 +84,40 @@ class CreateSlackChannelJob < ApplicationJob
 end
 ```
 
-### Configuration
+### retry option
+
+To use the `retry:` option, you need to introduce the [Retryable gem](https://github.com/nfedyashev/retryable).
+By specifying the options of the Retryable gem, you can retry when an exception occurs.
+
+```ruby
+# Gemfile
+gem 'retryable'
+```
+
+```ruby
+SpeedLimiter.throttle('server_name/method_name', limit: 10, period: 1, retry: { tries: 3, on: OpenURI::HTTPError }) do
+  http.get(path)
+end
+
+# equivalent to
+SpeedLimiter.throttle('server_name/method_name', limit: 10, period: 1) do
+  Retryable.retryable(tries: 3, on: OpenURI::HTTPError) do
+    http.get(path)
+  end
+end
+```
+
+`retry: true` or `retry: {}` is default use of `Retryable.configure`.
+
+```ruby
+SpeedLimiter.throttle('server_name/method_name', limit: 10, period: 1, retry: true) do
+  http.get(path)
+end
+```
+
+## Configuration
 
-#### Redis configuration
+### Redis configuration
 
 Redis can be specified as follows
 
@@ -99,7 +141,7 @@ SpeedLimiter.configure do |config|
 end
 ```
 
-#### Other configuration defaults
+### Other configuration defaults
 
 ```ruby
 SpeedLimiter.configure do |config|
@@ -111,7 +153,7 @@ SpeedLimiter.configure do |config|
 end
 ```
 
-#### Example
+### Example
 
 If you do not want to impose a limit in the test environment, please set it as follows.
 

data/lib/speed_limiter/config.rb

@@ -14,5 +14,9 @@ module SpeedLimiter
     end
 
     alias no_limit? no_limit
+
+    def redis_client
+      @redis_client ||= SpeedLimiter::Redis.new(@redis || ::Redis.new(url: redis_url))
+    end
   end
 end

data/lib/speed_limiter/state.rb

@@ -8,6 +8,9 @@ module SpeedLimiter
   class State
     extend Forwardable
 
+    # @param params [SpeedLimiter::ThrottleParams]
+    # @param count [Integer] current count
+    # @param ttl [Float] remaining time to reset
     def initialize(params:, count:, ttl:)
       @params = params
       @count = count
@@ -16,7 +19,7 @@ module SpeedLimiter
 
     attr_reader :params, :count, :ttl
 
-    def_delegators(:params, :config, :key, :limit, :period, :on_throttled)
+    def_delegators(:params, :config, :key, :limit, :period, :on_throttled, :retry)
 
     def inspect
       "<#{self.class.name} key=#{key.inspect} count=#{count} ttl=#{ttl}>"

data/lib/speed_limiter/throttle.rb

@@ -9,27 +9,58 @@ module SpeedLimiter
   class Throttle
     extend Forwardable
 
-    # @option params [String] :key key name
+    # @param key [String, #to_s] Throttle key name
     # @option params [Integer] :limit limit count per period
     # @option params [Integer] :period period time (seconds)
-    # @option params [Proc] :on_throttled Block called when limit exceeded, with ttl(Float) and key as argument
-    # @yield [count] Block called to not reach limit
-    # @yieldparam count [Integer] count of period
-    # @yieldreturn [any] block return value
-    def initialize(config:, **params, &block)
+    # @option params [Proc, #call] :on_throttled Block called when limit exceeded, with ttl(Float) and key as argument
+    # @option params [true, Hash] :retry Retry options. (see {Retryable.retryable} for details)
+    def initialize(key, config:, **params)
+      params[:key] = key.to_s
+
       @config = config
       @params = ThrottleParams.new(config: config, **params)
-      @block = block
     end
     attr_reader :config, :params, :block
 
-    def_delegators(:params, :key, :redis_key, :limit, :period, :on_throttled, :create_state)
+    delegate %i[redis_client] => :config
+
+    delegate %i[key redis_key limit period on_throttled create_state] => :params
+
+    # @yield [state]
+    # @yieldparam state [SpeedLimiter::State]
+    # @return [any] block return value
+    def call(&block)
+      if use_retryable?
+        Retryable.retryable(**retryable_options) { run_block(&block) }
+      else
+        run_block(&block)
+      end
+    end
+
+    private
+
+    def use_retryable?
+      return false if params.retry == false || params.retry.nil?
+
+      unless Gem::Specification.find_by_name("retryable")
+        raise ArgumentError, "To use the 'retry' option, you need to install the Retryable gem."
+      end
 
-    def throttle
+      require "retryable"
+      params.retry.is_a?(Hash) || params.retry == true
+    end
+
+    def retryable_options
+      return {} if params.retry == true
+
+      params.retry
+    end
+
+    def run_block(&block)
       return block.call(create_state) if config.no_limit?
 
       loop do
-        count, ttl = redis.increment(redis_key, period)
+        count, ttl = redis_client.increment(redis_key, period)
 
         break(block.call(create_state(count: count, ttl: ttl))) if count <= limit
 
@@ -37,23 +68,17 @@ module SpeedLimiter
       end
     end
 
-    private
-
     def wait_for_interval(count)
-      ttl = redis.ttl(redis_key)
+      ttl = redis_client.ttl(redis_key)
       return if ttl.negative?
 
       config.on_throttled.call(create_state(count: count, ttl: ttl)) if config.on_throttled.respond_to?(:call)
       on_throttled.call(create_state(count: count, ttl: ttl)) if on_throttled.respond_to?(:call)
 
-      ttl = redis.ttl(redis_key)
+      ttl = redis_client.ttl(redis_key)
       return if ttl.negative?
 
       sleep ttl
     end
-
-    def redis
-      @redis ||= SpeedLimiter::Redis.new(config.redis || ::Redis.new(url: config.redis_url))
-    end
   end
 end

data/lib/speed_limiter/throttle_params.rb

@@ -5,15 +5,23 @@ require "speed_limiter/state"
 module SpeedLimiter
   # Throttle params model
   class ThrottleParams
-    def initialize(config:, key:, limit:, period:, on_throttled: nil)
+    def initialize(config:, key:, limit:, period:, **options)
       @config = config
       @key = key
       @limit = limit
       @period = period
-      @on_throttled = on_throttled
+      @options = options
     end
 
-    attr_reader :config, :key, :limit, :period, :on_throttled
+    attr_reader :config, :key, :limit, :period
+
+    def on_throttled
+      @options[:on_throttled]
+    end
+
+    def retry
+      @options[:retry]
+    end
 
     def redis_key
       "#{config.prefix}:#{key}"

data/lib/speed_limiter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SpeedLimiter
-  VERSION = "0.1.0"
+  VERSION = "0.2.1"
 end

data/lib/speed_limiter.rb

@@ -16,19 +16,19 @@ module SpeedLimiter
       yield(config)
     end
 
-    def redis
-      @redis ||= config.redis || Redis.new(url: config.redis_url)
-    end
-
-    # @param key [String] key name
-    # @param limit [Integer] limit count per period
-    # @param period [Integer] period time (seconds)
-    # @param on_throttled [Proc] Block called when limit exceeded, with ttl(Float) and key as argument
-    # @yield [count] Block called to not reach limit
-    # @yieldparam count [Integer] count of period
-    # @yieldreturn [any] block return value
+    # @param key (see Throttle#initialize)
+    # @option (see Throttle#initialize)
+    # @yield (see Throttle#call)
+    # @yieldparam (see Throttle#call)
+    # @return Return value of block if argument contains block, otherwise Throttle instance
     def throttle(key, **params, &block)
-      Throttle.new(config: config, key: key, **params, &block).throttle
+      throttle = Throttle.new(key, config: config, **params)
+
+      if block
+        throttle.call(&block)
+      else
+        throttle
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: speed_limiter
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - yuhei mukoyama
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-16 00:00:00.000000000 Z
+date: 2024-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -75,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.5.7
 signing_key:
 specification_version: 4
 summary: Limit the frequency of execution across multiple threads and processes