berater 0.10.1 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e691d2d3cdc8f002e0e222c24d2e6f9a52ccb1dac7edaa92ea232ecce17fb77e
-  data.tar.gz: 5d302fff5fd063f34a94b1aae1b9b2e118b18efbe2315b4591405346f1dbc70c
+  metadata.gz: 5d3ef54656151bf378670caca07686db842a007e87e51d14195cc3f2b8d34d34
+  data.tar.gz: 22c6b65158ba926e78cd013c54913024c617eb5c2932297f7e4e424a72f66a14
 SHA512:
-  metadata.gz: 88b8e91557729601336b5235fbcc9710c79aa2f68ff393a09b5c55a1c994cef7371ed4a310c8038b07bdfc5f35d6b367ad7e1fc886c3f7c8579130808af5386b
-  data.tar.gz: 2600478d9761b14abbc2ef6c1a38b2e5b5e7476a40c6955f110746d4a90e31baabbda8d6571dcaf7d4e457d0cc19f120e84cba8915ded01b2a680111806d4400
+  metadata.gz: 2743af38d4daf9cd5d18a06368834545add59fb6d192fdf17c7f503ab059961177c444e5b09efde6a8ed6739b4cca04d83e7e88f8d904d0bd3e2b1bc94220cfb
+  data.tar.gz: a6750a44bcd05a1d0b25ff770d3c1d0f6fd3fd331cfebebbecdebd4ef06bc4f5a34d350cc36414cce7b212e7e63f8bb1d10cc4d25788ae50e1b973dfd280be4e

data/lib/berater/limiter.rb

@@ -7,12 +7,12 @@ module Berater
       options[:redis] || Berater.redis
     end
 
-    def limit(capacity: nil, cost: 1, &block)
-      capacity ||= @capacity
-      lock = nil
+    def limit(**opts, &block)
+      opts[:capacity] ||= @capacity
+      opts[:cost] ||= 1
 
-      Berater.middleware.call(self, capacity: capacity, cost: cost) do |limiter, **opts|
-        lock = limiter.inner_limit(**opts)
+      lock = Berater.middleware.call(self, **opts) do |limiter, **opts|
+        limiter.inner_limit(**opts)
       end
 
       if block_given?
@@ -27,10 +27,24 @@ module Berater
     end
 
     protected def inner_limit(capacity:, cost:)
+      if capacity.is_a?(String)
+        # try casting
+        begin
+          capacity = Float(capacity)
+        rescue ArgumentError; end
+      end
+
       unless capacity.is_a?(Numeric) && capacity >= 0
         raise ArgumentError, "invalid capacity: #{capacity}"
       end
 
+      if cost.is_a?(String)
+        # try casting
+        begin
+          cost = Float(cost)
+        rescue ArgumentError; end
+      end
+
       unless cost.is_a?(Numeric) && cost >= 0 && cost < Float::INFINITY
         raise ArgumentError, "invalid cost: #{cost}"
       end
@@ -76,6 +90,13 @@ module Berater
     end
 
     def capacity=(capacity)
+      if capacity.is_a?(String)
+        # try casting
+        begin
+          capacity = Float(capacity)
+        rescue TypeError, ArgumentError; end
+      end
+
       unless capacity.is_a?(Numeric)
         raise ArgumentError, "expected Numeric, found #{capacity.class}"
       end

data/lib/berater/middleware/fail_open.rb

@@ -0,0 +1,43 @@
+require 'set'
+
+module Berater
+  module Middleware
+    class FailOpen
+      ERRORS = Set[
+        Redis::BaseConnectionError,
+      ]
+
+      def initialize(errors: nil, on_fail: nil)
+        @errors = errors || ERRORS
+        @on_fail = on_fail
+      end
+
+      def call(*, **opts)
+        yield.tap do |lock|
+          return lock unless lock&.is_a?(Berater::Lock)
+
+          # wrap lock.release so it fails open
+
+          # save reference to original function
+          release_fn = lock.method(:release)
+
+          # make bound variables accessible to block
+          errors = @errors
+          on_fail = @on_fail
+
+          lock.define_singleton_method(:release) do
+            release_fn.call
+          rescue *errors => e
+            on_fail&.call(e)
+            false
+          end
+        end
+      rescue *@errors => e
+        @on_fail&.call(e)
+
+        # fail open by faking a lock
+        Berater::Lock.new(opts[:capacity], -1)
+      end
+    end
+  end
+end

