airbrake-ruby 2.12.0 → 2.13.0.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f92ef10b01c37b9374a6662bedba21c1593ef34
-  data.tar.gz: 957da6a830307c3d3cd9f583f1eaa9bf4a2df96f
+  metadata.gz: 3ae033f8b21b79ecf3902d570014f379e76b4c16
+  data.tar.gz: 131f71f8a92906a05aadf1ed3dbd4ffc35753162
 SHA512:
-  metadata.gz: b0ca6c8f84dfc39758f22203519765820a25c4bddd8e7aae90928d46b1f201ee7ab283679fdc16020043cd222c3a6f3e09def0642d1428d005b3022b8dfc59ee
-  data.tar.gz: 46f263d46199864c89c70c721ecb1c50f13262a13b9b3603b31260cd0f6ea44536fa2ceb419b3efaee1bd82b7877f53246c754288f433054c43ca3b0af3bba58
+  metadata.gz: 62a0b41680b377eefd25a0e9433ada861ce92841d954477de949f3ee16bbb32a198d3133433b0783e7e4f747a7c7bff39e76dcf4744bfbb8da8fffbcd54c4a6d
+  data.tar.gz: 6864d904a38696d892dcca249ddeff4b1c973e61735ef792a19518bf1e17c430fc9f1bd09ea59fe4c6d7685d6d1a1e911848a657a6647199bb3208d25183192c

data/lib/airbrake-ruby.rb

@@ -4,6 +4,7 @@ require 'json'
 require 'thread'
 require 'set'
 require 'socket'
+require 'time'
 
 require 'airbrake-ruby/version'
 require 'airbrake-ruby/config'
@@ -33,6 +34,7 @@ require 'airbrake-ruby/filter_chain'
 require 'airbrake-ruby/notifier'
 require 'airbrake-ruby/code_hunk'
 require 'airbrake-ruby/file_cache'
+require 'airbrake-ruby/route_sender'
 
 # This module defines the Airbrake API. The user is meant to interact with
 # Airbrake via its public class methods. Before using the library, you must to
@@ -115,6 +117,9 @@ module Airbrake
 
     # @macro see_public_api_method
     def merge_context(_context); end
+
+    # @macro see_public_api_method
+    def inc_request(method, route, status_code, dur, time); end
   end
 
   # A Hash that holds all notifiers. The keys of the Hash are notifier
@@ -343,5 +348,27 @@ module Airbrake
     def merge_context(context)
       @notifiers[:default].merge_context(context)
     end
+
+    # Increments request count of a certain +route+ that was invoked with
+    # +method+, and returned +status_code+ at +time+ and took +dur+
+    # milliseconds.
+    #
+    # After a certain amount of time (n seconds) the aggregated route
+    # information will be sent to Airbrake.
+    #
+    # @example
+    #   Airbrake.inc_request('POST', '/thing/:id/create', 200, 123, Time.now)
+    #
+    # @param [String] method The HTTP method that was invoked
+    # @param [String] route The route that was invoked
+    # @param [Integer] status_code The respose code that the route returned
+    # @param [Float] dur How much time the processing of the request took in
+    #   milliseconds
+    # @param [Time] time When the request happened
+    # @return [void]
+    # @since v2.13.0
+    def inc_request(method, route, status_code, dur, time)
+      @notifiers[:default].inc_request(method, route, status_code, dur, time)
+    end
   end
 end

data/lib/airbrake-ruby/config.rb

@@ -83,6 +83,12 @@ module Airbrake
     # @since v2.5.0
     attr_accessor :code_hunks
 
+    # @return [Integer] how many seconds to wait before sending collected route
+    #   stats
+    # @api public
+    # @since v2.13.0
+    attr_accessor :route_stats_flush_period
+
     # @param [Hash{Symbol=>Object}] user_config the hash to be used to build the
     #   config
     def initialize(user_config = {})
@@ -113,6 +119,7 @@ module Airbrake
       )
 
       self.versions = {}
+      self.route_stats_flush_period = 15
 
       merge(user_config)
     end

data/lib/airbrake-ruby/notifier.rb

