berater 0.9.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 476b59e3f1e27908f5c8a5097087e6c8c2384531e1284d79b9d89a73fbbb5840
-  data.tar.gz: de50fdcab6ea7dc9520fcf1aefdd07b1f8775c0ce96a30e3f1d45b6ccfb7b00f
+  metadata.gz: 8b657c7eb3a69e868416ad2d149d6c35ab13989e77a16ece23217deaaa9fafb6
+  data.tar.gz: 30835e7c247da37543ea118067d0b61d16080399ff6b53e86783c53a94b8d560
 SHA512:
-  metadata.gz: 2446e64f528a8ef1d37791922d37cddcebdf702f3c5beff2ef7ea9d611ce4cc6d6c40ac42e1ea826987a2eb2ceea3ddf97e420bb7369686b8239b260a1725c55
-  data.tar.gz: 23dccad7e02cc425631ceeb1dfbc6960b94ac92c523d840a991917af02caaf39a7befc5887fe45631f565ddb2eddb4850e557348ab29427d3cbae1db89124c3c
+  metadata.gz: '04481aa9c3097930f66eb29c6e19e650309b882cf835c1f36cb3fa58524b957d1194b5acc6a83f9fdfd33b73f888261ff3cc3171d730fd9781d9cf768b2b0768'
+  data.tar.gz: e0cd1a220a418face72685b44d23dff0040dc5f3d94b8c0d82769123a1c387e709702e8f093cc9c0f600d002ea4c848ebd4f0a2e38a4368e743104fbee597f9d

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
@@ -99,11 +120,16 @@ module Berater
     end
 
     class << self
-      def new(*)
+      def new(*args, **kwargs)
         # can only call via subclass
         raise NoMethodError if self == Berater::Limiter
 
-        super
+        if RUBY_VERSION < '3' && kwargs.empty?
+          # avoid ruby 2 problems with empty hashes
+          super(*args)
+        else
+          super
+        end
       end
 
       def cache_key(key)
@@ -116,6 +142,7 @@ module Berater
       def inherited(subclass)
         # automagically create convenience method
         name = subclass.to_s.split(':')[-1]
+
         Berater.define_singleton_method(name) do |*args, **opts, &block|
           Berater::Utils.convenience_fn(subclass, *args, **opts, &block)
         end

data/lib/berater/lock.rb

@@ -20,7 +20,7 @@ module Berater
 
       @released_at = Time.now
       @release_fn&.call
-      nil
+      true
     end
 
   end

data/lib/berater/lua_script.rb

@@ -1,4 +1,5 @@
 require 'digest'
+require 'redis'
 
 module Berater
   class LuaScript
@@ -6,11 +7,11 @@ module Berater
     attr_reader :source
 
     def initialize(source)
-      @source = source
+      @source = source.dup.freeze
     end
 
     def sha
-      @sha ||= Digest::SHA1.hexdigest(minify)
+      @sha ||= Digest::SHA1.hexdigest(minify).freeze
     end
 
     def eval(redis, *args)
@@ -44,7 +45,7 @@ module Berater
     def minify
       # trim comments (whole line and partial)
       # and whitespace (prefix and empty lines)
-      @minify ||= source.gsub(/^\s*--.*\n|\s*--.*|^\s*|^$\n/, '').chomp
+      @minify ||= source.gsub(/^\s*--.*\n|\s*--.*|^\s*|^$\n/, '').chomp.freeze
     end
 
   end

data/lib/berater/middleware/fail_open.rb

@@ -0,0 +1,41 @@
+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|
+          # 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,31 @@
+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)
+        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.rb

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

data/lib/berater/utils.rb

@@ -44,12 +44,7 @@ module Berater
 
     def convenience_fn(klass, *args, **opts, &block)
       limiter = klass.new(*args, **opts)
-      if block_given?
-        limiter.limit(&block)
-      else
-        limiter
-      end
+      block ? limiter.limit(&block) : limiter
     end
-
   end
 end

