berater 0.6.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd61012052d49f83a59057ed5ce4cc46b9c25a2d2bf4b5e494f02e590c2e2249
-  data.tar.gz: 3add1b481830566088eb7a9dce3540716b55dda9bb658a7b26b93a261b403f3a
+  metadata.gz: 7d25d186bfb9e709986e5c205c9fd2b8107dcf8df1e915316d28a6a59a0d4c0f
+  data.tar.gz: '05380448ad96697b5d3753a93584d4bdfcf3b028c649ca11360a1c92d6afadad'
 SHA512:
-  metadata.gz: 476cf552a5fb56498f81a737dba79358d016bedbd76c3c2cc8069c420e82a221c54280781821ef701d25da2551ddc25910818dc400dc7c046cecbe8f6db0ddd2
-  data.tar.gz: a92e64f027425ecdc4a39ee5f88a792f4f2625ec4bcf65fac70e34d591fb136e7544caa80138474ae5f5e6158fc19ec8894892585cf858966bfe5fe13a3d011b
+  metadata.gz: 6ddcd488d3d1aa293d621f32ad8cd684daffb0ba9c413e8cf6a7a292ae63a307e2cdf8e62803cf2a8c2b3ea7b9424e4874bb773f49620e768895b193385e847f
+  data.tar.gz: cf923f95875da8b7e6c0c0cbe4dccad5a4e3c9f6436da606a03f93c2b9ff86525485c6379ade0f276f30e1aff3bcf0c279fe88d33e6769455818482a5ff1a179

data/lib/berater.rb

@@ -19,20 +19,23 @@ module Berater
     @redis = nil
   end
 
-  def new(key, capacity, interval = nil, **opts)
+  def new(key, capacity, **opts)
+    args = []
+
     case capacity
-    when :unlimited, Float::INFINITY
+    when Float::INFINITY
       Berater::Unlimiter
-    when :inhibited, 0
+    when 0
       Berater::Inhibitor
     else
-      if interval
+      if opts[:interval]
+        args << opts.delete(:interval)
         Berater::RateLimiter
       else
         Berater::ConcurrencyLimiter
       end
     end.yield_self do |klass|
-      args = [ key, capacity, interval ].compact
+      args = [ key, capacity, *args ].compact
       klass.new(*args, **opts)
     end
   end
@@ -46,8 +49,8 @@ module Berater
 end
 
 # convenience method
-def Berater(key, capacity, interval = nil, **opts, &block)
-  limiter = Berater.new(key, capacity, interval, **opts)
+def Berater(key, capacity, **opts, &block)
+  limiter = Berater.new(key, capacity, **opts)
   if block_given?
     limiter.limit(&block)
   else

data/lib/berater/concurrency_limiter.rb

@@ -1,13 +1,14 @@
 module Berater
   class ConcurrencyLimiter < Limiter
 
-    class Incapacitated < Overloaded; end
-
     attr_reader :timeout
 
     def initialize(key, capacity, **opts)
       super(key, capacity, **opts)
 
+      # round fractional capacity
+      self.capacity = capacity.to_i
+
       self.timeout = opts[:timeout] || 0
     end
 
@@ -28,17 +29,15 @@ module Berater
 
       -- purge stale hosts
       if ttl > 0 then
-        redis.call('ZREMRANGEBYSCORE', key, '-inf', ts - ttl)
+        redis.call('ZREMRANGEBYSCORE', key, 0, ts - ttl)
       end
 
       -- check capacity
       local count = redis.call('ZCARD', key)
 
       if cost == 0 then
-        -- just check limit, ie. for .overlimit?
-        if count < capacity then
-          table.insert(lock_ids, true)
-        end
+        -- just checking count
+        table.insert(lock_ids, true)
       elseif (count + cost) <= capacity then
         -- grab locks, one per cost
         local lock_id = redis.call('INCRBY', lock_key, cost)
@@ -64,7 +63,7 @@ module Berater
     )
 
     protected def acquire_lock(capacity, cost)
