berater 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72cc5fcf9c68fff6dd3988ff85897b38d6fdcff21c0e6f94d3ec098ca8b35fc7
-  data.tar.gz: 49144f0dee2d7197740d39b9da365f9d959c730b7ece1ae761948ec9263ada75
+  metadata.gz: defd1ba585ef0f8b5ff8f2f388604c344571fe4fe887f7ca44d03d57c7ce20f8
+  data.tar.gz: 729865914aa2f72c4b61a16cbcd29f12d86d034a04f9c15f3c48c53a7611c5cf
 SHA512:
-  metadata.gz: 401a193c358a80098f1250053983d8f1a362cd14649156a036deedeb461fd70202743764d375b04a2b6b4fb08c795ec61d013e1be342626a2c8aad7dab2cb259
-  data.tar.gz: 55498f8b1a6bd70a64ed9053b80bc9c95b0d60043f073c302d48bb79b51677d7a3c235c07f35cc51dacec067d0c2cc8dcf972e37fb9e9baae126f69fa8aacb4f
+  metadata.gz: 864cc51b0eaf4c1767a36580331a27dfb20a2e0eeaaff805d2d188078cf9500ccfbf0d08e331cd06efb238b0c58dca9f67cde27025d1e87ebec8ef4ae234c683
+  data.tar.gz: aa303e6a58f1d79b0471d9d31bb5aa8835bd7f253c26f7930c6253e7801e154b9c26ce977529e70a7de647d9967caa6753963608828e721f7d1cfe5523805f41

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

@@ -10,7 +10,7 @@ module Berater
         duration = -Process.clock_gettime(Process::CLOCK_MONOTONIC)
         lock = yield
       rescue Exception => error
-        # note exception and propagate
+        # capture exception for reporting, then propagate
         raise
       ensure
         duration += Process.clock_gettime(Process::CLOCK_MONOTONIC)
@@ -21,7 +21,7 @@ module Berater
         @client.timing(
           'berater.limiter.limit',
           duration,
-          tags: tags.merge(overloaded: !lock),
+          tags: tags,
         )
 
         @client.gauge(
@@ -30,31 +30,36 @@ module Berater
           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,
+        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)
-            # overloaded, so contention >= capacity
-            @client.gauge(
-              'berater.limiter.contention',
-              limiter.capacity,
+            @client.increment(
+              'berater.limiter.overloaded',
               tags: tags,
             )
           else
             @client.increment(
               'berater.limiter.error',
-              tags: tags.merge(type: error.class.to_s)
+              tags: tags.merge(type: error.class.to_s.gsub('::', '_'))
             )
           end
         end
@@ -68,14 +73,19 @@ module Berater
           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)
+        # append global custom tags
+        if @tags
+          if @tags.respond_to?(:call)
+            tags.merge!(@tags.call(limiter, **opts) || {})
+          else
+            tags.merge!(@tags)
+          end
         end
 
-        tags.merge!(opts.fetch(:tags, {}))
+        # append call specific custom tags
+        tags.merge!(opts[:tags]) if opts[:tags]
+
+        tags
       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

@@ -3,5 +3,6 @@ module Berater
     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.12.0"
+  VERSION = "0.13.0"
 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

@@ -47,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
@@ -59,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
@@ -87,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 }

data/spec/middleware/load_shedder_spec.rb

@@ -1,4 +1,6 @@
 describe Berater::Middleware::LoadShedder do
+  it_behaves_like 'a limiter middleware'
+
   describe '#call' do
     subject { described_class.new }
 

data/spec/middleware/statsd_spec.rb

@@ -9,13 +9,23 @@ describe Berater::Middleware::Statsd do
     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 { described_class.new(client, **client_opts).call(limiter, **opts, &block) }
+    subject do
+      described_class.new(client, **middleware_opts).call(limiter, **opts, &block)
+    end
 
-    let(:client_opts) { {} }
+    let(:middleware_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(:opts) { { capacity: limiter.capacity, cost: 1 } }
     let(:block) { lambda { lock } }
 
     after { subject }
@@ -31,7 +41,6 @@ describe Berater::Middleware::Statsd do
         tags: {
           key: limiter.key,
           limiter: String,
-          overloaded: false,
         },
       )
     end
@@ -44,39 +53,63 @@ describe Berater::Middleware::Statsd do
       )
     end
 
