berater 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: defd1ba585ef0f8b5ff8f2f388604c344571fe4fe887f7ca44d03d57c7ce20f8
-  data.tar.gz: 729865914aa2f72c4b61a16cbcd29f12d86d034a04f9c15f3c48c53a7611c5cf
+  metadata.gz: 3780da104c79084b2c3b348363a5f763c42d9d936dc218e68df90cdbbc223cfe
+  data.tar.gz: a3b7e7af7b3a764f97c013cb642eccf6d71ad825df459d32722a4e312ca2cdd8
 SHA512:
-  metadata.gz: 864cc51b0eaf4c1767a36580331a27dfb20a2e0eeaaff805d2d188078cf9500ccfbf0d08e331cd06efb238b0c58dca9f67cde27025d1e87ebec8ef4ae234c683
-  data.tar.gz: aa303e6a58f1d79b0471d9d31bb5aa8835bd7f253c26f7930c6253e7801e154b9c26ce977529e70a7de647d9967caa6753963608828e721f7d1cfe5523805f41
+  metadata.gz: 364a70d42009b4c80b7235cbbc736f8c074f309abfa529f494f2fd01959e9b5ffb2bbd08ad3a39b12b0565abb8435bf86cd59b774055c4fbd845ba7d2f0c798b
+  data.tar.gz: 92271042126ccc8b70a3a95f6fa530a8f36dceddaf7cc8de3ef9eb1ac861fcd9f7d10e066d27ac4d7bb807d5f43741f78aaf4b9b43a970bc159a5b2a3142f73a

data/lib/berater/middleware/load_shedder.rb

@@ -23,13 +23,14 @@ module Berater
           priority = Float(priority) rescue nil
         end
 
-        unless PRIORITY_RANGE.include?(priority)
-          return capacity
-        end
+        if PRIORITY_RANGE.include?(priority)
+          # priority 1 stays at 100%, 2 scales down to 90%, 5 to 60%
+          factor = 1 - (priority - 1) * 0.1
 
-        # priority 1 stays at 100%, 2 scales down to 90%, 5 to 60%
-        factor = 1 - (priority - 1) * 0.1
-        (capacity * factor).floor
+          (capacity * factor).floor
+        else
+          capacity
+        end
       end
     end
   end

data/lib/berater/middleware/trace.rb

@@ -1,5 +1,3 @@
-require 'ddtrace'
-
 module Berater
   module Middleware
     class Trace
@@ -8,7 +6,7 @@ module Berater
       end
 
       def call(limiter, **)
-        tracer.trace('Berater.limit') do |span|
+        tracer&.trace('Berater') do |span|
           begin
             lock = yield
           rescue Exception => error
@@ -34,7 +32,7 @@ module Berater
       private
 
       def tracer
-        @tracer || Datadog.tracer
+        @tracer || (defined?(Datadog::Tracing) && Datadog::Tracing) || (defined?(Datadog) && Datadog.tracer)
       end
     end
   end

data/lib/berater/mutex.rb

@@ -0,0 +1,28 @@
+module Berater
+  module Mutex
+    def self.included(base)
+      # add class methods
+      base.instance_eval do
+        def synchronize(subkey = nil, **opts, &block)
+          key = [ 'Mutex', name&.delete(':') || object_id, subkey ].compact.join(':')
+
+          Berater::ConcurrencyLimiter(key, 1, **mutex_options.merge(opts)) do
+            yield if block_given?
+          end
+        end
+
+        def mutex_options(**kwargs)
+          (@mutex_options ||= {}).update(kwargs)
+        end
+      end
+    end
+
+    def synchronize(...)
+      self.class.synchronize(...)
+    end
+
+    def self.extend_object(base)
+      included(base)
+    end
+  end
+end

data/lib/berater/version.rb

@@ -1,3 +1,3 @@
 module Berater
-  VERSION = "0.13.0"
+  VERSION = "0.14.0"
 end

data/lib/berater.rb

@@ -3,11 +3,13 @@ require 'berater/limiter_set'
 require 'berater/lock'
 require 'berater/lua_script'
 require 'berater/middleware'
+require 'berater/mutex'
 require 'berater/utils'
 require 'berater/version'
 require 'meddleware'
 
 module Berater
+  include Meddleware
   extend self
 
   class Overloaded < StandardError; end
@@ -22,12 +24,6 @@ module Berater
     @limiters ||= LimiterSet.new
   end
 
-  def middleware(&block)
-    (@middleware ||= Meddleware.new).tap do
-      @middleware.instance_eval(&block) if block_given?
-    end
-  end
-
   def new(key, capacity, **opts)
     args = []
 