data/lib/berater/middleware/load_shedder.rb

@@ -0,0 +1,36 @@
+module Berater
+  module Middleware
+    class LoadShedder
+      PRIORITY_RANGE = 1..5
+
+      def initialize(default_priority: nil)
+        @default_priority = default_priority
+      end
+
+      def call(*args, **opts)
+        if priority = opts.delete(:priority) || @default_priority
+          opts[:capacity] = adjust_capacity(opts[:capacity], priority)
+        end
+
+        yield *args, **opts
+      end
+
+      protected
+
+      def adjust_capacity(capacity, priority)
+        if priority.is_a?(String)
+          # try casting
+          priority = Float(priority) rescue nil
+        end
+
+        unless PRIORITY_RANGE.include?(priority)
+          return capacity
+        end
+
+        # priority 1 stays at 100%, 2 scales down to 90%, 5 to 60%
+        factor = 1 - (priority - 1) * 0.1
+        (capacity * factor).floor
+      end
+    end
+  end
+end

data/lib/berater/middleware/statsd.rb

@@ -0,0 +1,94 @@
+module Berater
+  module Middleware
+    class Statsd
+      def initialize(client, tags: {})
+        @client = client
+        @tags = tags
+      end
+
+      def call(limiter, **opts)
+        duration = -Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        lock = yield
+      rescue Exception => error
+        # note exception and propagate
+        raise
+      ensure
+        duration += Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        duration = (duration * 1_000).round(2) # milliseconds
+
+        tags = build_tags(limiter, opts)
+
+        @client.timing(
+          'berater.limiter.limit',
+          duration,
+          tags: tags,
+        )
+
+        @client.gauge(
+          'berater.limiter.capacity',
+          limiter.capacity,
+          tags: tags,
+        )
+
+        if lock
+          @client.increment(
+            'berater.lock.acquired',
+            tags: tags,
+          )
+
+          if lock.contention > 0 # not a failsafe lock
+            @client.gauge(
+              'berater.lock.capacity',
+              lock.capacity,
+              tags: tags,
+            )
+            @client.gauge(
+              'berater.limiter.contention',
+              lock.contention,
+              tags: tags,
+            )
+          end
+        end
+
+        if error
+          if error.is_a?(Berater::Overloaded)
+            @client.increment(
+              'berater.limiter.overloaded',
+              tags: tags,
+            )
+
+            # overloaded, so contention >= capacity
+            @client.gauge(
+              'berater.limiter.contention',
+              limiter.capacity,
+              tags: tags,
+            )
+          else
+            @client.increment(
+              'berater.limiter.error',
+              tags: tags.merge(type: error.class.to_s.gsub('::', '_'))
+            )
+          end
+        end
+      end
+
+      private
+
+      def build_tags(limiter, opts)
+        tags = {
+          key: limiter.key,
+          limiter: limiter.class.to_s.split(':')[-1],
+        }
+
+        # append custom tags
+        if @tags.respond_to?(:call)
+          tags.merge!(@tags.call(limiter, **opts) || {})
+        else
+          tags.merge!(@tags)
+        end
+
+        tags.merge!(opts.fetch(:tags, {}))
+      end
+    end
+  end
+end

data/lib/berater/middleware.rb

@@ -0,0 +1,7 @@
+module Berater
+  module Middleware
+    autoload 'FailOpen', 'berater/middleware/fail_open'
+    autoload 'LoadShedder', 'berater/middleware/load_shedder'
+    autoload 'Statsd', 'berater/middleware/statsd'
+  end
+end

data/lib/berater/version.rb

@@ -1,3 +1,3 @@
 module Berater
-  VERSION = "0.10.1"
+  VERSION = "0.12.1"
 end

data/lib/berater.rb

@@ -2,6 +2,7 @@ require 'berater/limiter'
 require 'berater/limiter_set'
 require 'berater/lock'
 require 'berater/lua_script'
+require 'berater/middleware'
 require 'berater/utils'
 require 'berater/version'
 require 'meddleware'
