berater 0.11.1 → 0.12.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b657c7eb3a69e868416ad2d149d6c35ab13989e77a16ece23217deaaa9fafb6
-  data.tar.gz: 30835e7c247da37543ea118067d0b61d16080399ff6b53e86783c53a94b8d560
+  metadata.gz: 250bedb127940f561746dc7385129f30a2a17b677501bb0f864596f8c3de30f9
+  data.tar.gz: 6adb5fa4d20cd133a4eb87e1406977619d9b5034f3b8ed8a576dcee0c36333cb
 SHA512:
-  metadata.gz: '04481aa9c3097930f66eb29c6e19e650309b882cf835c1f36cb3fa58524b957d1194b5acc6a83f9fdfd33b73f888261ff3cc3171d730fd9781d9cf768b2b0768'
-  data.tar.gz: e0cd1a220a418face72685b44d23dff0040dc5f3d94b8c0d82769123a1c387e709702e8f093cc9c0f600d002ea4c848ebd4f0a2e38a4368e743104fbee597f9d
+  metadata.gz: 72b457fc673453f21b75635776b37857f5f6f79f9bb90ba17b42b8e51f3351b427770ddeead2012bab18b32024ca3c850112868c824edb521b6e82bb7bcfc681
+  data.tar.gz: a5e81cda6ff755e6a19b12e18ca2a99b457879e7047845604bf533505bb4f3c95e6ac5bf032fb119a0115dcacc246dd616d94007a16d0fcd471f4851ea69f497

data/lib/berater/concurrency_limiter.rb

@@ -63,7 +63,7 @@ module Berater
     LUA
     )
 
-    protected def acquire_lock(capacity, cost)
+    protected def acquire_lock(capacity:, cost:)
       # round fractional capacity and cost
       capacity = capacity.to_i
       cost = cost.ceil

data/lib/berater/limiter.rb

@@ -1,5 +1,6 @@
 module Berater
   class Limiter
+    DEFAULT_COST = 1
 
     attr_reader :key, :capacity, :options
 
@@ -9,7 +10,7 @@ module Berater
 
     def limit(**opts, &block)
       opts[:capacity] ||= @capacity
-      opts[:cost] ||= 1
+      opts[:cost] ||= DEFAULT_COST
 
       lock = Berater.middleware.call(self, **opts) do |limiter, **opts|
         limiter.inner_limit(**opts)
@@ -26,7 +27,7 @@ module Berater
       end
     end
 
-    protected def inner_limit(capacity:, cost:)
+    protected def inner_limit(capacity:, cost:, **opts)
       if capacity.is_a?(String)
         # try casting
         begin
@@ -49,7 +50,7 @@ module Berater
         raise ArgumentError, "invalid cost: #{cost}"
       end
 
-      acquire_lock(capacity, cost)
+      acquire_lock(capacity: capacity, cost: cost, **opts)
     rescue NoMethodError => e
       raise unless e.message.include?("undefined method `evalsha' for")
 
@@ -110,13 +111,12 @@ module Berater
       @capacity = capacity
     end
 
-    def acquire_lock(capacity, cost)
+    def acquire_lock(capacity:, cost:)
       raise NotImplementedError
     end
 
-    def cache_key(subkey = nil)
-      instance_key = subkey.nil? ? key : "#{key}:#{subkey}"
-      self.class.cache_key(instance_key)
+    def cache_key
+      self.class.cache_key(key)
     end
 
     class << self

data/lib/berater/middleware/fail_open.rb

@@ -14,6 +14,8 @@ module Berater
 
       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

data/lib/berater/middleware/load_shedder.rb

@@ -18,6 +18,11 @@ module Berater
       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

data/lib/berater/middleware/statsd.rb