data/spec/limiter_spec.rb

@@ -220,9 +220,7 @@ describe Berater::Limiter do
     end
 
     context 'with custom limiter' do
-      MyLimiter = Class.new(Berater::Unlimiter)
-
-      let(:klass) { MyLimiter }
+      let(:klass) { MyLimiter = Class.new(Berater::Unlimiter) }
 
       it 'adds Berater prefix' do
         is_expected.to eq 'Berater:MyLimiter:key'
@@ -242,12 +240,10 @@ describe Berater::Limiter do
     end
 
     context 'with custom limiter' do
-      MyLimiter = Class.new(Berater::Unlimiter)
-
-      let(:klass) { MyLimiter }
+      let(:klass) { MyOtherLimiter = Class.new(Berater::Unlimiter) }
 
       it 'adds Berater prefix' do
-        is_expected.to eq 'Berater:MyLimiter:key'
+        is_expected.to eq 'Berater:MyOtherLimiter:key'
       end
     end
   end

data/spec/middleware/trace_spec.rb

@@ -1,30 +1,61 @@
+require 'ddtrace'
+
 describe Berater::Middleware::Trace do
-  before { Datadog.tracer.enabled = false }
+  before do
+    allow(tracer).to receive(:trace).and_yield(span)
+  end
 
   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) }
+  if defined?(Datadog::Tracing)
+    before { Datadog.configure { |c| c.tracing.enabled = false } }
+
+    let(:span) { double(Datadog::Tracing::SpanOperation, set_tag: nil) }
+    let(:tracer) { double(Datadog::Tracing::Tracer) }
+    let(:ddtracer) { Datadog::Tracing }
+  else
+    before { Datadog.tracer.enabled = false }
+
+    let(:span) { double(Datadog::Span, set_tag: nil) }
+    let(:tracer) { double(Datadog::Tracer) }
+    let(:ddtracer) { Datadog.tracer }
   end
 
-  context 'with a provided tracer' do
-    let(:instance) { described_class.new(tracer: tracer) }
+  describe '#tracer' do
+    subject { instance.send(:tracer) }
 
-    it 'traces' do
-      expect(tracer).to receive(:trace).with(/Berater/)
-      expect(span).to receive(:set_tag).with(/capacity/, Numeric)
+    let(:instance) { described_class.new }
+
+    it 'defaults to Datadog.tracer' do
+      is_expected.to be ddtracer
+    end
+
+    context 'when provided a tracer' do
+      let(:instance) { described_class.new(tracer: tracer) }
 
-      instance.call(limiter) {}
+      it { is_expected.to be tracer }
     end
+  end
+
+  describe '#call' do
+    let(:instance) { described_class.new(tracer: tracer) }
 
     it 'yields' do
       expect {|b| instance.call(limiter, &b) }.to yield_control
     end
 
+    context 'when a Berater::Overloaded exception is raised' do
+      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
+
     context 'when an exception is raised' do
       it 'tags the span and raises' do
         expect(span).to receive(:set_tag).with('error', 'IOError')
@@ -34,25 +65,32 @@ describe Berater::Middleware::Trace do
         }.to raise_error(IOError)
       end
     end
+  end
+
+  context 'when used as middleware' do
+    before do
+      Berater.middleware.use described_class, tracer: tracer
+    end
 
-    context 'when an Overloaded exception is raised' do
+    it 'traces' do
+      expect(tracer).to receive(:trace).with('Berater')
+      expect(span).to receive(:set_tag).with('key', limiter.key)
+      expect(span).to receive(:set_tag).with('capacity', Numeric)
+      expect(span).to receive(:set_tag).with('contention', Numeric)
+
+      limiter.limit
+    end
+
+    context 'when limiter is overloaded' 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 }
+          limiter.limit
         }.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/mutex_spec.rb

