simple_throttle 1.0.5 → 1.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30c315dd33f7e175c0e74b4dfd8344e889d7e856c96c786b87ebac29d07fcc3a
-  data.tar.gz: acfb600e437eb125b9bf279dd95315ce7fa40612f836f887003b360ae2aacceb
+  metadata.gz: 4bf38f023dce00a87b27e9b2f39d0519a8dbb4abd90b549697be21ed6792bd7f
+  data.tar.gz: 35023bd729899add113084518e63f8ee6975bf71c7a5b12fc0ceb64924ccd207
 SHA512:
-  metadata.gz: 89d1b64043ee7f6460be93bb12ac50728e31ede360bcaa68191cb84087d50fe7db4386d8d24eba380c37a9426df78cb26c0685da75d7f6610e244e332be2821c
-  data.tar.gz: 47598bdce624ab1effbefbfc36d8860f3e017a7ecb2213cdd46d8c67e681583df62bdaf1270f77f6d4e83a88de0c0222c92c3a141fb9bfc3340cbee3bf0914a3
+  metadata.gz: dfab9a31ebc150ceb5f6b8833efc670357eefa790e60b33156607f7d72155566c300c454fc58368cae15936b8152f2c47e5ed83875ca3b8e0f58f9219d03d5e1
+  data.tar.gz: 4a3bd5605206b8b1e93bcc527c7d3f2dbf22590f23e390c4cb5c75ba7ac3cbe2fef885adffb62006fed54f310eea5804e10c6f319c81c45c8832971d36818718

data/CHANGELOG.md

@@ -4,6 +4,19 @@ 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.7
+
+## Fixed
+- Fixed peek method to return the correct value rather than the raw value from Redis.
+
+### Changed
+- Updated repository location and gem owners
+
+## 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

data/MIT_LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2016 WHI, Inc.
+Copyright (c) 2016 Brian Durand
 
 MIT License
 

data/README.md

@@ -1,7 +1,6 @@
-[![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 +37,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.5
+1.0.7

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
 
@@ -120,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
 
@@ -149,7 +157,9 @@ class SimpleThrottle
   #
   # @return [Integer]
   def peek
-    current_size(false)
+    timestamps = redis_client.lrange(redis_key, 0, -1).collect(&:to_i)
+    min_timestamp = ((Time.now.to_f - ttl) * 1000).ceil
+    timestamps.count { |t| t > min_timestamp }
   end
 
   # Returns when the next resource call should be allowed. Note that this doesn't guarantee that
@@ -182,9 +192,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

data/simple_throttle.gemspec

@@ -1,11 +1,11 @@
 Gem::Specification.new do |spec|
   spec.name = "simple_throttle"
   spec.version = File.read(File.expand_path("../VERSION", __FILE__)).strip
-  spec.authors = ["We Heart It", "Brian Durand"]
-  spec.email = ["dev@weheartit.com", "bbdurand@gmail.com"]
+  spec.authors = ["Brian Durand"]
+  spec.email = ["bbdurand@gmail.com"]
 
   spec.summary = "Simple redis backed throttling mechanism to limit access to a resource"
-  spec.homepage = "https://github.com/weheartit/simple_throttle"
+  spec.homepage = "https://github.com/bdurand/simple_throttle"
   spec.license = "MIT"
 
   # Specify which files should be added to the gem when it is released.

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_throttle
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.0.7
 platform: ruby
 authors:
-- We Heart It
 - Brian Durand
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-04 00:00:00.000000000 Z
+date: 2023-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -41,7 +40,6 @@ dependencies:
         version: '0'
 description:
 email:
-- dev@weheartit.com
 - bbdurand@gmail.com
 executables: []
 extensions: []
@@ -53,7 +51,7 @@ files:
 - VERSION
 - lib/simple_throttle.rb
 - simple_throttle.gemspec
-homepage: https://github.com/weheartit/simple_throttle
+homepage: https://github.com/bdurand/simple_throttle
 licenses:
 - MIT
 metadata: {}