berater 0.11.1 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b657c7eb3a69e868416ad2d149d6c35ab13989e77a16ece23217deaaa9fafb6
-  data.tar.gz: 30835e7c247da37543ea118067d0b61d16080399ff6b53e86783c53a94b8d560
+  metadata.gz: 72cc5fcf9c68fff6dd3988ff85897b38d6fdcff21c0e6f94d3ec098ca8b35fc7
+  data.tar.gz: 49144f0dee2d7197740d39b9da365f9d959c730b7ece1ae761948ec9263ada75
 SHA512:
-  metadata.gz: '04481aa9c3097930f66eb29c6e19e650309b882cf835c1f36cb3fa58524b957d1194b5acc6a83f9fdfd33b73f888261ff3cc3171d730fd9781d9cf768b2b0768'
-  data.tar.gz: e0cd1a220a418face72685b44d23dff0040dc5f3d94b8c0d82769123a1c387e709702e8f093cc9c0f600d002ea4c848ebd4f0a2e38a4368e743104fbee597f9d
+  metadata.gz: 401a193c358a80098f1250053983d8f1a362cd14649156a036deedeb461fd70202743764d375b04a2b6b4fb08c795ec61d013e1be342626a2c8aad7dab2cb259
+  data.tar.gz: 55498f8b1a6bd70a64ed9053b80bc9c95b0d60043f073c302d48bb79b51677d7a3c235c07f35cc51dacec067d0c2cc8dcf972e37fb9e9baae126f69fa8aacb4f

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,82 @@
+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.merge(overloaded: !lock),
+        )
+
+        @client.gauge(
+          'berater.limiter.capacity',
+          limiter.capacity,
+          tags: tags,
+        )
+
+        if lock && 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
+
+        if error
+          if error.is_a?(Berater::Overloaded)
+            # 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)
+            )
+          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

@@ -2,5 +2,6 @@ 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.11.1"
+  VERSION = "0.12.0"
 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

data/spec/middleware/fail_open_spec.rb

@@ -94,6 +94,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

@@ -2,8 +2,6 @@ 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
@@ -46,20 +44,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 +65,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,227 @@
+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,
+          overloaded: false,
+        },
+      )
+    end
+
+    it 'tracks limiter capacity' do
+      expect(client).to receive(:gauge).with(
+        'berater.limiter.capacity',
+        limiter.capacity,
+        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: error.to_s),
+        )
+
+        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',
+            Hash,
+          )
+
+          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 limit call' do
+        expect(client).to receive(:timing).with(
+          'berater.limiter.limit',
+          Float,
+          tags: hash_including(overloaded: true),
+        )
+      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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: berater
 version: !ruby/object:Gem::Version
-  version: 0.11.1
+  version: 0.12.0
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-25 00:00:00.000000000 Z
+date: 2021-11-03 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
@@ -153,6 +167,7 @@ files:
 - 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
@@ -172,6 +187,7 @@ files:
 - 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
@@ -205,6 +221,7 @@ 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