berater 0.10.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e691d2d3cdc8f002e0e222c24d2e6f9a52ccb1dac7edaa92ea232ecce17fb77e
-  data.tar.gz: 5d302fff5fd063f34a94b1aae1b9b2e118b18efbe2315b4591405346f1dbc70c
+  metadata.gz: f57ab651eeb34e6a0bb7b889fefa9c13d1d1fc5b6e834bc2b9a6e0ba7b74a8e2
+  data.tar.gz: 8112aa91ae48872132d8222a07f03dce42ff6f5ff26a3bf17906a389ba675ec9
 SHA512:
-  metadata.gz: 88b8e91557729601336b5235fbcc9710c79aa2f68ff393a09b5c55a1c994cef7371ed4a310c8038b07bdfc5f35d6b367ad7e1fc886c3f7c8579130808af5386b
-  data.tar.gz: 2600478d9761b14abbc2ef6c1a38b2e5b5e7476a40c6955f110746d4a90e31baabbda8d6571dcaf7d4e457d0cc19f120e84cba8915ded01b2a680111806d4400
+  metadata.gz: 17ae5da54dcf9535d4afe93d7e239ddc1fefaedf3419883cfa22d1f55c0c0aa7a9365986509e8e54e37c08c258068db4a76064dcc6af3f654e170b3efc8c1cd0
+  data.tar.gz: 04b1e7553e86107bbc91fc486b7b0ae099f5575b8654f7800f2a1c281b7b8bfde1e63df2378f03fcb4a9864b15b6a5de610bb6e7a1ce4d4b8e53898d9f4f0869

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?

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/version.rb

@@ -1,3 +1,3 @@
 module Berater
-  VERSION = "0.10.1"
+  VERSION = "0.11.0"
 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/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

@@ -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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: berater
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.11.0
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-18 00:00:00.000000000 Z
+date: 2021-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: meddleware
@@ -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.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/fail_open_spec.rb
 - spec/matchers_spec.rb
 - spec/dsl_refinement_spec.rb
 - spec/test_mode_spec.rb