@@ -0,0 +1,92 @@
+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
+        # capture exception for reporting, then 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.lock.contention',
+              lock.contention,
+              tags: tags,
+            )
+          end
+        end
+
+        if error
+          if error.is_a?(Berater::Overloaded)
+            @client.increment(
+              'berater.limiter.overloaded',
+              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 global custom tags
+        if @tags
+          if @tags.respond_to?(:call)
+            tags.merge!(@tags.call(limiter, **opts) || {})
+          else
+            tags.merge!(@tags)
+          end
+        end
+
+        # append call specific custom tags
+        tags.merge!(opts[:tags]) if opts[:tags]
+
+        tags
+      end
+    end
+  end
+end

data/lib/berater/middleware/trace.rb

@@ -0,0 +1,41 @@
+require 'ddtrace'
+
+module Berater
+  module Middleware
+    class Trace
+      def initialize(tracer: nil)
+        @tracer = tracer
+      end
+
+      def call(limiter, **)
+        tracer.trace('Berater.limit') do |span|
+          begin
+            lock = yield
+          rescue Exception => error
+            # capture exception for reporting, then propagate
+            raise
+          ensure
+            span.set_tag('capacity', limiter.capacity)
+            span.set_tag('contention', lock.contention) if lock
+            span.set_tag('key', limiter.key)
+            span.set_tag('limiter', limiter.class.to_s.split(':')[-1])
+
+            if error
+              if error.is_a?(Berater::Overloaded)
+                span.set_tag('overloaded', true)
+              else
+                span.set_tag('error', error.class.to_s.gsub('::', '_'))
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      def tracer
+        @tracer || Datadog.tracer
+      end
+    end
+  end
+end

data/lib/berater/middleware.rb

@@ -2,5 +2,7 @@ module Berater
   module Middleware
     autoload 'FailOpen', 'berater/middleware/fail_open'
     autoload 'LoadShedder', 'berater/middleware/load_shedder'
+    autoload 'Statsd', 'berater/middleware/statsd'
+    autoload 'Trace', 'berater/middleware/trace'
   end
 end

data/lib/berater/rate_limiter.rb

@@ -20,7 +20,6 @@ module Berater
 
     LUA_SCRIPT = Berater::LuaScript(<<~LUA
       local key = KEYS[1]
-      local ts_key = KEYS[2]
       local ts = tonumber(ARGV[1])
       local capacity = tonumber(ARGV[2])
       local interval_msec = tonumber(ARGV[3])
@@ -71,7 +70,7 @@ module Berater
     LUA
     )
 
-    protected def acquire_lock(capacity, cost)
+    protected def acquire_lock(capacity:, cost:)
       # timestamp in milliseconds
       ts = (Time.now.to_f * 10**3).to_i
 

data/lib/berater/static_limiter.rb

@@ -18,7 +18,7 @@ module Berater
     LUA
     )
 
-    protected def acquire_lock(capacity, cost)
+    protected def acquire_lock(capacity:, cost:)
       if cost == 0
         # utilization check
         count = redis.get(cache_key) || "0"

data/lib/berater/test_mode.rb

@@ -21,7 +21,7 @@ module Berater
 
   class Limiter
     module TestMode
-      def acquire_lock(*)
+      def acquire_lock(**)
         case Berater.test_mode
         when :pass
           Lock.new(Float::INFINITY, 0)
@@ -43,5 +43,7 @@ Berater.singleton_class.prepend Berater::TestMode
 ObjectSpace.each_object(Class).each do |klass|
   next unless klass < Berater::Limiter
 
+  next if klass == Berater::Unlimiter || klass == Berater::Inhibitor
+
   klass.prepend Berater::Limiter::TestMode
 end

data/lib/berater/version.rb

@@ -1,3 +1,3 @@
 module Berater
-  VERSION = "0.11.1"
+  VERSION = "0.12.2"
 end

data/lib/berater.rb

@@ -52,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/berater_spec.rb

@@ -77,18 +77,21 @@ describe Berater do
       end
 
       context 'with a block' do
-        before { Berater.test_mode = :pass }
-
         subject { Berater(:key, capacity, **opts) { 123 } }
 
         it 'creates a limiter and calls limit' do
           expect(klass).to receive(:new).and_return(limiter)
-          expect(limiter).to receive(:limit).and_call_original
+          expect(limiter).to receive(:limit)
+
           subject
         end
 
         it 'yields' do
-          is_expected.to be 123
+          if capacity > 0
+            is_expected.to be 123
+          else
+            expect { subject }.to be_overloaded
+          end
         end
       end
     end

data/spec/limiter_spec.rb

@@ -15,7 +15,9 @@ describe Berater::Limiter do
   end
 
   describe '#capacity=' do
-    subject { Berater::Unlimiter.new(:key, capacity).capacity }
+    subject do
+      Berater::RateLimiter.new(:key, capacity, :second).capacity
+    end
 
     context 'when capacity is numeric' do
       let(:capacity) { 3.5 }