data/lib/berater/version.rb

@@ -1,3 +1,3 @@
 module Berater
-  VERSION = '0.9.0'
+  VERSION = "0.11.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'

data/spec/berater_spec.rb

@@ -59,8 +59,8 @@ describe Berater do
       end
 
       it 'accepts an optional redis parameter' do
-        redis = double('Redis')
-        limiter = Berater.new(:key, capacity, opts.merge(redis: redis))
+        redis = double(Redis)
+        limiter = Berater.new(:key, capacity, **opts.merge(redis: redis))
         expect(limiter.redis).to be redis
       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,32 @@ describe Berater::Limiter do
     end
   end
 
+  describe '#capacity=' do
+    subject { Berater::Unlimiter.new(:key, capacity).capacity }
+
+    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 gracefully' 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 +55,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 +83,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
@@ -79,6 +117,16 @@ describe Berater::Limiter do
         expect { limiter.limit }.to raise_error(RuntimeError)
       end
     end
+
+    it 'releases the lock even when limited code raises an error' do
+      lock = Berater::Lock.new(Float::INFINITY, 0)
+      expect(subject).to receive(:acquire_lock).and_return(lock)
+      expect(lock).to receive(:release)
+
+      expect {
+        subject.limit { raise 'fail' }
+      }.to raise_error(RuntimeError)
+    end
   end
 
   describe '#==' do

data/spec/lua_script_spec.rb

@@ -93,5 +93,4 @@ describe Berater::LuaScript do
       it { subject }
     end
   end
-
 end

data/spec/middleware/fail_open_spec.rb

@@ -0,0 +1,184 @@
+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
+  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,130 @@
+describe Berater::Middleware::LoadShedder do
+  describe '#call' do
+    subject { described_class.new }
+
+    before { Berater.test_mode = :pass }
+
+    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 '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
+      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
+  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_spec.rb

@@ -1,5 +1,5 @@
 class Meddler
-  def call(*)
+  def call(*args, **kwargs)
     yield
   end
 end
@@ -73,18 +73,18 @@ describe 'Berater.middleware' do
 
     context 'when middleware meddles' do
       it 'can change the capacity' do
-        expect(middleware).to receive(:call) do |limiter, opts, &block|
+        expect(middleware).to receive(:call) do |limiter, **opts, &block|
           opts[:capacity] = 0
-          block.call
+          block.call(limiter, **opts)
         end
 
         expect { limiter.limit }.to be_overloaded
       end
 
       it 'can change the cost' do
-        expect(middleware).to receive(:call) do |limiter, opts, &block|
+        expect(middleware).to receive(:call) do |limiter, **opts, &block|
           opts[:cost] = 2
-          block.call
+          block.call(limiter, **opts)
         end
 
         expect { limiter.limit }.to be_overloaded
@@ -93,8 +93,8 @@ describe 'Berater.middleware' do
       it 'can change the limiter' do
         other_limiter = Berater::Inhibitor.new
 
-        expect(middleware).to receive(:call) do |limiter, opts, &block|
-          block.call other_limiter, opts
+        expect(middleware).to receive(:call) do |limiter, **opts, &block|
+          block.call(other_limiter, **opts)
         end
         expect(other_limiter).to receive(:acquire_lock).and_call_original
 
@@ -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.9.0
+  version: 0.11.1
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-09 00:00:00.000000000 Z
+date: 2021-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: meddleware
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: benchmark
   requirement: !ruby/object:Gem::Requirement
@@ -150,6 +150,9 @@ 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/rate_limiter.rb
 - lib/berater/rspec.rb
 - lib/berater/rspec/matchers.rb
@@ -167,6 +170,8 @@ 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_spec.rb
 - spec/rate_limiter_spec.rb
 - spec/riddle_spec.rb
@@ -193,12 +198,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+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/fail_open_spec.rb
 - spec/matchers_spec.rb
 - spec/dsl_refinement_spec.rb
 - spec/test_mode_spec.rb