simple_throttle 1.0.4 → 1.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd25dd96b13df27a165952bee5a5ff4fd6731c164c88aaa586e2c990a47650d3
-  data.tar.gz: 4298862682b63ef05bebf1e70abb62bf1dad5e7c3a23835e4c9ad94ed38c8cd5
+  metadata.gz: 8e18797fda6fc1d6b7c7fec9630876cca2ddffce4c716767598d0491d763d86e
+  data.tar.gz: f20bb9caa31be9ec0b185be99ead23d56a644e8f73662da97efa3ebd0bcac4a0
 SHA512:
-  metadata.gz: 52eda43dd29e5c4ceadb806c0a132abeb30737365aea897a33815e7aa40ca518ea97ed4506c3b612e4729f08e9e3534877dd9f3d6890925cdb8bf7afdc4a5e70
-  data.tar.gz: 839f5e758fe348fa974dd3b8e3b2d37827002ab39db178058095344ed90c94b25aeb6a477d93ac042a9d291bf3afd8bbf13672b60a91233fa09cb13861a94bf1
+  metadata.gz: 4950eeea8f2419d800921816c7de0a4b3d120fd37462881c07bc2bb8720046b27a6ecbbc6709e314191bae5f225c3ae794cb9af2f34b2358490a4888f429ccce
+  data.tar.gz: f8c2e359ddd7b9b429ac2863dbc63d3614a00f3f8f15b85d0f509aae89140e0ac2d880945fafa737330fccff95559fa8a2c1d6f30f7513da28945ec0a9424bdd

data/CHANGELOG.md

@@ -4,7 +4,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 1.0.6
+
+### Added
+- Add support for `pause_to_recover` flag on throttles to force calls to the throttle to fail until the process calling them has paused temporarily.
+
+## 1.0.5
+
+### Added
+- Make loading lua script play better with Redis clusters.
+- Handle failures loading lua script on Redis server to prevent infinite loop.
+
 ## 1.0.4