@@ -26,7 +28,7 @@ describe Berater::Limiter do
     context 'when capacity is a stringified numeric' do
       let(:capacity) { '3.5' }
 
-      it 'casts the value gracefully' do
+      it 'casts the value' do
         is_expected.to be capacity.to_f
       end
     end
@@ -45,7 +47,9 @@ describe Berater::Limiter do
 
     context 'with a capacity parameter' do
       it 'overrides the stored value' do
-        is_expected.to receive(:acquire_lock).with(3, anything)
+        is_expected.to receive(:acquire_lock).with(hash_including(
+          capacity: 3,
+        ))
 
         subject.limit(capacity: 3)
       end
@@ -57,15 +61,29 @@ describe Berater::Limiter do
       end
 
       it 'handles stringified numerics gracefully' do
-        is_expected.to receive(:acquire_lock).with(3.5, anything)
+        is_expected.to receive(:acquire_lock).with(hash_including(
+          capacity: 3.5,
+        ))
 
         subject.limit(capacity: '3.5')
       end
     end
 
+    it 'has a default cost' do
+      is_expected.to receive(:acquire_lock).with(hash_including(
+        cost: described_class::DEFAULT_COST,
+      ))
+
+      subject.limit
+    end
+
     context 'with a cost parameter' do
-      it 'overrides the stored value' do
-        is_expected.to receive(:acquire_lock).with(anything, 2)
+      it 'overrides the default value' do
+        expect(described_class::DEFAULT_COST).not_to eq 2
+
+        is_expected.to receive(:acquire_lock).with(hash_including(
+          cost: 2,
+        ))
 
         subject.limit(cost: 2)
       end
@@ -85,12 +103,23 @@ describe Berater::Limiter do
       end
 
       it 'handles stringified numerics gracefully' do
-        is_expected.to receive(:acquire_lock).with(anything, 2.5)
+        is_expected.to receive(:acquire_lock).with(hash_including(
+          cost: 2.5,
+        ))
 
         subject.limit(cost: '2.5')
       end
     end
 
+    it 'passes through arbitrary parameters' do
+      is_expected.to receive(:acquire_lock).with(hash_including(
+        priority: 123,
+        zed: nil,
+      ))
+
+      subject.limit(priority: 123, zed: nil)
+    end
+
     context 'when Berater.redis is nil' do
       let!(:redis) { Berater.redis }
 

data/spec/middleware/fail_open_spec.rb

@@ -1,4 +1,6 @@
 describe Berater::Middleware::FailOpen do
+  it_behaves_like 'a limiter middleware'
+
   let(:limiter) { Berater::Unlimiter.new }
   let(:lock) { limiter.limit }
   let(:error) { Redis::TimeoutError }
@@ -94,6 +96,18 @@ describe Berater::Middleware::FailOpen do
         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

data/spec/middleware/load_shedder_spec.rb

@@ -1,9 +1,9 @@
 describe Berater::Middleware::LoadShedder do
+  it_behaves_like 'a limiter middleware'
+
   describe '#call' do
     subject { described_class.new }
 
-    before { Berater.test_mode = :pass }
-
     it 'yields' do
       expect {|b| subject.call(&b) }.to yield_control
     end
@@ -46,20 +46,6 @@ describe Berater::Middleware::LoadShedder do
       end
     end
 
-    it 'ignores bogus priority options' do
-      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: '123') do |capacity:|
-        expect(capacity).to eq 100
-      end
-    end
-
     it 'works with a fractional priority' do
       subject.call(capacity: 100, priority: 1.5) do |capacity:|
         expect(capacity).to be < 100
@@ -81,6 +67,42 @@ describe Berater::Middleware::LoadShedder do
         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

data/spec/middleware/statsd_spec.rb