@@ -36,6 +36,8 @@ module Airbrake
 
       @async_sender = AsyncSender.new(@config)
       @sync_sender = SyncSender.new(@config)
+
+      @route_sender = RouteSender.new(@config)
     end
 
     # @macro see_public_api_method
@@ -95,6 +97,11 @@ module Airbrake
       @context.merge!(context)
     end
 
+    # @macro see_public_api_method
+    def inc_request(*args)
+      @route_sender.inc_request(*args)
+    end
+
     private
 
     def convert_to_exception(ex)

data/lib/airbrake-ruby/response.rb

@@ -16,16 +16,19 @@ module Airbrake
     # @param [Net::HTTPResponse] response
     # @param [Logger] logger
     # @return [Hash{String=>String}] parsed response
-    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
     def self.parse(response, logger)
       code = response.code.to_i
       body = response.body
 
       begin
         case code
+        when 200
+          logger.debug("#{LOG_LABEL} #{name} (#{code}): #{body}")
+          { response.msg => response.body }
         when 201
           parsed_body = JSON.parse(body)
-          logger.debug("#{LOG_LABEL} #{parsed_body}")
+          logger.debug("#{LOG_LABEL} #{name} (#{code}): #{parsed_body}")
           parsed_body
         when 400, 401, 403, 420
           parsed_body = JSON.parse(body)
@@ -47,7 +50,7 @@ module Airbrake
         { 'error' => ex.inspect }
       end
     end
-    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
     def self.truncated_body(body)
       if body.nil?

data/lib/airbrake-ruby/route_sender.rb

@@ -0,0 +1,106 @@
+module Airbrake
+  # RouteSender aggregates information about requests and periodically sends
+  # collected data to Airbrake.
+  # @since v2.13.0
+  class RouteSender
+    # The key that represents a route.
+    RouteKey = Struct.new(:method, :route, :statusCode, :time)
+
+    # RouteStat holds data that describes a route's performance.
+    RouteStat = Struct.new(:count, :sum, :sumsq, :min, :max) do
+      # @param [Integer] count The number of requests
+      # @param [Float] sum The sum of request duration in milliseconds
+      # @param [Float] sumsq The squared sum of request duration in milliseconds
+      # @param [Float] min The minimal request duration
+      # @param [Float] max The maximum request duration
+      def initialize(count: 0, sum: 0.0, sumsq: 0.0, min: 0.0, max: 0.0)
+        super(count, sum, sumsq, min, max)
+      end
+    end
+
+    # @param [Airbrake::Config] config
+    def initialize(config)
+      @config = config
+      @flush_period = config.route_stats_flush_period
+      @sender = SyncSender.new(config, :put)
+      @routes = {}
+      @thread = nil
+      @mutex = Mutex.new
+    end
+
+    # @macro see_public_api_method
+    def inc_request(method, route, status_code, dur, tm)
+      route = create_route_key(method, route, status_code, tm)
+
+      promise = Airbrake::Promise.new
+
+      @mutex.synchronize do
+        @routes[route] ||= RouteStat.new
+        increment_stats(@routes[route], dur)
+
+        if @flush_period > 0
+          schedule_flush(promise)
+        else
+          send(@routes, promise)
+        end
+      end
+
+      promise
+    end
+
+    private
+
+    def create_route_key(method, route, status_code, tm)
+      # rubocop:disable Style/DateTime
+      time = DateTime.new(
+        tm.year, tm.month, tm.day, tm.hour, tm.min, 0, tm.zone || 0
+      )
+      # rubocop:enable Style/DateTime
+      RouteKey.new(method, route, status_code, time.rfc3339)
+    end
+
+    def increment_stats(stat, dur)
+      stat.count += 1
+
+      ms = dur.to_f
+      stat.sum += ms
+      stat.sumsq += ms * ms
+
+      stat.min = ms if ms < stat.min || stat.min == 0
+      stat.max = ms if ms > stat.max
+    end
+
+    def schedule_flush(promise)
+      @thread ||= Thread.new do
+        sleep(@flush_period)
+
+        routes = nil
+        @mutex.synchronize do
+          routes = @routes
+          @routes = {}
+          @thread = nil
+        end
+
+        send(routes, promise)
+      end
+
+      # Setting a name is needed to test the timer.
+      # Ruby <=2.2 doesn't support Thread#name, so we have this check.
+      @thread.name = 'route-stat-thread' if @thread.respond_to?(:name)
+    end
+
+    def send(routes, promise)
+      if routes.none?
+        raise "#{self.class.name}##{__method__}: routes cannot be empty. Race?"
+      end
+
+      @config.logger.debug("#{LOG_LABEL} RouteStats#send: #{routes}")
+
+      @sender.send(
+        { routes: routes.map { |k, v| k.to_h.merge(v.to_h) } },
+        promise,
+        URI.join(@config.host, "api/v4/projects/#{@config.project_id}/routes-stats")
+      )
+    end
+  end
+end