@@ -51,8 +52,8 @@ module Berater
   end
 
   def expunge
-    redis.scan_each(match: "#{self.name}*") do |key|
-      redis.del key
+    redis.scan_each(match: "#{name}*") do |key|
+      redis.del(key)
     end
   end
 

data/spec/concurrency_limiter_spec.rb

@@ -24,6 +24,7 @@ describe Berater::ConcurrencyLimiter do
     it { expect_capacity(0) }
     it { expect_capacity(1) }
     it { expect_capacity(1.5) }
+    it { expect_capacity('1.5') }
     it { expect_capacity(10_000) }
 
     context 'with erroneous values' do
@@ -34,7 +35,7 @@ describe Berater::ConcurrencyLimiter do
       end
 
       it { expect_bad_capacity(-1) }
-      it { expect_bad_capacity('1') }
+      it { expect_bad_capacity('abc') }
       it { expect_bad_capacity(:one) }
       it { expect_bad_capacity(Float::INFINITY) }
     end

data/spec/limiter_spec.rb

@@ -14,6 +14,34 @@ describe Berater::Limiter do
     end
   end
 
+  describe '#capacity=' do
+    subject do
+      Berater::RateLimiter.new(:key, capacity, :second).capacity
+    end
+
+    context 'when capacity is numeric' do
+      let(:capacity) { 3.5 }
+
+      it { is_expected.to be capacity }
+    end
+
+    context 'when capacity is a stringified numeric' do
+      let(:capacity) { '3.5' }
+
+      it 'casts the value' do
+        is_expected.to be capacity.to_f
+      end
+    end
+
+    context 'when capacity is a bogus value' do
+      let(:capacity) { :abc }
+
+      it 'raises' do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
   describe '#limit' do
     subject { Berater::Unlimiter.new }
 
@@ -29,6 +57,12 @@ describe Berater::Limiter do
           subject.limit(capacity: 'abc')
         }.to raise_error(ArgumentError)
       end
+
+      it 'handles stringified numerics gracefully' do
+        is_expected.to receive(:acquire_lock).with(3.5, anything)
+
+        subject.limit(capacity: '3.5')
+      end
     end
 
     context 'with a cost parameter' do
@@ -51,6 +85,12 @@ describe Berater::Limiter do
           subject.limit(cost: Float::INFINITY)
         }.to raise_error(ArgumentError)
       end
+
+      it 'handles stringified numerics gracefully' do
+        is_expected.to receive(:acquire_lock).with(anything, 2.5)
+
+        subject.limit(cost: '2.5')
+      end
     end
 
     context 'when Berater.redis is nil' do

data/spec/middleware/fail_open_spec.rb

