berater 0.12.1 → 0.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d3ef54656151bf378670caca07686db842a007e87e51d14195cc3f2b8d34d34
-  data.tar.gz: 22c6b65158ba926e78cd013c54913024c617eb5c2932297f7e4e424a72f66a14
+  metadata.gz: 1270edae5d2c019ae92b623ff4c26e588cf8d5413c8f7b6c549d3d3ec4e16766
+  data.tar.gz: a9a659acde5a04263b1ca516a2fb1ecdd760d9133f3603b4fa7ec336c06f59df
 SHA512:
-  metadata.gz: 2743af38d4daf9cd5d18a06368834545add59fb6d192fdf17c7f503ab059961177c444e5b09efde6a8ed6739b4cca04d83e7e88f8d904d0bd3e2b1bc94220cfb
-  data.tar.gz: a6750a44bcd05a1d0b25ff770d3c1d0f6fd3fd331cfebebbecdebd4ef06bc4f5a34d350cc36414cce7b212e7e63f8bb1d10cc4d25788ae50e1b973dfd280be4e
+  metadata.gz: 07fc3784c2e6d41648f97878e3a0c62e3a089c1ef69315e88141642350180634c65a89deda082ed5933a90666c620111329756d0699d3fde5238b97d0ad37e82
+  data.tar.gz: 6f8dc42b5b694a45c286b1d66a0b8efbf17371b3fd6bfd8936098b4155b85ae6523146fecfc6b7c46e3b0a8df1ddb03158f1fd181c9e6a1e13042232089e1a41

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/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/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)
@@ -36,14 +36,14 @@ module Berater
             tags: tags,
           )
 
-          if lock.contention > 0 # not a failsafe lock
+          if lock.contention >= 0 # not a failsafe lock
             @client.gauge(
               'berater.lock.capacity',
               lock.capacity,
               tags: tags,
             )
             @client.gauge(
-              'berater.limiter.contention',
+              'berater.lock.contention',
               lock.contention,
               tags: tags,
             )
@@ -56,13 +56,6 @@ module Berater
               'berater.limiter.overloaded',
               tags: tags,
             )
-
-            # overloaded, so contention >= capacity
-            @client.gauge(
-              'berater.limiter.contention',
-              limiter.capacity,
-              tags: tags,
-            )
           else
             @client.increment(
               'berater.limiter.error',
@@ -80,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,39 @@
+module Berater
+  module Middleware
+    class Trace
+      def initialize(tracer: nil)
+        @tracer = tracer
+      end
+
+      def call(limiter, **)
+        tracer&.trace('Berater') 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 || (defined?(Datadog::Tracing) && Datadog::Tracing) || (defined?(Datadog) && 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.1"
+  VERSION = "0.13.1"
 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 }
 
@@ -193,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'
@@ -215,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/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 }
@@ -50,39 +60,56 @@ describe Berater::Middleware::Statsd do
       )
     end
 
-    context 'when custom tags are passed in' do
-      let(:opts) { { tags: { abc: 123 } } }
+    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
@@ -107,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,
       )
@@ -117,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,
       )
@@ -155,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
@@ -162,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
@@ -189,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
@@ -215,16 +243,17 @@ describe Berater::Middleware::Statsd do
         )
       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,96 @@
+require 'ddtrace'
+
+describe Berater::Middleware::Trace do
+  before do
+    allow(tracer).to receive(:trace).and_yield(span)
+  end
+
+  it_behaves_like 'a limiter middleware'
+
+  let(:limiter) { Berater::Unlimiter.new }
+
+  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
+
+  describe '#tracer' do
+    subject { instance.send(:tracer) }
+
+    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) }
+
+      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')
+
+        expect {
+          instance.call(limiter) { raise IOError }
+        }.to raise_error(IOError)
+      end
+    end
+  end
+
+  context 'when used as middleware' do
+    before do
+      Berater.middleware.use described_class, tracer: tracer
+    end
+
+    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 {
+          limiter.limit
+        }.to be_overloaded
+      end
+    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.1
+  version: 0.13.1
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-05 00:00:00.000000000 Z
+date: 2022-07-13 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