+
+### Fixed
 - Fix wait_time method to match the documentation from [bc-swoop](https://github.com/bc-swoop)
 
 ## 1.0.3

data/README.md

@@ -1,7 +1,7 @@
 [![Maintainability](https://api.codeclimate.com/v1/badges/0535eef45908cc64b740/maintainability)](https://codeclimate.com/github/weheartit/simple_throttle/maintainability)
 [![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
 
-This gem provides a very simple throttling mechanism backed by redis for limiting access to a resource. The throttle can be thought of as a limit on the number of calls in a set time frame (i.e. 100 calls per hour). These
+This gem provides a very simple throttling mechanism backed by Redis for limiting access to a resource. The throttle can be thought of as a limit on the number of calls in a set time frame (i.e. 100 calls per hour).
 
 ## Usage
 
@@ -38,7 +38,33 @@ Calling `allowed!` will return `true` if the throttle limit has not yet been rea
 
 The throttle data is kept in redis as a list of timestamps and will be auto expired if it falls out of use. The thottles time windows are rolling time windows and more calls will be allowed as soon as possible. So, if you have a throttle of, 100 requests per hour, and the throttle kicks in, you will be able to make the next throttled call one hour after the first call being tracked, not one hour after the last call.
 
-Redis server 2.6 or greater is required.
+### Pause to recover option
+
+Throttles can also specify a `pause_to_recover` option set when they are created. When this flag is set, once a throttle check fails, it will continue to fail until the rate at which it is called drops below the maximum rate allowed by the throttle. This is designed for use where you want to detect run away processes constantly hitting a service. Without this set, the process would be able to utilize the resource up to the set limit. With it set, the process would need to pause temporarily to succeed again.
+
+For example, if you have a throttle that allows 10 calls per 60 seconds, then a process hitting every second will succeed 10 times per minute. A similar throttle with the `pause_to_recover` option set, would only succeed on the first 10 calls. After that, it will continue to fail until the rate at which it is called drops below the maximum rate of the throttle (i.e. once every 6 seconds).
+
+```ruby
+throttle_1 = SimpleThrottle.new("t1", limit: 10, ttl: 60)
+throttle_2 = SimpleThrottle.new("t2", limit: 10, ttl: 60, pause_to_recover: true)
+
+loop do
+  if throttle_1.allowed!
+    # This will be called 10 times every minute.
+    do_thing_1
+  end
+
+  if throttle_2.allowed!
+    # This will only be called 10 times in total because the throttle is never
+    # given a chance to recover.
+    do_thing_2
+  end
+end
+```
+
+### Redis requirement
+
+Redis server 2.6 or greater is required for this code.
 
 ## Installation
 

data/VERSION

@@ -1 +1 @@
-1.0.4
+1.0.6

data/lib/simple_throttle.rb

@@ -16,6 +16,7 @@ class SimpleThrottle
     local ttl = tonumber(ARGV[2])
     local now = ARGV[3]
     local push = tonumber(ARGV[4])
+    local pause_to_recover = tonumber(ARGV[5])
 
     local size = redis.call('llen', list_key)
     if size >= limit then
@@ -30,7 +31,7 @@ class SimpleThrottle
       end
     end
 
-    if push > 0 and size < limit then
+    if push > 0 and (size < limit or (size == limit and pause_to_recover > 0)) then
       redis.call('rpush', list_key, now)
       redis.call('pexpire', list_key, ttl)
     end
@@ -48,12 +49,15 @@ class SimpleThrottle
     # @param name [String] unique name for the throttle
     # @param ttl [Numeric] number of seconds that the throttle will remain active
     # @param limit [Integer] number of allowed requests within the throttle ttl
+    # @param pause_to_recover [Boolean] require processes calling the throttle
+    #   to pause at least temporarily before freeing up the throttle. If this is true,
+    #   then a throttle called constantly with no pauses will never free up.
     # @param redis [Redis, Proc] Redis instance to use or a Proc that yields a Redos instance
     # @return [void]
-    def add(name, ttl:, limit:, redis: nil)
+    def add(name, ttl:, limit:, pause_to_recover: false, redis: nil)
       @lock.synchronize do
         @throttles ||= {}
-        @throttles[name.to_s] = new(name, limit: limit, ttl: ttl, redis: redis)
+        @throttles[name.to_s] = new(name, limit: limit, ttl: ttl, pause_to_recover: pause_to_recover, redis: redis)
       end
     end
 
@@ -95,12 +99,16 @@ class SimpleThrottle
     private
 
     def execute_lua_script(redis:, keys:, args:)
-      @script_sha_1 ||= redis.script(:load, LUA_SCRIPT)
+      client = redis
+      @script_sha_1 ||= client.script(:load, LUA_SCRIPT)
+      attempts = 0
+
       begin
-        redis.evalsha(@script_sha_1, Array(keys), Array(args))
+        client.evalsha(@script_sha_1, Array(keys), Array(args))
       rescue Redis::CommandError => e
-        if e.message.include?("NOSCRIPT")
-          @script_sha_1 = redis.script(:load, LUA_SCRIPT)
+        if e.message.include?("NOSCRIPT") && attempts < 2
+          @script_sha_1 = client.script(:load, LUA_SCRIPT)
+          attempts += 1
           retry
         else
           raise e
@@ -116,12 +124,16 @@ class SimpleThrottle
   # @param name [String] unique name for the throttle
   # @param ttl [Numeric] number of seconds that the throttle will remain active
   # @param limit [Integer] number of allowed requests within the throttle ttl
+  # @param pause_to_recover [Boolean] require processes calling the throttle
+  #   to pause at least temporarily before freeing up the throttle. If this is true,
+  #   then a throttle called constantly with no pauses will never free up.
   # @param redis [Redis, Proc] Redis instance to use or a Proc that yields a Redos instance
-  def initialize(name, ttl:, limit:, redis: nil)
+  def initialize(name, ttl:, limit:, pause_to_recover: false, redis: nil)
     @name = name.to_s
     @name = name.dup.freeze unless name.frozen?
     @limit = limit.to_i
     @ttl = ttl.to_f
+    @pause_to_recover = !!pause_to_recover
     @redis = redis
   end
 
@@ -178,9 +190,10 @@ class SimpleThrottle
   # If push is set to true then a new item will be added to the list.
   def current_size(push)
     push_arg = (push ? 1 : 0)
+    pause_to_recover_arg = (@pause_to_recover ? 1 : 0)
     time_ms = (Time.now.to_f * 1000).round
     ttl_ms = (ttl * 1000).ceil
-    self.class.send(:execute_lua_script, redis: redis_client, keys: [redis_key], args: [limit, ttl_ms, time_ms, push_arg])
+    self.class.send(:execute_lua_script, redis: redis_client, keys: [redis_key], args: [limit, ttl_ms, time_ms, push_arg, pause_to_recover_arg])
   end
 
   def redis_key

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: simple_throttle
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.6
 platform: ruby
 authors:
 - We Heart It
 - Brian Durand
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-10 00:00:00.000000000 Z
+date: 2023-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -39,7 +39,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - dev@weheartit.com
 - bbdurand@gmail.com
@@ -57,7 +57,7 @@ homepage: https://github.com/weheartit/simple_throttle
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -72,8 +72,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: Simple redis backed throttling mechanism to limit access to a resource
 test_files: []