@@ -0,0 +1,196 @@
+describe Berater::Middleware::FailOpen do
+  let(:limiter) { Berater::Unlimiter.new }
+  let(:lock) { limiter.limit }
+  let(:error) { Redis::TimeoutError }
+
+  describe '.call' do
+    let(:instance) { described_class.new(errors: errors, on_fail: on_fail) }
+    let(:errors) { nil }
+    let(:on_fail) { nil }
+
+    it 'returns the blocks value' do
+      expect(instance.call { lock }).to be lock
+    end
+
+    context 'when there is an error during lock acquisition' do
+      subject { instance.call { raise error } }
+
+      it 'still returns a lock' do
+        expect(subject).to be_a Berater::Lock
+      end
+
+      it 'creates a new, fake lock' do
+        expect(Berater::Lock).to receive(:new)
+        subject
+      end
+
+      it 'returns a lock that is releasable' do
+        expect(subject.release).to be true
+      end
+
+      context 'when an on_fail handler is defined' do
+        let(:on_fail) { double(Proc) }
+
+        it 'calls the handler' do
+          expect(on_fail).to receive(:call).with(error)
+          subject
+        end
+      end
+
+      context 'when the error is an IOError' do
+        let(:error) { IOError }
+
+        it 'would normally not catch the error' do
+          expect { subject }.to raise_error(error)
+        end
+
+        context 'and errors option is set' do
+          let(:errors) { [ error ] }
+
+          it 'catches the error' do
+            expect { subject }.not_to raise_error
+          end
+        end
+      end
+    end
+
+    context 'when there is an error during lock release' do
+      subject { instance.call { lock }.release }
+
+      before do
+        expect(lock).to receive(:release).and_raise(error)
+      end
+
+      it 'handles the exception' do
+        expect { subject }.not_to raise_error
+      end
+
+      it 'returns false since lock was not released' do
+        is_expected.to be false
+      end
+
+      context 'when an on_fail handler is defined' do
+        let(:on_fail) { double(Proc) }
+
+        it 'calls the handler' do
+          expect(on_fail).to receive(:call).with(Exception)
+          subject
+        end
+      end
+
+      context 'when the error is an IOError' do
+        let(:error) { IOError }
+
+        it 'would normally not catch the error' do
+          expect { subject }.to raise_error(error)
+        end
+
+        context 'and errors option is set' do
+          let(:errors) { [ error ] }
+
+          it 'catches the error' do
+            expect { subject }.not_to raise_error
+          end
+        end
+      end
+    end
+
+    context 'when there is no lock' do
+      it 'does not crash' do
+        instance.call {}
+      end
+    end
+
+    context 'when the lock is not a lock' do
+      it 'does not crash' do
+        instance.call { :foo }
+      end
+    end
+  end
+
+  context 'when there is an error during lock acquisition' do
+    before do
+      expect(limiter).to receive(:acquire_lock).and_raise(error)
+    end
+
+    it 'raises an exception for the caller' do
+      expect { limiter.limit }.to raise_error(error)
+    end
+
+    context 'when FailOpen middleware is enabled' do
+      before do
+        Berater.middleware.use described_class
+      end
+
+      it 'fails open' do
+        expect(limiter.limit).to be_a Berater::Lock
+      end
+
+      it 'returns the intended result' do
+        expect(limiter.limit { 123 }).to be 123
+      end
+    end
+
+    context 'when FailOpen middleware is enabled with callback' do
+      before do
+        Berater.middleware.use described_class, on_fail: on_fail
+      end
+      let(:on_fail) { double(Proc) }
+
+      it 'calls the callback' do
+        expect(on_fail).to receive(:call).with(Exception)
+        limiter.limit
+      end
+    end
+  end
+
+  context 'when there is an error during lock release' do
+    before do
+      allow(limiter).to receive(:acquire_lock).and_return(lock)
+      allow(lock).to receive(:release).and_raise(error)
+    end
+
+    it 'acquires a lock' do
+      expect(limiter.limit).to be_a Berater::Lock
+      expect(limiter.limit).to be lock
+    end
+
+    it 'raises an exception when lock is released' do
+      expect {
+        limiter.limit.release
+      }.to raise_error(error)
+    end
+
+    it 'raises an exception when lock is auto released' do
+      expect {
+        limiter.limit {}
+      }.to raise_error(error)
+    end
+
+    context 'when FailOpen middleware is enabled' do
+      before do
+        Berater.middleware.use described_class
+      end
+
+      it 'fails open' do
+        expect { limiter.limit.release }.not_to raise_error
+      end
+
+      it 'returns the intended result' do
+        expect(limiter.limit { 123 }).to be 123
+      end
+    end
+
+    context 'when FailOpen middleware is enabled with callback' do
+      before do
+        Berater.middleware.use described_class, on_fail: on_fail
+      end
+      let(:on_fail) { double(Proc) }
+
+      it 'calls the callback' do
+        expect(on_fail).to receive(:call).with(Exception)
+        limiter.limit {}
+      end
+    end
+  end
+end

data/spec/middleware/load_shedder_spec.rb

