Class: SimpleThrottle
- Inherits:
-
Object
- Object
- SimpleThrottle
- Defined in:
- lib/simple_throttle.rb
Overview
Create a simple throttle that can be used to limit the number of request for a resouce per time period. These objects are thread safe.
Constant Summary collapse
- LUA_SCRIPT =
Server side Lua script that maintains the throttle in redis. The throttle is stored as a list of timestamps in milliseconds. When the script is invoked it will scan the oldest entries removing any that should be expired from the list. If the list is below the specified limit then the current entry will be added. The list is marked to expire with the oldest entry so there’s no need to cleanup the lists.
<<~LUA local list_key = KEYS[1] local limit = tonumber(ARGV[1]) 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 local expired = tonumber(now) - ttl while size > 0 do local t = redis.call('lpop', list_key) if tonumber(t) > expired then redis.call('lpush', list_key, t) break end size = size - 1 end end 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 return size LUA
Instance Attribute Summary collapse
-
#limit ⇒ Object
readonly
Returns the value of attribute limit.
-
#name ⇒ Object
readonly
Returns the value of attribute name.
-
#ttl ⇒ Object
readonly
Returns the value of attribute ttl.
Class Method Summary collapse
-
.[](name) ⇒ SimpleThrottle
Returns a globally defined throttle with the specfied name.
-
.add(name, ttl:, limit:, pause_to_recover: false, redis: nil) ⇒ void
Add a global throttle that can be referenced later with the [] method.
-
.redis ⇒ Redis
Return the Redis instance where the throttles are stored.
-
.set_redis(client = nil, &block) ⇒ void
Set the Redis instance to use for maintaining the throttle.
Instance Method Summary collapse
-
#allowed! ⇒ Boolean
Returns true if the limit for the throttle has not been reached yet.
-
#initialize(name, ttl:, limit:, pause_to_recover: false, redis: nil) ⇒ SimpleThrottle
constructor
Create a new throttle.
-
#peek ⇒ Integer
Peek at the current number for throttled calls being tracked.
-
#reset! ⇒ void
Reset a throttle back to zero.
-
#wait_time ⇒ Float
Returns when the next resource call should be allowed.
Constructor Details
#initialize(name, ttl:, limit:, pause_to_recover: false, redis: nil) ⇒ SimpleThrottle
Create a new throttle.
131 132 133 134 135 136 137 138 |
# File 'lib/simple_throttle.rb', line 131 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 |
Instance Attribute Details
#limit ⇒ Object (readonly)
Returns the value of attribute limit.
120 121 122 |
# File 'lib/simple_throttle.rb', line 120 def limit @limit end |
#name ⇒ Object (readonly)
Returns the value of attribute name.
120 121 122 |
# File 'lib/simple_throttle.rb', line 120 def name @name end |
#ttl ⇒ Object (readonly)
Returns the value of attribute ttl.
120 121 122 |
# File 'lib/simple_throttle.rb', line 120 def ttl @ttl end |
Class Method Details
.[](name) ⇒ SimpleThrottle
Returns a globally defined throttle with the specfied name.
68 69 70 71 72 |
# File 'lib/simple_throttle.rb', line 68 def [](name) if defined?(@throttles) && @throttles @throttles[name.to_s] end end |
.add(name, ttl:, limit:, pause_to_recover: false, redis: nil) ⇒ void
This method returns an undefined value.
Add a global throttle that can be referenced later with the [] method. This can be used to configure global throttles that you want to setup once and then use in multiple places.
57 58 59 60 61 62 |
# File 'lib/simple_throttle.rb', line 57 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, pause_to_recover: pause_to_recover, redis: redis) end end |
.redis ⇒ Redis
Return the Redis instance where the throttles are stored.
90 91 92 93 94 95 96 97 |
# File 'lib/simple_throttle.rb', line 90 def redis @redis_client ||= Redis.new if @redis_client.is_a?(Proc) @redis_client.call else @redis_client end end |
.set_redis(client = nil, &block) ⇒ void
This method returns an undefined value.
Set the Redis instance to use for maintaining the throttle. This can either be set with a hard coded value or by the value yielded by a block. If the block form is used it will be invoked at runtime to get the instance. Use this method if your Redis instance isn’t constant (for example if you’re in a forking environment and re-initialize connections on fork)
83 84 85 |
# File 'lib/simple_throttle.rb', line 83 def set_redis(client = nil, &block) @redis_client = (client || block) end |
Instance Method Details
#allowed! ⇒ Boolean
Returns true if the limit for the throttle has not been reached yet. This method will also track the throttled resource as having been invoked on each call.
144 145 146 147 |
# File 'lib/simple_throttle.rb', line 144 def allowed! size = current_size(true) size < limit end |
#peek ⇒ Integer
Peek at the current number for throttled calls being tracked.
159 160 161 162 163 |
# File 'lib/simple_throttle.rb', line 159 def peek = redis_client.lrange(redis_key, 0, -1).collect(&:to_i) = ((Time.now.to_f - ttl) * 1000).ceil .count { |t| t > } end |
#reset! ⇒ void
This method returns an undefined value.
Reset a throttle back to zero.
152 153 154 |
# File 'lib/simple_throttle.rb', line 152 def reset! redis_client.del(redis_key) end |
#wait_time ⇒ Float
Returns when the next resource call should be allowed. Note that this doesn’t guarantee that calling allow! will return true if the wait time is zero since other processes or threads can claim the resource.
170 171 172 173 174 175 176 177 178 179 |
# File 'lib/simple_throttle.rb', line 170 def wait_time if peek < limit 0.0 else first = redis_client.lindex(redis_key, 0).to_f / 1000.0 delta = Time.now.to_f - first delta = 0.0 if delta < 0 ttl - delta end end |