Simple Ruby Rate Limiting - ruby

Question

I am trying to build a very simple rate limit algorithm using an array.
Let's for example use the following rate limit as an example "5 requests every 5 minutes"
I have an array that stores a list of timestamps (where each element is a Time.now) and is added to the array when an API gets called (assuming it's under the rate limit)
I also used a Mutex here so different threads can both share the timestamp resource as well as ensuring there's no race condition happening.
However, I'd like this array to be self-cleaning of sorts. If there are 5 (or more) elements in the array AND one or more of it is outside of the 5 minute interval, it would automatically remove this entry.
And this is sort of where I am stuck on.
I have the following code:
def initialize(max, interval)
#max, #interval = max, interval
#m = Mutex.new
#timestamp = []
end
def validate_rate
#m.synchronize do
if #timestamp.count > #max && self.is_first_ts_expired
#timestamp.shift
if self.rate_count < #max
#timestamp << Time.now
return false
else
return true
end
end
end
end
def is_first_ts_expired
return false if ##timestamp[#name].first.nil? # no logged entries = no expired timestamps
return ##timestamp[#name].first <= Time.now - #interval
end
# Gets the number of requests that are under the allowed interval
def rate_count
count = 0
#timestamp.each { |x|
if x >= Time.now - #interval
count += 1
end
}
count
end
The following is how you will call this simple class. rl.validate_rate will return true if it's under the rate limit, but false if it's above. And ideally it will self-clean the timestamp array when it's greater than the max variable.
rl = RateLimit.new(5, 5.minutes)
raise RateLimitException unless rl.validate_rate do
# stuff
end
I am curious if where I put the "clean up" is_first_ts_expired code is called at the right place?

Answer 1

I think this is a totally valid approach.
Two quick notes:
1) It seems like you're only allowing insertion into the array when there are less than the max number of elements:
if rate_count < #max
#timestamp << Time.now
return true
else
return false
end
However, you're also only clearing out expired elements when there are greater than the number of allowed elements in the array:
if #timestamp.count > max && is_first_ts_expired
#timestamp.shift
I think in order to get this working, you want to remove that first condition when you are checking if you should clear elements from the array. It will look something like this:
if is_first_ts_expired
#timestamp.shift
2) You will only ever clean one item out of your array here:
if is_first_ts_expired
#timestamp.shift
To make this solution more robust, you may want to replace the if with a while so you can clean out multiple expired items. For example:
while is_first_ts_expired do
#timestamp.shift
end
Updated based on comment below:
Since you'll potentially be going through all of the timestamps if the timestamps are all expired, you'll want to slightly modify the is_first_ts_expired to handle an empty timestamp array. Something like this:
def is_first_ts_expired
current_ts = #timestamp.first
current_ts && current_ts <= Time.now - #interval
end