@@ -0,0 +1,150 @@
+describe Berater::Middleware::LoadShedder do
+  describe '#call' do
+    subject { described_class.new }
+
+    it 'yields' do
+      expect {|b| subject.call(&b) }.to yield_control
+    end
+
+    it 'passes through capacity and cost options' do
+      opts = {
+        capacity: 1,
+        cost: 2,
+      }
+
+      subject.call(**opts) do |**passed_opts|
+        expect(passed_opts).to eq(opts)
+      end
+    end
+
+    it 'strips out priority from options' do
+      opts = {
+        capacity: 1,
+        priority: 3,
+      }
+
+      subject.call(**opts) do |**passed_opts|
+        expect(passed_opts.keys).not_to include(:priority)
+      end
+    end
+
+    it 'keeps full capacity for priority 1' do
+      subject.call(capacity: 100, priority: 1) do |capacity:|
+        expect(capacity).to eq 100
+      end
+    end
+
+    it 'adjusts the capactiy according to priority' do
+      subject.call(capacity: 100, priority: 2) do |capacity:|
+        expect(capacity).to be < 100
+      end
+
+      subject.call(capacity: 100, priority: 5) do |capacity:|
+        expect(capacity).to eq 60
+      end
+    end
+
+    it 'works with a fractional priority' do
+      subject.call(capacity: 100, priority: 1.5) do |capacity:|
+        expect(capacity).to be < 100
+      end
+    end
+
+    context 'with a default priority' do
+      subject { described_class.new(default_priority: 5) }
+
+      it 'keeps full capacity for priority 1' do
+        subject.call(capacity: 100, priority: 1) do |capacity:|
+          expect(capacity).to eq 100
+        end
+      end
+
+      it 'uses the default priority' do
+        subject.call(capacity: 100) do |capacity:|
+          expect(capacity).to eq 60
+        end
+      end
+    end
+
+    context 'with a stringified priority' do
+      it 'casts the value' do
+        subject.call(capacity: 100, priority: '5') do |capacity:|
+          expect(capacity).to eq 60
+        end
+      end
+    end
+
+    context 'with a bogus priority value' do
+      it 'ignores the priority option' do
+        subject.call(capacity: 100, priority: nil) do |capacity:|
+          expect(capacity).to eq 100
+        end
+
+        subject.call(capacity: 100, priority: -1) do |capacity:|
+          expect(capacity).to eq 100
+        end
+
+        subject.call(capacity: 100, priority: 0) do |capacity:|
+          expect(capacity).to eq 100
+        end
+
+        subject.call(capacity: 100, priority: 50) do |capacity:|
+          expect(capacity).to eq 100
+        end
+
+        subject.call(capacity: 100, priority: 'abc') do |capacity:|
+          expect(capacity).to eq 100
+        end
+
+        subject.call(capacity: 100, priority: :abc) do |capacity:|
+          expect(capacity).to eq 100
+        end
+      end
+    end
+  end
+
+  context 'with a limiter' do
+    before do
+      Berater.middleware.use Berater::Middleware::LoadShedder
+    end
+
+    shared_examples 'limiter load shedding' do |limiter|
+      it 'passes through the capactiy properly' do
+        expect(limiter).to receive(:inner_limit).with(
+          hash_including(capacity: 100)
+        ).and_call_original
+
+        limiter.limit
+      end
+
+      it 'scales the capactiy with priority' do
+        expect(limiter).to receive(:inner_limit).with(
+          hash_including(capacity: 60)
+        ).and_call_original
+
+        limiter.limit(priority: 5)
+      end
+
+      it 'overloads properly' do
+        60.times { limiter.limit(priority: 5) }
+
+        expect {
+          limiter.limit(priority: 5)
+        }.to be_overloaded
+
+        expect {
+          limiter.limit(priority: 4)
+        }.not_to be_overloaded
+
+        39.times { limiter.limit(priority: 1) }
+
+        expect {
+          limiter.limit(priority: 1)
+        }.to be_overloaded
+      end
+    end
+
+    include_examples 'limiter load shedding', Berater::ConcurrencyLimiter.new(:key, 100)
+    include_examples 'limiter load shedding', Berater::RateLimiter.new(:key, 100, :second)
+  end
+end

data/spec/middleware/statsd_spec.rb

