prop 2.4.0 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 850a96785d6d002acd243a5edf5cca965bd46bd1
-  data.tar.gz: 9ffb56011562feb0d9cf2c5ab62705420d59d46e
+  metadata.gz: d0fe432ea00485ac163d99cc47cc62d515bf67fb
+  data.tar.gz: a6edac3e0e50fdaed49664fbdb4bd46419e81a27
 SHA512:
-  metadata.gz: 8cfee5d2c8af78a8a9273bdc873ba83ee6bb81237ca7cb253fce98dbf6180cff96f1004759e5d2fc4ee8e01364dddfae7f4b94c3909f547b08bcd3b109c9d7d2
-  data.tar.gz: 61e6d22651a9017e827d34220511fd8dd6dc60acaa69908968082d71a0ee6926859c0509f08b12fdf5a4d4310f83b95d0cf7b4137f713323d70fb88defcd0bbc
+  metadata.gz: 67390eaadb265153db7845785824a3f27b3bcb97db533b277d14b44a121c70deca9105bee5565541dabd53e374f67adff6da539346ea4f98f5bc8d730d156960
+  data.tar.gz: 66e0df0d0db24d5baf3ca3791b36dd0c9bf2f5bacc8d56637fb96d0f47266788483b752292e3b07337efc2d03c2e30d1b72e8330051ff64fa37984906566ad38

data/README.md

@@ -227,6 +227,8 @@ You can add two additional configurations: `:strategy` and `:burst_rate` to use
 Prop will handle the details after configured, and you don't have to specify `:strategy` 
 again when using `throttle`, `throttle!` or any other methods.
 
+The leaky bucket algorithm used is "leaky bucket as a meter".
+
 ```ruby
 Prop.configure(:api_request, strategy: :leaky_bucket, burst_rate: 20, threshold: 5, interval: 1.minute)
 ```

data/lib/prop.rb

@@ -3,7 +3,7 @@ require "prop/limiter"
 require "forwardable"
 
 module Prop
-  VERSION = "2.4.0"
+  VERSION = "2.5.0"
 
   # Short hand for accessing Prop::Limiter methods
   class << self

data/lib/prop/leaky_bucket_strategy.rb

@@ -5,40 +5,69 @@ require 'prop/key'
 module Prop
   class LeakyBucketStrategy
     class << self
+      def _throttle_leaky_bucket(handle, key, cache_key, options)
+        (over_limit, bucket) = options.key?(:decrement) ?
+          decrement(cache_key, options.fetch(:decrement), options) :
+          increment(cache_key, options.fetch(:increment, 1), options)
+
+        [over_limit, bucket]
+      end
+
       def counter(cache_key, options)
-        bucket = Prop::Limiter.cache.read(cache_key) || zero_counter
-        now = Time.now.to_i
-        leak_rate = (now - bucket.fetch(:last_updated)) / options.fetch(:interval).to_f
-        leak_amount =  leak_rate * options.fetch(:threshold)
+        cache.read(cache_key) || zero_counter
+      end
+
+      def leak_amount(bucket, amount, options, now)
+        leak_rate = (now - bucket.fetch(:last_leak_time, 0)) / options.fetch(:interval).to_f
+        leak_amount = (leak_rate * options.fetch(:threshold).to_f)
+        leak_amount.to_i
+      end
 
-        bucket[:bucket] = [(bucket.fetch(:bucket) - leak_amount).to_i, 0].max
-        bucket[:last_updated] = now
-        bucket
+      def update_bucket(current_bucket_size, max_bucket_size, amount)
+        over_limit = (max_bucket_size-current_bucket_size) < amount
+        updated_bucket_size = over_limit ? current_bucket_size : current_bucket_size + amount
+        [over_limit, updated_bucket_size]
       end
 
       # WARNING: race condition
       # this increment is not atomic, so it might miss counts when used frequently
       def increment(cache_key, amount, options)
-        counter = counter(cache_key, options)
-        counter[:bucket] += amount
-        Prop::Limiter.cache.write(cache_key, counter)
-        counter
+        bucket = counter(cache_key, options)
+        now = Time.now.to_i
+        max_bucket_size = options.fetch(:burst_rate)
+        current_bucket_size = bucket.fetch(:bucket, 0)
+        leak_amount = leak_amount(bucket, amount, options, now)
+        if leak_amount > 0
+          # maybe TODO, update last_leak_time to reflect the exact time for the current leak amount
+          # the current strategy will always reflect a little less leakage, probably not an issue though
+          bucket[:last_leak_time] = now
+          current_bucket_size = [(current_bucket_size - leak_amount), 0].max
+        end
+
+        over_limit, updated_bucket_size = update_bucket(current_bucket_size, max_bucket_size, amount)
+        bucket[:bucket] = updated_bucket_size
+        bucket[:over_limit] = over_limit
+        cache.write(cache_key, bucket)
+        [over_limit, bucket]
       end
 
       def decrement(cache_key, amount, options)
-        counter = counter(cache_key, options)
-        counter[:bucket] -= amount
-        counter[:bucket] = 0 unless counter[:bucket] > 0
-        Prop::Limiter.cache.write(cache_key, counter)
-        counter
+        now = Time.now.to_i
+        bucket = counter(cache_key, options)
+        leak_amount = leak_amount(bucket, amount, options, now)
+        bucket[:bucket] = [bucket[:bucket] - amount - leak_amount, 0].max
+        bucket[:last_leak_time] = now if leak_amount > 0
+        bucket[:over_limit] = false
+        cache.write(cache_key, bucket)
+        [false, bucket]
       end
 
       def reset(cache_key)
-        Prop::Limiter.cache.write(cache_key, zero_counter)
+        cache.write(cache_key, zero_counter, raw: true)
       end
 
-      def compare_threshold?(counter, operator, options)
-        counter.fetch(:bucket).to_i.send operator, options.fetch(:burst_rate)
+      def compare_threshold?(bucket, operator, options)
+        bucket.fetch(:over_limit, false)
       end
 
       def build(options)
@@ -70,7 +99,11 @@ module Prop
       end
 
       def zero_counter
-        { bucket: 0, last_updated: 0 }
+        { bucket: 0, last_leak_time: 0, over_limit: false }
+      end
+
+      def cache
+        Prop::Limiter.cache
       end
     end
   end

data/lib/prop/limiter.rb

@@ -142,9 +142,17 @@ module Prop
 
       private
 
+      def leaky_bucket_strategy?(strategy)
+        strategy == Prop::LeakyBucketStrategy
+      end
+
       def _throttle(strategy, handle, key, cache_key, options)
         return [false, strategy.zero_counter] if disabled?
 
+        if leaky_bucket_strategy?(strategy)
+          return Prop::LeakyBucketStrategy._throttle_leaky_bucket(handle, key, cache_key, options)
+        end
+
         counter = options.key?(:decrement) ?
           strategy.decrement(cache_key, options.fetch(:decrement), options) :
           strategy.increment(cache_key, options.fetch(:increment, 1), options)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prop
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.5.0
 platform: ruby
 authors:
 - Morten Primdahl
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-22 00:00:00.000000000 Z
+date: 2020-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -116,7 +116,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14.4
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: Gem for implementing rate limits.