@@ -0,0 +1,110 @@
+describe Berater::Mutex do
+  let(:klass) do
+    Class.new do
+      include Berater::Mutex
+    end
+  end
+
+  describe 'synchronize' do
+    it { expect(klass).to respond_to(:synchronize) }
+    it { expect(klass.new).to respond_to(:synchronize) }
+
+    it { expect { |block| klass.synchronize(&block) }.to yield_control }
+
+    it 'returns the blocks value' do
+      res = klass.synchronize { 123 }
+      expect(res).to be 123
+    end
+
+    it 'still works and returns nil without a block' do
+      expect(klass.synchronize).to be nil
+    end
+
+    it 'does not allow simultaneous calls' do
+      expect {
+        klass.synchronize do
+          klass.synchronize
+        end
+      }.to be_overloaded
+    end
+
+    it 'allows simultaneous calls with different sub-keys' do
+      expect {
+        klass.synchronize(:a) do
+          klass.synchronize(:b)
+        end
+      }.not_to raise_error
+    end
+
+    it 'allows consecutive calls' do
+      expect {
+        3.times { klass.synchronize }
+      }.not_to raise_error
+    end
+
+    describe 'the instance method' do
+      it 'is a pass through to the class method' do
+        expect(klass).to receive(:synchronize)
+        klass.new.synchronize
+      end
+
+      it 'works with arguments' do
+        key = 'key'
+        opts = { timeout: 1 }
+        block = ->{}
+
+        expect(klass).to receive(:synchronize) do |this_key, **these_opts, &this_block|
+          expect(this_key).to be key
+          expect(these_opts).to eq opts
+          expect(this_block).to be block
+        end
+
+        klass.new.synchronize(key, **opts, &block)
+      end
+    end
+  end
+
+  describe '.mutex_options' do
+    subject { klass.mutex_options }
+
+    it { expect(klass).to respond_to(:mutex_options) }
+    it { is_expected.to be_a Hash }
+    it { is_expected.to be_empty }
+    it { expect(klass.new).not_to respond_to(:mutex_options) }
+
+    context 'when mutex_options are set' do
+      let(:klass) do
+        Class.new do
+          include Berater::Mutex
+
+          mutex_options timeout: 1
+        end
+      end
+
+      it { is_expected.to eq(timeout: 1) }
+
+      it 'uses mutex_options during synchronize' do
+        expect(Berater::ConcurrencyLimiter).to receive(:new).and_wrap_original do |original, *args, **kwargs|
+          expect(kwargs).to eq(subject)
+          original.call(*args, **kwargs)
+        end
+
+        klass.synchronize
+      end
+    end
+  end
+
+  describe 'when extended rather than included' do
+    let(:klass) do
+      Class.new do
+        extend Berater::Mutex
+      end
+    end
+
+    it { expect(klass).to respond_to(:synchronize) }
+    it { expect(klass).to respond_to(:mutex_options) }
+
+    it { expect(klass.new).not_to respond_to(:synchronize) }
+    it { expect(klass.new).not_to respond_to(:mutex_options) }
+  end
+end

data/spec/test_mode_spec.rb

@@ -171,4 +171,13 @@ describe Berater::TestMode do
     it_behaves_like 'it supports test_mode'
   end
 
+  describe 'Mutex' do
+    let(:klass) { Class.new { include Berater::Mutex } }
+
+    context 'when test_mode = :fail' do
+      before { Berater.test_mode = :fail }
+
+      it { expect { klass.synchronize }.to be_overloaded }
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: berater
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.14.0
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-04 00:00:00.000000000 Z
+date: 2022-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: meddleware
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
@@ -183,6 +183,7 @@ files:
 - lib/berater/middleware/load_shedder.rb
 - lib/berater/middleware/statsd.rb
 - lib/berater/middleware/trace.rb
+- lib/berater/mutex.rb
 - lib/berater/rate_limiter.rb
 - lib/berater/rspec.rb
 - lib/berater/rspec/matchers.rb
@@ -205,6 +206,7 @@ files:
 - spec/middleware/statsd_spec.rb
 - spec/middleware/trace_spec.rb
 - spec/middleware_spec.rb
+- spec/mutex_spec.rb
 - spec/rate_limiter_spec.rb
 - spec/riddle_spec.rb
 - spec/static_limiter_spec.rb
@@ -230,28 +232,29 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Berater
 test_files:
-- spec/rate_limiter_spec.rb
+- spec/berater_spec.rb
+- spec/concurrency_limiter_spec.rb
+- spec/dsl_refinement_spec.rb
+- spec/dsl_spec.rb
+- spec/inhibitor_spec.rb
+- spec/limiter_set_spec.rb
+- 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/trace_spec.rb
-- spec/middleware/fail_open_spec.rb
-- spec/matchers_spec.rb
-- spec/dsl_refinement_spec.rb
-- spec/test_mode_spec.rb
 - spec/middleware_spec.rb
-- spec/dsl_spec.rb
-- spec/lua_script_spec.rb
-- spec/concurrency_limiter_spec.rb
+- spec/mutex_spec.rb
+- spec/rate_limiter_spec.rb
 - spec/riddle_spec.rb
-- spec/limiter_set_spec.rb
-- spec/utils_spec.rb
-- spec/berater_spec.rb
-- spec/limiter_spec.rb
 - spec/static_limiter_spec.rb
-- spec/inhibitor_spec.rb
+- spec/test_mode_spec.rb
 - spec/unlimiter_spec.rb
+- spec/utils_spec.rb