@@ -0,0 +1,232 @@
+require 'datadog/statsd'
+
+describe Berater::Middleware::Statsd do
+  let(:client) { double(Datadog::Statsd) }
+
+  before do
+    allow(client).to receive(:gauge)
+    allow(client).to receive(:increment)
+    allow(client).to receive(:timing)
+  end
+
+  describe '#call' do
+    subject { described_class.new(client, **client_opts).call(limiter, **opts, &block) }
+
+    let(:client_opts) { {} }
+    let(:limiter) { double(Berater::Limiter, key: :key, capacity: 5) }
+    let(:lock) { double(Berater::Lock, capacity: 4, contention: 2) }
+    let(:opts) { { capacity: lock.capacity, cost: 1 } }
+    let(:block) { lambda { lock } }
+
+    after { subject }
+
+    it 'returns a lock' do
+      expect(subject).to be lock
+    end
+
+    it 'tracks the call' do
+      expect(client).to receive(:timing).with(
+        'berater.limiter.limit',
+        Float,
+        tags: {
+          key: limiter.key,
+          limiter: String,
+        },
+      )
+    end
+
+    it 'tracks limiter capacity' do
+      expect(client).to receive(:gauge).with(
+        'berater.limiter.capacity',
+        limiter.capacity,
+        Hash
+      )
+    end
+
+    it 'tracks lock acquisition' do
+      expect(client).to receive(:increment).with(
+        'berater.lock.acquired',
+        Hash
+      )
+    end
+
+    context 'when custom tags are passed in' do
+      let(:opts) { { tags: { abc: 123 } } }
+
+      it 'incorporates the tags' do
+        expect(client).to receive(:timing) do |*, tags:|
+          expect(tags).to include(opts[:tags])
+        end
+      end
+    end
+
+    context 'with global tags' do
+      let(:client_opts) { { tags: { abc: 123 } }}
+
+      it 'incorporates the tags' do
+        expect(client).to receive(:timing) do |*, tags:|
+          expect(tags).to include(client_opts[:tags])
+        end
+      end
+    end
+
+    context 'with global tag callback' do
+      let(:client_opts) { { tags: callback }}
+      let(:callback) { double(Proc) }
+
+      it 'calls the callback' do
+        expect(callback).to receive(:call).with(limiter, **opts)
+      end
+
+      it 'incorporates the tags' do
+        expect(callback).to receive(:call).and_return({ abc: 123 })
+
+        expect(client).to receive(:timing) do |*, tags:|
+          expect(tags).to include(abc: 123)
+        end
+      end
+    end
+  end
+
+  context 'with a limiter' do
+    before do
+      Berater.middleware.use described_class, client
+    end
+
+    let(:limiter) { Berater::ConcurrencyLimiter.new(:key, 3) }
+
+    it 'tracks calls to limit' do
+      expect(client).to receive(:timing) do |*, tags:|
+        expect(tags[:limiter]).to eq 'ConcurrencyLimiter'
+      end
+
+      expect(client).to receive(:gauge).with(
+        'berater.limiter.capacity',
+        limiter.capacity,
+        Hash,
+      )
+
+      expect(client).to receive(:gauge).with(
+        'berater.limiter.contention',
+        1,
+        Hash,
+      )
+
+      limiter.limit
+    end
+
+    it 'tracks each call' do
+      expect(client).to receive(:gauge).with(
+        'berater.limiter.contention',
+        1,
+        Hash,
+      )
+
+      expect(client).to receive(:gauge).with(
+        'berater.limiter.contention',
+        2,
+        Hash,
+      )
+
+      2.times { limiter.limit }
+    end
+
+    context 'when an exception is raised' do
+      before do
+        expect(limiter).to receive(:redis).and_raise(error)
+      end
+
+      let(:error) { Redis::TimeoutError }
+
+      it 'tracks limiter exceptions' do
+        expect(client).to receive(:increment).with(
+          'berater.limiter.error',
+          tags: hash_including(type: 'Redis_TimeoutError'),
+        )
+
+        expect { limiter.limit }.to raise_error(error)
+      end
+
+      context 'with FailOpen middleware inserted after' do
+        before do
+          Berater.middleware.use Berater::Middleware::FailOpen
+        end
+
+        it 'does not track the exception' do
+          expect(client).not_to receive(:increment).with(
+            'berater.limiter.error',
+          )
+
+          limiter.limit
+        end
+
+        it 'does not track lock-based stats' do
+          expect(client).not_to receive(:gauge).with(
+            'berater.lock.capacity',
+          )
+
+          expect(client).not_to receive(:gauge).with(
+            'berater.limiter.contention',
+          )
+
+          limiter.limit
+        end
+      end
+
+      context 'with FailOpen middleware inserted before' do
+        before do
+          Berater.middleware.prepend Berater::Middleware::FailOpen
+        end
+
+        it 'tracks the exception' do
+          expect(client).to receive(:increment).with(
+            'berater.limiter.error',
+            anything,
+          )
+
+          limiter.limit
+        end
+
+        it 'does not track lock-based stats' do
+          expect(client).not_to receive(:gauge).with(
+            'berater.lock.capacity',
+          )
+
+          expect(client).not_to receive(:gauge).with(
+            'berater.limiter.contention',
+          )
+
+          limiter.limit
+        end
+      end
+    end
+
+    context 'when the limiter is overloaded' do
+      before { limiter.capacity.times { limiter.limit } }
+
+      after do
+        expect { limiter.limit }.to be_overloaded
+      end
+
+      it 'tracks the overloaded count' do
+        expect(client).to receive(:increment).with(
+          'berater.limiter.overloaded',
+          Hash
+        )
+      end
+
+      it 'tracks contention' do
+        expect(client).not_to receive(:gauge).with(
+          'berater.limiter.contention',
+          limiter.capacity,
+        )
+      end
+
+      it 'does not track the exception' do
+        expect(client).not_to receive(:increment).with(
+          'berater.limiter.error',
+        )
+      end
+    end
+  end
+end