@@ -0,0 +1,261 @@
+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
+
+  context do
+    before do
+      Berater.middleware.use described_class, client
+    end
+
+    it_behaves_like 'a limiter middleware'
+  end
+
+  describe '#call' do
+    subject do
+      described_class.new(client, **middleware_opts).call(limiter, **opts, &block)
+    end
+
+    let(:middleware_opts) { {} }
+    let(:limiter) { double(Berater::Limiter, key: :key, capacity: 5) }
+    let(:lock) { double(Berater::Lock, capacity: 4, contention: 2) }
+    let(:opts) { { capacity: limiter.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
+
+    it 'tracks lock capacity' do
+      expect(client).to receive(:gauge).with(
+        'berater.lock.capacity',
+        lock.capacity,
+        Hash
+      )
+    end
+
+    it 'tracks lock contention' do
+      expect(client).to receive(:gauge).with(
+        'berater.lock.contention',
+        lock.contention,
+        Hash
+      )
+    end
+
+    describe 'tags' do
+      def expect_tags_to(matcher)
+        expect(client).to receive(:timing) do |*, tags:|
+          expect(tags).to matcher
+        end
+      end
+
+      context 'with global tags' do
+        let(:middleware_opts) { { tags: { abc: 123 } }}
+
+        it 'incorporates the tags' do
+          expect_tags_to include(middleware_opts[:tags])
+        end
+      end
+
+      context 'with global tag callback' do
+        let(:middleware_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_tags_to include(abc: 123)
+        end
+      end
+
+      context 'when call specific custom tags are passed in' do
+        let(:opts) { { tags: { abc: 123 } } }
+
+        it 'incorporates the tags' do
+          expect_tags_to include(opts[:tags])
+        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.lock.capacity',
+        limiter.capacity,
+        Hash,
+      )
+
+      expect(client).to receive(:gauge).with(
+        'berater.lock.contention',
+        1,
+        Hash,
+      )
+
+      limiter.limit
+    end
+
+    it 'tracks each call' do
+      expect(client).to receive(:gauge).with(
+        'berater.lock.contention',
+        1,
+        Hash,
+      )
+
+      expect(client).to receive(:gauge).with(
+        'berater.lock.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',
+            anything,
+          )
+
+          limiter.limit
+        end
+
+        it 'does not track lock-based stats' do
+          expect(client).not_to receive(:gauge).with(
+            /berater.lock/,
+            any_args,
+          )
+
+          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/,
+            any_args,
+          )
+
+          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 'does not track lock-based stats' do
+        expect(client).not_to receive(:gauge).with(
+          /berater.lock/,
+          any_args,
+        )
+      end
+
+      it 'does not track the exception' do
+        expect(client).not_to receive(:increment).with(
+          'berater.limiter.error',
+          anything,
+        )
+      end
+    end
+  end
+end

data/spec/middleware/trace_spec.rb

@@ -0,0 +1,58 @@
+describe Berater::Middleware::Trace do
+  before { Datadog.tracer.enabled = false }
+
+  it_behaves_like 'a limiter middleware'
+
+  let(:limiter) { Berater::Unlimiter.new }
+  let(:span) { double(Datadog::Span, set_tag: nil) }
+  let(:tracer) { double(Datadog::Tracer) }
+
+  before do
+    allow(tracer).to receive(:trace) {|&b| b.call(span) }
+  end
+
+  context 'with a provided tracer' do
+    let(:instance) { described_class.new(tracer: tracer) }
+
+    it 'traces' do
+      expect(tracer).to receive(:trace).with(/Berater/)
+      expect(span).to receive(:set_tag).with(/capacity/, Numeric)
+
+      instance.call(limiter) {}
+    end
+
+    it 'yields' do
+      expect {|b| instance.call(limiter, &b) }.to yield_control
+    end
+
+    context 'when an exception is raised' do
+      it 'tags the span and raises' do
+        expect(span).to receive(:set_tag).with('error', 'IOError')
+
+        expect {
+          instance.call(limiter) { raise IOError }
+        }.to raise_error(IOError)
+      end
+    end
+
+    context 'when an Overloaded exception is raised' do
+      let(:limiter) { Berater::Inhibitor.new }
+
+      it 'tags the span as overloaded and raises' do
+        expect(span).to receive(:set_tag).with('overloaded', true)
+
+        expect {
+          instance.call(limiter) { raise Berater::Overloaded }
+        }.to be_overloaded
+      end
+    end
+  end
+
+  context 'with the default tracer' do
+    it 'uses Datadog.tracer' do
+      expect(Datadog).to receive(:tracer).and_return(tracer)
+
+      described_class.new.call(limiter) {}
+    end
+  end
+end

data/spec/test_mode_spec.rb

@@ -9,8 +9,13 @@ describe Berater::TestMode do
     end
 
     it 'prepends Limiter subclasses' do
-      expect(Berater::Unlimiter.ancestors).to include(Berater::Limiter::TestMode)
-      expect(Berater::Inhibitor.ancestors).to include(Berater::Limiter::TestMode)
+      expect(Berater::ConcurrencyLimiter.ancestors).to include(Berater::Limiter::TestMode)
+      expect(Berater::RateLimiter.ancestors).to include(Berater::Limiter::TestMode)
+    end
+
+    it 'does not modify Unlimiter or Inhibitor' do
+      expect(Berater::Unlimiter.ancestors).not_to include(Berater::Limiter::TestMode)
+      expect(Berater::Inhibitor.ancestors).not_to include(Berater::Limiter::TestMode)
     end
 
     it 'preserves the original functionality via super' do
@@ -19,6 +24,8 @@ describe Berater::TestMode do
   end
 
   describe '.test_mode' do
+    let(:limiter) { Berater::ConcurrencyLimiter.new(:key, 1) }
+
     it 'can be turned on' do
       Berater.test_mode = :pass
       expect(Berater.test_mode).to be :pass
@@ -37,7 +44,6 @@ describe Berater::TestMode do
     end
 
     it 'works no matter when limiter was created' do
-      limiter = Berater::Unlimiter.new
       expect(limiter).not_to be_overloaded
 
       Berater.test_mode = :fail
@@ -47,7 +53,7 @@ describe Berater::TestMode do
     it 'supports a generic expectation' do
       Berater.test_mode = :pass
       expect_any_instance_of(Berater::Limiter).to receive(:limit)
-      Berater::Unlimiter.new.limit
+      limiter.limit
     end
   end
 
@@ -94,7 +100,17 @@ describe Berater::TestMode do
       it_behaves_like 'it is not overloaded'
     end
 
-    it_behaves_like 'it supports test_mode'
+    context 'when test_mode = :pass' do
+      before { Berater.test_mode = :pass }
+
+      it_behaves_like 'it is not overloaded'
+    end
+
+    context 'when test_mode = :fail' do
+      before { Berater.test_mode = :fail }
+
+      it_behaves_like 'it is not overloaded'
+    end
   end
 
   describe 'Inhibitor' do
@@ -106,7 +122,17 @@ describe Berater::TestMode do
       it_behaves_like 'it is overloaded'
     end
 
-    it_behaves_like 'it supports test_mode'
+    context 'when test_mode = :pass' do
+      before { Berater.test_mode = :pass }
+
+      it_behaves_like 'it is overloaded'
+    end
+
+    context 'when test_mode = :fail' do
+      before { Berater.test_mode = :fail }
+
+      it_behaves_like 'it is overloaded'
+    end
   end
 
   describe 'RateLimiter' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: berater
 version: !ruby/object:Gem::Version
-  version: 0.11.1
+  version: 0.12.2
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-25 00:00:00.000000000 Z
+date: 2022-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: meddleware
@@ -80,6 +80,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ddtrace
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !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
@@ -153,6 +181,8 @@ files:
 - lib/berater/middleware.rb
 - lib/berater/middleware/fail_open.rb
 - lib/berater/middleware/load_shedder.rb
+- lib/berater/middleware/statsd.rb
+- lib/berater/middleware/trace.rb
 - lib/berater/rate_limiter.rb
 - lib/berater/rspec.rb
 - lib/berater/rspec/matchers.rb
@@ -172,6 +202,8 @@ files:
 - spec/matchers_spec.rb
 - spec/middleware/fail_open_spec.rb
 - spec/middleware/load_shedder_spec.rb
+- spec/middleware/statsd_spec.rb
+- spec/middleware/trace_spec.rb
 - spec/middleware_spec.rb
 - spec/rate_limiter_spec.rb
 - spec/riddle_spec.rb
@@ -205,6 +237,8 @@ summary: Berater
 test_files:
 - spec/rate_limiter_spec.rb
 - spec/middleware/load_shedder_spec.rb
+- spec/middleware/statsd_spec.rb
+- spec/middleware/trace_spec.rb
 - spec/middleware/fail_open_spec.rb
 - spec/matchers_spec.rb
 - spec/dsl_refinement_spec.rb