data/lib/airbrake-ruby/sync_sender.rb

@@ -1,5 +1,6 @@
 module Airbrake
-  # Responsible for sending notices to Airbrake synchronously. Supports proxies.
+  # Responsible for sending data to Airbrake synchronously via PUT or POST
+  # methods. Supports proxies.
   #
   # @see AsyncSender
   # @api private
@@ -9,21 +10,22 @@ module Airbrake
     CONTENT_TYPE = 'application/json'.freeze
 
     # @param [Airbrake::Config] config
-    def initialize(config)
+    def initialize(config, method = :post)
       @config = config
+      @method = method
       @rate_limit_reset = Time.now
     end
 
-    # Sends a POST request to the given +endpoint+ with the +notice+ payload.
+    # Sends a POST or PUT request to the given +endpoint+ with the +data+ payload.
     #
-    # @param [Airbrake::Notice] notice
-    # @param [Airbrake::Notice] endpoint
+    # @param [#to_json] data
+    # @param [URI::HTTPS] endpoint
     # @return [Hash{String=>String}] the parsed HTTP response
-    def send(notice, promise, endpoint = @config.endpoint)
+    def send(data, promise, endpoint = @config.endpoint)
       return promise if rate_limited_ip?(promise)
 
       response = nil
-      req = build_post_request(endpoint, notice)
+      req = build_request(endpoint, data)
 
       return promise if missing_body?(req, promise)
 
@@ -58,16 +60,27 @@ module Airbrake
       end
     end
 
-    def build_post_request(uri, notice)
-      Net::HTTP::Post.new(uri.request_uri).tap do |req|
-        req.body = notice.to_json
+    def build_request(uri, data)
+      req =
+        if @method == :put
+          Net::HTTP::Put.new(uri.request_uri)
+        else
+          Net::HTTP::Post.new(uri.request_uri)
+        end
 
-        req['Authorization'] = "Bearer #{@config.project_key}"
-        req['Content-Type'] = CONTENT_TYPE
-        req['User-Agent'] =
-          "#{Airbrake::Notice::NOTIFIER[:name]}/#{Airbrake::AIRBRAKE_RUBY_VERSION}" \
-          " Ruby/#{RUBY_VERSION}"
-      end
+      build_request_body(req, data)
+    end
+
+    def build_request_body(req, data)
+      req.body = data.to_json
+
+      req['Authorization'] = "Bearer #{@config.project_key}"
+      req['Content-Type'] = CONTENT_TYPE
+      req['User-Agent'] =
+        "#{Airbrake::Notice::NOTIFIER[:name]}/#{Airbrake::AIRBRAKE_RUBY_VERSION}" \
+        " Ruby/#{RUBY_VERSION}"
+
+      req
     end
 
     def proxy_params
@@ -87,7 +100,7 @@ module Airbrake
       missing = req.body.nil?
 
       if missing
-        reason = "#{LOG_LABEL} notice was not sent because of missing body"
+        reason = "#{LOG_LABEL} data was not sent because of missing body"
         @config.logger.error(reason)
         promise.reject(reason)
       end

data/lib/airbrake-ruby/version.rb

@@ -2,5 +2,5 @@
 # More information: http://semver.org/
 module Airbrake
   # @return [String] the library version
-  AIRBRAKE_RUBY_VERSION = '2.12.0'.freeze
+  AIRBRAKE_RUBY_VERSION = '2.13.0.pre.1'.freeze
 end

data/spec/airbrake_spec.rb