data/spec/middleware_spec.rb

@@ -105,6 +105,16 @@ describe 'Berater.middleware' do
         expect(middleware).to receive(:call)
         expect(limiter.limit).to be nil
       end
+
+      it 'can intercept the lock' do
+        expect(middleware).to receive(:call) do |&block|
+          lock = block.call
+          expect(lock).to be_a Berater::Lock
+          expect(lock.capacity).to eq limiter.capacity
+        end
+
+        limiter.limit
+      end
     end
   end
 end

data/spec/rate_limiter_spec.rb

@@ -19,12 +19,13 @@ describe Berater::RateLimiter do
   describe '#capacity' do
     def expect_capacity(capacity)
       limiter = described_class.new(:key, capacity, :second)
-      expect(limiter.capacity).to eq capacity
+      expect(limiter.capacity).to eq capacity.to_f
     end
 
     it { expect_capacity(0) }
     it { expect_capacity(1) }
     it { expect_capacity(1.5) }
+    it { expect_capacity('1.5') }
     it { expect_capacity(100) }
 
     context 'with erroneous values' do
@@ -35,7 +36,7 @@ describe Berater::RateLimiter do
       end
 
       it { expect_bad_capacity(-1) }
-      it { expect_bad_capacity('1') }
+      it { expect_bad_capacity('abc') }
       it { expect_bad_capacity(:one) }
       it { expect_bad_capacity(Float::INFINITY) }
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: berater
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.12.1
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-18 00:00:00.000000000 Z
+date: 2021-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: meddleware
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: dogstatsd-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -150,6 +164,10 @@ files:
 - lib/berater/limiter_set.rb
 - lib/berater/lock.rb
 - lib/berater/lua_script.rb
+- lib/berater/middleware.rb
+- lib/berater/middleware/fail_open.rb
+- lib/berater/middleware/load_shedder.rb
+- lib/berater/middleware/statsd.rb
 - lib/berater/rate_limiter.rb
 - lib/berater/rspec.rb
 - lib/berater/rspec/matchers.rb
@@ -167,6 +185,9 @@ files:
 - spec/limiter_spec.rb
 - spec/lua_script_spec.rb
 - spec/matchers_spec.rb
+- spec/middleware/fail_open_spec.rb
+- spec/middleware/load_shedder_spec.rb
+- spec/middleware/statsd_spec.rb
 - spec/middleware_spec.rb
 - spec/rate_limiter_spec.rb
 - spec/riddle_spec.rb
@@ -193,12 +214,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: Berater
 test_files:
 - spec/rate_limiter_spec.rb
+- spec/middleware/load_shedder_spec.rb
+- spec/middleware/statsd_spec.rb
+- spec/middleware/fail_open_spec.rb
 - spec/matchers_spec.rb
 - spec/dsl_refinement_spec.rb
 - spec/test_mode_spec.rb