-    context 'when custom tags are passed in' do
-      let(:opts) { { tags: { abc: 123 } } }
+    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
 
-      it 'incorporates the tags' do
+    describe 'tags' do
+      def expect_tags_to(matcher)
         expect(client).to receive(:timing) do |*, tags:|
-          expect(tags).to include(opts[:tags])
+          expect(tags).to matcher
         end
       end
-    end
 
-    context 'with global tags' do
-      let(:client_opts) { { tags: { abc: 123 } }}
+      context 'with global tags' do
+        let(:middleware_opts) { { tags: { abc: 123 } }}
 
-      it 'incorporates the tags' do
-        expect(client).to receive(:timing) do |*, tags:|
-          expect(tags).to include(client_opts[:tags])
+        it 'incorporates the tags' do
+          expect_tags_to include(middleware_opts[:tags])
         end
       end
-    end
 
-    context 'with global tag callback' do
-      let(:client_opts) { { tags: callback }}
-      let(:callback) { double(Proc) }
+      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 'calls the callback' do
-        expect(callback).to receive(:call).with(limiter, **opts)
+        it 'incorporates the tags' do
+          expect(callback).to receive(:call).and_return({ abc: 123 })
+          expect_tags_to include(abc: 123)
+        end
       end
 
-      it 'incorporates the tags' do
-        expect(callback).to receive(:call).and_return({ abc: 123 })
+      context 'when call specific custom tags are passed in' do
+        let(:opts) { { tags: { abc: 123 } } }
 
-        expect(client).to receive(:timing) do |*, tags:|
-          expect(tags).to include(abc: 123)
+        it 'incorporates the tags' do
+          expect_tags_to include(opts[:tags])
         end
       end
     end
@@ -101,7 +134,13 @@ describe Berater::Middleware::Statsd do
       )
 
       expect(client).to receive(:gauge).with(
-        'berater.limiter.contention',
+        'berater.lock.capacity',
+        limiter.capacity,
+        Hash,
+      )
+
+      expect(client).to receive(:gauge).with(
+        'berater.lock.contention',
         1,
         Hash,
       )
@@ -111,13 +150,13 @@ describe Berater::Middleware::Statsd do
 
     it 'tracks each call' do
       expect(client).to receive(:gauge).with(
-        'berater.limiter.contention',
+        'berater.lock.contention',
         1,
         Hash,
       )
 
       expect(client).to receive(:gauge).with(
-        'berater.limiter.contention',
+        'berater.lock.contention',
         2,
         Hash,
       )
@@ -135,7 +174,7 @@ describe Berater::Middleware::Statsd do
       it 'tracks limiter exceptions' do
         expect(client).to receive(:increment).with(
           'berater.limiter.error',
-          tags: hash_including(type: error.to_s),
+          tags: hash_including(type: 'Redis_TimeoutError'),
         )
 
         expect { limiter.limit }.to raise_error(error)
@@ -149,6 +188,7 @@ describe Berater::Middleware::Statsd do
         it 'does not track the exception' do
           expect(client).not_to receive(:increment).with(
             'berater.limiter.error',
+            anything,
           )
 
           limiter.limit
@@ -156,11 +196,8 @@ describe Berater::Middleware::Statsd do
 
         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',
+            /berater.lock/,
+            any_args,
           )
 
           limiter.limit
@@ -175,7 +212,7 @@ describe Berater::Middleware::Statsd do
         it 'tracks the exception' do
           expect(client).to receive(:increment).with(
             'berater.limiter.error',
-            Hash,
+            anything,
           )
 
           limiter.limit
@@ -183,11 +220,8 @@ describe Berater::Middleware::Statsd do
 
         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',
+            /berater.lock/,
+            any_args,
           )
 
           limiter.limit
@@ -202,24 +236,24 @@ describe Berater::Middleware::Statsd 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),
+      it 'tracks the overloaded count' do
+        expect(client).to receive(:increment).with(
+          'berater.limiter.overloaded',
+          Hash
         )
       end
 
-      it 'tracks contention' do
+      it 'does not track lock-based stats' do
         expect(client).not_to receive(:gauge).with(
-          'berater.limiter.contention',
-          limiter.capacity,
+          /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

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.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-03 00:00:00.000000000 Z
+date: 2022-03-04 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: 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
@@ -168,6 +182,7 @@ files:
 - 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
@@ -188,6 +203,7 @@ files:
 - 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
@@ -222,6 +238,7 @@ 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