-      # fractional cost is not supported, but make it work
+      # round fractional capacity and cost
       capacity = capacity.to_i
       cost = cost.ceil
 
@@ -77,7 +76,7 @@ module Berater
         [ capacity, ts, @timeout_msec, cost ]
       )
 
-      raise Incapacitated if lock_ids.empty?
+      raise Overloaded if lock_ids.empty?
 
       release_fn = if cost > 0
         proc { release(lock_ids) }
@@ -86,8 +85,6 @@ module Berater
       Lock.new(capacity, count, release_fn)
     end
 
-    alias incapacitated? overloaded?
-
     private def release(lock_ids)
       res = redis.zrem(cache_key(key), lock_ids)
       res == true || res == lock_ids.count # depending on which version of Redis

data/lib/berater/dsl.rb

@@ -1,20 +1,21 @@
 module Berater
   module DSL
     refine Berater.singleton_class do
-      def new(key, mode = nil, *args, **opts, &block)
-        if mode.nil?
+      def new(key, capacity = nil, **opts, &block)
+        if capacity.nil?
           unless block_given?
-            raise ArgumentError, 'expected either mode or block'
+            raise ArgumentError, 'expected either capacity or block'
           end
 
-          mode, *args = DSL.eval(&block)
+          capacity, more_opts = DSL.eval(&block)
+          opts.merge!(more_opts) if more_opts
         else
           if block_given?
-            raise ArgumentError, 'expected either mode or block, not both'
+            raise ArgumentError, 'expected either capacity or block, not both'
           end
         end
 
-        super(key, mode, *args, **opts)
+        super(key, capacity, **opts)
       end
     end
 
@@ -38,13 +39,12 @@ module Berater
 
     KEYWORDS = [
       :second, :minute, :hour,
-      :unlimited, :inhibited,
     ].freeze
 
     def install
       Integer.class_eval do
         def per(unit)
-          [ self, unit ]
+          [ self, interval: unit ]
         end
         alias every per
 

data/lib/berater/inhibitor.rb

@@ -1,16 +1,12 @@
 module Berater
   class Inhibitor < Limiter
 
-    class Inhibited < Overloaded; end
-
     def initialize(key = :inhibitor, *args, **opts)
       super(key, 0, **opts)
     end
 
-    alias inhibited? overloaded?
-
     protected def acquire_lock(*)
-      raise Inhibited
+      raise Overloaded
     end
 
   end

data/lib/berater/limiter.rb

@@ -10,11 +10,11 @@ module Berater
     def limit(capacity: nil, cost: 1, &block)
       capacity ||= @capacity
 
-      unless capacity.is_a?(Numeric)
+      unless capacity.is_a?(Numeric) && capacity >= 0
         raise ArgumentError, "invalid capacity: #{capacity}"
       end
 
-      unless cost.is_a?(Numeric) && cost >= 0
+      unless cost.is_a?(Numeric) && cost >= 0 && cost < Float::INFINITY
         raise ArgumentError, "invalid cost: #{cost}"
       end
 
@@ -31,10 +31,16 @@ module Berater
       end
     end
 
-    def overloaded?
-      limit(cost: 0) { false }
-    rescue Overloaded
-      true
+    def utilization
+      lock = limit(cost: 0)
+
+      if lock.capacity == 0
+        1.0
+      else
+        lock.contention.to_f / lock.capacity
+      end
+    rescue Berater::Overloaded
+      1.0
     end
 
     def to_s

data/lib/berater/rate_limiter.rb

@@ -1,8 +1,6 @@
 module Berater
   class RateLimiter < Limiter
 
-    class Overrated < Overloaded; end
-
     attr_accessor :interval
 
     def initialize(key, capacity, interval, **opts)
@@ -26,24 +24,32 @@ module Berater
       local capacity = tonumber(ARGV[2])
       local interval_msec = tonumber(ARGV[3])
       local cost = tonumber(ARGV[4])
-      local count = 0
-      local allowed
-      local msec_per_drip = interval_msec / capacity
-
-      -- timestamp of last update
-      local last_ts = tonumber(redis.call('GET', ts_key))
 