@@ -110,4 +110,14 @@ RSpec.describe Airbrake do
       described_class.merge_context(foo: 'bar')
     end
   end
+
+  describe ".inc_request" do
+    it "forwards 'inc_request' to the notifier" do
+      t = Time.now
+      expect(default_notifier).to receive(:inc_request).with(
+        'GET', '/foo', 200, 1000, t
+      )
+      described_class.inc_request('GET', '/foo', 200, 1000, t)
+    end
+  end
 end

data/spec/async_sender_spec.rb

@@ -21,7 +21,7 @@ RSpec.describe Airbrake::AsyncSender do
       sender.close
 
       log = stdout.string.split("\n")
-      notices_sent    = log.grep(/\*\*Airbrake: \{\}/).size
+      notices_sent    = log.grep(/\*\*Airbrake: Airbrake::Response \(201\): \{\}/).size
       notices_dropped = log.grep(/\*\*Airbrake:.*not.*delivered/).size
       expect(notices_sent).to be >= queue_size
       expect(notices_sent + notices_dropped).to eq(notices_count)
@@ -60,7 +60,7 @@ RSpec.describe Airbrake::AsyncSender do
 
       it "prints the correct number of log messages" do
         log = @stderr.string.split("\n")
-        notices_sent    = log.grep(/\*\*Airbrake: \{\}/).size
+        notices_sent    = log.grep(/\*\*Airbrake: Airbrake::Response \(201\): \{\}/).size
         notices_dropped = log.grep(/\*\*Airbrake:.*not.*delivered/).size
         expect(notices_sent).to be >= @sender.instance_variable_get(:@unsent).max
         expect(notices_sent + notices_dropped).to eq(300)

data/spec/config_spec.rb

@@ -78,6 +78,10 @@ RSpec.describe Airbrake::Config do
       it "doesn't set default whitelist" do
         expect(config.whitelist_keys).to be_empty
       end
+
+      it "sets the default route_stats_flush_period" do
+        expect(config.route_stats_flush_period).to eq(15)
+      end
     end
   end
 

data/spec/notifier_spec.rb

@@ -449,5 +449,15 @@ RSpec.describe Airbrake::Notifier do
       subject.merge_context(apples: 'oranges')
     end
   end
+
+  describe "#inc_request" do
+    it "forwards 'inc_request' to RouteSender" do
+      t = Time.now
+      expect_any_instance_of(Airbrake::RouteSender).to receive(:inc_request).with(
+        'GET', '/foo', 200, 1000, t
+      )
+      subject.inc_request('GET', '/foo', 200, 1000, t)
+    end
+  end
 end
 # rubocop:enable Layout/DotPosition

data/spec/response_spec.rb

@@ -5,10 +5,12 @@ RSpec.describe Airbrake::Response do
     let(:out) { StringIO.new }
     let(:logger) { Logger.new(out) }
 