-      if last_ts then
-        count = tonumber(redis.call('GET', key)) or 0
-
-        -- adjust for time passing
-        local drips = math.floor((ts - last_ts) / msec_per_drip)
-        count = math.max(0, count - drips)
+      local allowed -- whether lock was acquired
+      local count -- capacity being utilized
+      local msec_per_drip = interval_msec / capacity
+      local state = redis.call('GET', key)
+
+      if state then
+        local last_ts -- timestamp of last update
+        count, last_ts = string.match(state, '([%d.]+);(%w+)')
+        count = tonumber(count)
+        last_ts = tonumber(last_ts, 16)
+
+        -- adjust for time passing, guarding against clock skew
+        if ts > last_ts then
+          local drips = math.floor((ts - last_ts) / msec_per_drip)
+          count = math.max(0, count - drips)
+        else
+          ts = last_ts
+        end
+      else
+        count = 0
       end
 
       if cost == 0 then
-        -- just check limit, ie. for .overlimit?
-        allowed = count < capacity
+        -- just checking count
+        allowed = true
       else
         allowed = (count + cost) <= capacity
 
@@ -52,14 +58,15 @@ module Berater
 
           -- time for bucket to empty, in milliseconds
           local ttl = math.ceil(count * msec_per_drip)
+          ttl = ttl + 100 -- margin of error, for clock skew
 
-          -- update count and last_ts, with expirations
-          redis.call('SET', key, count, 'PX', ttl)
-          redis.call('SET', ts_key, ts, 'PX', ttl)
+          -- update count and last_ts, with expiration
+          state = string.format('%f;%X', count, ts)
+          redis.call('SET', key, state, 'PX', ttl)
         end
       end
 
-      return { count, allowed }
+      return { tostring(count), allowed }
     LUA
     )
 
@@ -69,17 +76,17 @@ module Berater
 
       count, allowed = LUA_SCRIPT.eval(
         redis,
-        [ cache_key(key), cache_key("#{key}-ts") ],
+        [ cache_key(key) ],
         [ ts, capacity, @interval_msec, cost ]
       )
 
-      raise Overrated unless allowed
+      count = count.include?('.') ? count.to_f : count.to_i
+
+      raise Overloaded unless allowed
 
       Lock.new(capacity, count)
     end
 
-    alias overrated? overloaded?
-
     def to_s
       msg = if interval.is_a? Numeric
         if interval == 1

data/lib/berater/rspec/matchers.rb

@@ -1,10 +1,6 @@
 module Berater
   module Matchers
     class Overloaded
-      def initialize(type)
-        @type = type
-      end
-
       def supports_block_expectations?
         true
       end
@@ -12,13 +8,13 @@ module Berater
       def matches?(obj)
         case obj
         when Proc
-          # eg. expect { ... }.to be_overrated
+          # eg. expect { ... }.to be_overloaded
           res = obj.call
 
           if res.is_a? Berater::Limiter
             # eg. expect { Berater.new(...) }.to be_overloaded
             @limiter = res
-            res.overloaded?
+            @limiter.utilization >= 1
           else
             # eg. expect { Berater(...)  }.to be_overloaded
             # eg. expect { limiter.limit }.to be_overloaded
@@ -27,55 +23,39 @@ module Berater
         when Berater::Limiter
           # eg. expect(Berater.new(...)).to be_overloaded
           @limiter = obj
-          obj.overloaded?
+          @limiter.utilization >= 1
         end
-      rescue @type
+      rescue Berater::Overloaded
         true
       end
 
       def description
         if @limiter
-          "be #{verb}"
+          "be overloaded"
         else
-          "raise #{@type}"
+          "raise #{Berater::Overloaded}"
         end
       end
 
       def failure_message
         if @limiter
-          "expected to be #{verb}"
+          "expected to be overloaded"
         else
-          "expected #{@type} to be raised"
+          "expected #{Berater::Overloaded} to be raised"
         end
       end
 
       def failure_message_when_negated
         if @limiter
-          "expected not to be #{verb}"
+          "expected not to be overloaded"
         else