-    context "when response code is 201" do
-      it "logs response body" do
-        described_class.parse(OpenStruct.new(code: 201, body: '{}'), logger)
-        expect(out.string).to match(/Airbrake: {}/)
+    [200, 201].each do |code|
+      context "when response code is #{code}" do
+        it "logs response body" do
+          described_class.parse(OpenStruct.new(code: code, body: '{}'), logger)
+          expect(out.string).to match(/Airbrake: Airbrake::Response \(#{code}\): {}/)
+        end
       end
     end
 

data/spec/route_sender_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+RSpec.describe Airbrake::RouteSender do
+  let(:endpoint) { 'https://api.airbrake.io/api/v4/projects/1/routes-stats' }
+
+  let(:config) do
+    Airbrake::Config.new(
+      project_id: 1,
+      project_key: 'banana',
+      route_stats_flush_period: 0.1
+    )
+  end
+
+  subject { described_class.new(config) }
+
+  describe "#inc_request" do
+    before do
+      stub_request(:put, endpoint).to_return(status: 200, body: '')
+    end
+
+    # Let the request finish.
+    after { sleep 0.2 }
+
+    it "rounds time to the floor minute" do
+      subject.inc_request('GET', '/foo', 200, 24, Time.new(2018, 1, 1, 0, 0, 20, 0))
+      sleep 0.2
+      expect(
+        a_request(:put, endpoint).with(body: /"time":"2018-01-01T00:00:00\+00:00"/)
+      ).to have_been_made
+    end
+
+    it "increments routes with the same key" do
+      subject.inc_request('GET', '/foo', 200, 24, Time.new(2018, 1, 1, 0, 0, 20, 0))
+      subject.inc_request('GET', '/foo', 200, 24, Time.new(2018, 1, 1, 0, 0, 50, 0))
+      sleep 0.2
+      expect(
+        a_request(:put, endpoint).with(body: /"count":2/)
+      ).to have_been_made
+    end
+
+    it "groups routes by time" do
+      subject.inc_request('GET', '/foo', 200, 24, Time.new(2018, 1, 1, 0, 0, 20, 0))
+      subject.inc_request('GET', '/foo', 200, 10, Time.new(2018, 1, 1, 0, 1, 20, 0))
+      sleep 0.2
+      expect(
+        a_request(:put, endpoint).with(
+          body: %r|\A
+            {"routes":\[
+              {"method":"GET","route":"/foo","statusCode":200,
+               "time":"2018-01-01T00:00:00\+00:00","count":1,"sum":24.0,
+               "sumsq":576.0,"min":24.0,"max":24.0},
+              {"method":"GET","route":"/foo","statusCode":200,
+               "time":"2018-01-01T00:01:00\+00:00","count":1,"sum":10.0,
+               "sumsq":100.0,"min":10.0,"max":10.0}\]}
+          \z|x
+        )
+      ).to have_been_made
+    end
+
+    it "groups routes by route key" do
+      subject.inc_request('GET', '/foo', 200, 24, Time.new(2018, 1, 1, 0, 0, 20, 0))
+      subject.inc_request('POST', '/foo', 200, 10, Time.new(2018, 1, 1, 0, 0, 20, 0))
+      sleep 0.2
+      expect(
+        a_request(:put, endpoint).with(
+          body: %r|\A
+            {"routes":\[
+              {"method":"GET","route":"/foo","statusCode":200,
+               "time":"2018-01-01T00:00:00\+00:00","count":1,"sum":24.0,
+               "sumsq":576.0,"min":24.0,"max":24.0},
+              {"method":"POST","route":"/foo","statusCode":200,
+               "time":"2018-01-01T00:00:00\+00:00","count":1,"sum":10.0,
+               "sumsq":100.0,"min":10.0,"max":10.0}\]}
+          \z|x
+        )
+      ).to have_been_made
+    end
+
+    it "returns a promise" do
+      promise = subject.inc_request('GET', '/foo', 200, 24, Time.new)
+      sleep 0.2
+      expect(promise).to be_an(Airbrake::Promise)
+      expect(promise.value).to eq('' => nil)
+    end
+  end
+end

data/spec/sync_sender_spec.rb

@@ -30,7 +30,7 @@ RSpec.describe Airbrake::SyncSender do
     before { stub_request(:post, endpoint).to_return(body: '{}') }
 
     it "sets the Content-Type header to JSON" do
-      sender.send(notice, promise)
+      sender.send({}, promise)
       expect(
         a_request(:post, endpoint).with(
           headers: { 'Content-Type' => 'application/json' }
@@ -39,18 +39,18 @@ RSpec.describe Airbrake::SyncSender do
     end
 
     it "sets the User-Agent header to the notifier slug" do
-      sender.send(notice, promise)
+      sender.send({}, promise)
       expect(
         a_request(:post, endpoint).with(
           headers: {
-            'User-Agent' => %r{airbrake-ruby/\d+\.\d+\.\d+ Ruby/\d+\.\d+\.\d+}
+            'User-Agent' => %r{airbrake-ruby/\d+\.\d+\.\d+.+ Ruby/\d+\.\d+\.\d+}
           }
         )
       ).to have_been_made.once
     end
 
     it "sets the Authorization header to the project key" do
-      sender.send(notice, promise)
+      sender.send({}, promise)
       expect(
         a_request(:post, endpoint).with(
           headers: { 'Authorization' => 'Bearer banana' }
@@ -62,13 +62,13 @@ RSpec.describe Airbrake::SyncSender do
       https = double("foo")
       allow(sender).to receive(:build_https).and_return(https)
       allow(https).to receive(:request).and_raise(StandardError.new('foo'))
-      expect(sender.send(notice, promise)).to be_an(Airbrake::Promise)
+      expect(sender.send({}, promise)).to be_an(Airbrake::Promise)
       expect(promise.value).to eq('error' => '**Airbrake: HTTP error: foo')
       expect(stdout.string).to match(/ERROR -- : .+ HTTP error: foo/)
     end
 
     context "when request body is nil" do
-      it "doesn't send a notice" do
+      it "doesn't send data" do
         expect_any_instance_of(Airbrake::Truncator).
           to receive(:reduce_max_size).and_return(0)
 
@@ -84,8 +84,8 @@ RSpec.describe Airbrake::SyncSender do
 
         expect(sender.send(notice, promise)).to be_an(Airbrake::Promise)
         expect(promise.value).
-          to match('error' => '**Airbrake: notice was not sent because of missing body')
-        expect(stdout.string).to match(/ERROR -- : .+ notice was not sent/)
+          to match('error' => '**Airbrake: data was not sent because of missing body')
+        expect(stdout.string).to match(/ERROR -- : .+ data was not sent/)
       end
     end
 
@@ -102,11 +102,11 @@ RSpec.describe Airbrake::SyncSender do
 
       it "returns error" do
         p1 = Airbrake::Promise.new
-        sender.send(notice, p1)
+        sender.send({}, p1)
         expect(p1.value).to match('error' => '**Airbrake: IP is rate limited')
 
         p2 = Airbrake::Promise.new
-        sender.send(notice, p2)
+        sender.send({}, p2)
         expect(p2.value).to match('error' => '**Airbrake: IP is rate limited')
 
         # Wait for X-RateLimit-Delay and then make a new request to make sure p2
@@ -114,11 +114,29 @@ RSpec.describe Airbrake::SyncSender do
         sleep 1
 
         p3 = Airbrake::Promise.new
-        sender.send(notice, p3)
+        sender.send({}, p3)
         expect(p3.value).to match('error' => '**Airbrake: IP is rate limited')
 
         expect(a_request(:post, endpoint)).to have_been_made.twice
       end
     end
+
+    context "when the provided method is :put" do
+      before { stub_request(:put, endpoint).to_return(status: 200, body: '') }
+
+      it "PUTs the request" do
+        sender = described_class.new(config, :put)
+        sender.send({}, promise)
+        expect(a_request(:put, endpoint)).to have_been_made
+      end
+    end
+
+    context "when the provided method is :post" do
+      it "POSTs the request" do
+        sender = described_class.new(config, :post)
+        sender.send({}, promise)
+        expect(a_request(:post, endpoint)).to have_been_made
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: airbrake-ruby
 version: !ruby/object:Gem::Version
-  version: 2.12.0
+  version: 2.13.0.pre.1
 platform: ruby
 authors:
 - Airbrake Technologies, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-11 00:00:00.000000000 Z
+date: 2018-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -141,6 +141,7 @@ files:
 - lib/airbrake-ruby/notifier.rb
 - lib/airbrake-ruby/promise.rb
 - lib/airbrake-ruby/response.rb
+- lib/airbrake-ruby/route_sender.rb
 - lib/airbrake-ruby/sync_sender.rb
 - lib/airbrake-ruby/truncator.rb
 - lib/airbrake-ruby/version.rb
@@ -177,6 +178,7 @@ files:
 - spec/notifier_spec/options_spec.rb
 - spec/promise_spec.rb
 - spec/response_spec.rb
+- spec/route_sender_spec.rb
 - spec/spec_helper.rb
 - spec/sync_sender_spec.rb
 - spec/truncator_spec.rb
@@ -195,9 +197,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.6.13
@@ -205,6 +207,7 @@ signing_key:
 specification_version: 4
 summary: Ruby notifier for https://airbrake.io
 test_files:
+- spec/route_sender_spec.rb
 - spec/truncator_spec.rb
 - spec/helpers.rb
 - spec/filters/exception_attributes_filter_spec.rb