-          "did not expect #{@type} to be raised"
+          "did not expect #{Berater::Overloaded} to be raised"
         end
       end
-
-      private def verb
-        @type.to_s.split('::')[-1].downcase
-      end
     end
 
     def be_overloaded
-      Overloaded.new(Berater::Overloaded)
-    end
-
-    def be_overrated
-      Overloaded.new(Berater::RateLimiter::Overrated)
-    end
-
-    def be_incapacitated
-      Overloaded.new(Berater::ConcurrencyLimiter::Incapacitated)
-    end
-
-    def be_inhibited
-      Overloaded.new(Berater::Inhibitor::Inhibited)
+      Overloaded.new
     end
   end
 end

data/lib/berater/test_mode.rb

@@ -19,14 +19,7 @@ module Berater
       when :pass
         Lock.new(Float::INFINITY, 0)
       when :fail
-        # find class specific Overloaded error
-        e = self.class.constants.map do |name|
-          self.class.const_get(name)
-        end.find do |const|
-          const.is_a?(Class) && const < Berater::Overloaded
-        end || Berater::Overloaded
-
-        raise e
+        raise Overloaded
       else
         super
       end

data/lib/berater/version.rb

@@ -1,3 +1,3 @@
 module Berater
-  VERSION = '0.6.2'
+  VERSION = '0.7.0'
 end

data/spec/berater_spec.rb

@@ -25,7 +25,7 @@ describe Berater do
   end
 
   describe '.new' do
-    context 'unlimited mode' do
+    context 'Unlimiter mode' do
       let(:limiter) { Berater.new(:key, Float::INFINITY) }
 
       it 'instantiates an Unlimiter' do
@@ -44,7 +44,7 @@ describe Berater do
       end
     end
 
-    context 'inhibited mode' do
+    context 'Inhibitor mode' do
       let(:limiter) { Berater.new(:key, 0) }
 
       it 'instantiates an Inhibitor' do
@@ -64,7 +64,7 @@ describe Berater do
     end
 
     context 'rate mode' do
-      let(:limiter) { Berater.new(:key, 1, :second) }
+      let(:limiter) { Berater.new(:key, 1, interval: :second) }
 
       it 'instantiates a RateLimiter' do
         expect(limiter).to be_a Berater::RateLimiter
@@ -77,7 +77,7 @@ describe Berater do
 
       it 'accepts options' do
         redis = double('Redis')
-        limiter = Berater.new(:key, 1, :second, redis: redis)
+        limiter = Berater.new(:key, 1, interval: :second, redis: redis)
         expect(limiter.redis).to be redis
       end
     end
@@ -103,20 +103,20 @@ describe Berater do
   end
 
   describe 'Berater() - convenience method' do
-    RSpec.shared_examples 'test convenience' do |klass, *args|
+    RSpec.shared_examples 'test convenience' do |klass, capacity, **opts|
       it 'creates a limiter' do
-        limiter = Berater(:key, *args)
+        limiter = Berater(:key, capacity, **opts)
         expect(limiter).to be_a klass
       end
 
       context 'with a block' do
         it 'creates a limiter and calls limit' do
-          limiter = Berater(:key, *args)
+          limiter = Berater(:key, capacity, **opts)
           expect(klass).to receive(:new).and_return(limiter)
           expect(limiter).to receive(:limit).and_call_original
 
           begin
-            res = Berater(:key, *args) { true }
+            res = Berater(:key, capacity, **opts) { true }
             expect(res).to be true
           rescue Berater::Overloaded
             expect(klass).to be Berater::Inhibitor
@@ -127,7 +127,7 @@ describe Berater do
 
     include_examples 'test convenience', Berater::Unlimiter, Float::INFINITY
     include_examples 'test convenience', Berater::Inhibitor, 0
-    include_examples 'test convenience', Berater::RateLimiter, 1, :second
+    include_examples 'test convenience', Berater::RateLimiter, 1, interval: :second
     include_examples 'test convenience', Berater::ConcurrencyLimiter, 1
   end