airbrake-ruby 3.2.6 → 4.0.0

data/lib/airbrake-ruby/performance_notifier.rb

@@ -6,24 +6,12 @@ module Airbrake
   # @since v3.2.0
   class PerformanceNotifier
     include Inspectable
+    include Loggable
 
-    # @param [Airbrake::Config] config
-    def initialize(config)
-      @config =
-        if config.is_a?(Config)
-          config
-        else
-          loc = caller_locations(1..1).first
-          signature = "#{self.class.name}##{__method__}"
-          warn(
-            "#{loc.path}:#{loc.lineno}: warning: passing a Hash to #{signature} " \
-            'is deprecated. Pass `Airbrake::Config` instead'
-          )
-          Config.new(config)
-        end
-
-      @flush_period = @config.performance_stats_flush_period
-      @sender = SyncSender.new(@config, :put)
+    def initialize
+      @config = Airbrake::Config.instance
+      @flush_period = Airbrake::Config.instance.performance_stats_flush_period
+      @sender = SyncSender.new(:put)
       @payload = {}
       @schedule_flush = nil
       @mutex = Mutex.new
@@ -92,7 +80,7 @@ module Airbrake
       signature = "#{self.class.name}##{__method__}"
       raise "#{signature}: payload (#{payload}) cannot be empty. Race?" if payload.none?
 
-      @config.logger.debug("#{LOG_LABEL} #{signature}: #{payload}")
+      logger.debug("#{LOG_LABEL} #{signature}: #{payload}")
 
       payload.group_by { |k, _v| k.name }.each do |resource_name, data|
         data = { resource_name => data.map { |k, v| k.to_h.merge!(v.to_h) } }

data/lib/airbrake-ruby/response.rb

@@ -11,13 +11,16 @@ module Airbrake
     # @return [Integer] HTTP code returned when an IP sends over 10k/min notices
     TOO_MANY_REQUESTS = 429
 
+    class << self
+      include Loggable
+    end
+
     # Parses HTTP responses from the Airbrake API.
     #
     # @param [Net::HTTPResponse] response
-    # @param [Logger] logger
     # @return [Hash{String=>String}] parsed response
     # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-    def self.parse(response, logger)
+    def self.parse(response)
       code = response.code.to_i
       body = response.body
 

data/lib/airbrake-ruby/sync_sender.rb

@@ -9,9 +9,11 @@ module Airbrake
     # @return [String] body for HTTP requests
     CONTENT_TYPE = 'application/json'.freeze
 
-    # @param [Airbrake::Config] config
-    def initialize(config, method = :post)
-      @config = config
+    include Loggable
+
+    # @param [Symbol] method HTTP method to use to send payload
+    def initialize(method = :post)
+      @config = Airbrake::Config.instance
       @method = method
       @rate_limit_reset = Time.now
     end
@@ -35,11 +37,11 @@ module Airbrake
         response = https.request(req)
       rescue StandardError => ex
         reason = "#{LOG_LABEL} HTTP error: #{ex}"
-        @config.logger.error(reason)
+        logger.error(reason)
         return promise.reject(reason)
       end
 
-      parsed_resp = Response.parse(response, @config.logger)
+      parsed_resp = Response.parse(response)
       if parsed_resp.key?('rate_limit_reset')
         @rate_limit_reset = parsed_resp['rate_limit_reset']
       end
@@ -101,7 +103,7 @@ module Airbrake
 
       if missing
         reason = "#{LOG_LABEL} data was not sent because of missing body"
-        @config.logger.error(reason)
+        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 = '3.2.6'.freeze
+  AIRBRAKE_RUBY_VERSION = '4.0.0'.freeze
 end

data/spec/airbrake_spec.rb

@@ -1,31 +1,7 @@
 RSpec.describe Airbrake do
-  describe ".[]" do
-    it "returns a NilNotifier" do
-      expect(described_class[:test]).to be_an(Airbrake::NilNoticeNotifier)
-    end
-  end
-
-  describe ".notifiers" do
-    it "returns a Hash of notifiers" do
-      expect(described_class.notifiers).to eq(
-        notice: {}, performance: {}, deploy: {}
-      )
-    end
-  end
-
-  let(:default_notifier) do
-    described_class[:default]
-  end
+  before { Airbrake::Config.instance = Airbrake::Config.new }
 
   describe ".configure" do
-    let(:config_params) { { project_id: 1, project_key: 'abc' } }
-
-    after do
-      described_class.instance_variable_get(:@notice_notifiers).clear
-      described_class.instance_variable_get(:@performance_notifiers).clear
-      described_class.instance_variable_get(:@deploy_notifiers).clear
-    end
-
     it "yields the config" do
       expect do |b|
         begin
@@ -36,31 +12,6 @@ RSpec.describe Airbrake do
       end.to yield_with_args(Airbrake::Config)
     end
 
-    context "when invoked with a notice notifier name" do
-      it "sets notice notifier name to the provided name" do
-        described_class.configure(:test) { |c| c.merge(config_params) }
-        expect(described_class[:test]).to be_an(Airbrake::NoticeNotifier)
-      end
-    end
-
-    context "when invoked without a notifier name" do
-      it "defaults to the :default notifier name" do
-        described_class.configure { |c| c.merge(config_params) }
-        expect(described_class[:default]).to be_an(Airbrake::NoticeNotifier)
-      end
-    end
-
-    context "when invoked twice with the same notifier name" do
-      it "raises Airbrake::Error" do
-        described_class.configure { |c| c.merge(config_params) }
-        expect do
-          described_class.configure { |c| c.merge(config_params) }
-        end.to raise_error(
-          Airbrake::Error, "the 'default' notifier was already configured"
-        )
-      end
-    end
-
     context "when user config doesn't contain a project id" do
       it "raises error" do
         expect { described_class.configure { |c| c.project_key = '1' } }.
@@ -75,97 +26,4 @@ RSpec.describe Airbrake do
       end
     end
   end
-
-  describe ".configured?" do
-    it "forwards 'configured?' to the notifier" do
-      expect(default_notifier).to receive(:configured?)
-      described_class.configured?
-    end
-  end
-
-  describe ".notify" do
-    it "forwards 'notify' to the notifier" do
-      block = proc {}
-      expect(default_notifier).to receive(:notify).with('ex', foo: 'bar', &block)
-      described_class.notify('ex', foo: 'bar', &block)
-    end
-  end
-
-  describe ".notify_sync" do
-    it "forwards 'notify_sync' to the notifier" do
-      block = proc {}
-      expect(default_notifier).to receive(:notify).with('ex', foo: 'bar', &block)
-      described_class.notify('ex', foo: 'bar', &block)
-    end
-  end
-
-  describe ".add_filter" do
-    it "forwards 'add_filter' to the notifier" do
-      block = proc {}
-      expect(default_notifier).to receive(:add_filter).with(nil, &block)
-      described_class.add_filter(&block)
-    end
-  end
-
-  describe ".build_notice" do
-    it "forwards 'build_notice' to the notifier" do
-      expect(default_notifier).to receive(:build_notice).with('ex', foo: 'bar')
-      described_class.build_notice('ex', foo: 'bar')
-    end
-  end
-
-  describe ".close" do
-    it "forwards 'close' to the notifier" do
-      expect(default_notifier).to receive(:close)
-      described_class.close
-    end
-  end
-
-  describe ".notify_deploy" do
-    let(:default_notifier) { described_class.notifiers[:deploy][:default] }
-
-    it "calls 'notify' on the deploy notifier" do
-      expect(default_notifier).to receive(:notify).with(foo: 'bar')
-      described_class.notify_deploy(foo: 'bar')
-    end
-  end
-
-  describe ".merge_context" do
-    it "forwards 'merge_context' to the notifier" do
-      expect(default_notifier).to receive(:merge_context).with(foo: 'bar')
-      described_class.merge_context(foo: 'bar')
-    end
-  end
-
-  describe ".notify_request" do
-    let(:default_notifier) { described_class.notifiers[:performance][:default] }
-
-    it "calls 'notify' on the route notifier" do
-      params = {
-        method: 'GET',
-        route: '/foo',
-        status_code: 200,
-        start_time: Time.new(2018, 1, 1, 0, 20, 0, 0),
-        end_time: Time.new(2018, 1, 1, 0, 19, 0, 0)
-      }
-      expect(default_notifier).to receive(:notify).with(Airbrake::Request.new(params))
-      described_class.notify_request(params)
-    end
-  end
-
-  describe ".notify_query" do
-    let(:default_notifier) { described_class.notifiers[:performance][:default] }
-
-    it "calls 'notify' on the query notifier" do
-      params = {
-        method: 'GET',
-        route: '/foo',
-        query: 'SELECT * FROM foos',
-        start_time: Time.new(2018, 1, 1, 0, 20, 0, 0),
-        end_time: Time.new(2018, 1, 1, 0, 19, 0, 0)
-      }
-      expect(default_notifier).to receive(:notify).with(Airbrake::Query.new(params))
-      described_class.notify_query(params)
-    end
-  end
 end

data/spec/async_sender_spec.rb

@@ -1,154 +1,147 @@
 RSpec.describe Airbrake::AsyncSender do
+  let(:endpoint) { 'https://api.airbrake.io/api/v3/projects/1/notices' }
+  let(:queue_size) { 10 }
+  let(:notice) { Airbrake::Notice.new(AirbrakeTestError.new) }
+
   before do
-    stub_request(:post, /.*/).to_return(status: 201, body: '{}')
+    stub_request(:post, endpoint).to_return(status: 201, body: '{}')
+    Airbrake::Config.instance = Airbrake::Config.new(
+      project_id: '1',
+      workers: 3,
+      queue_size: queue_size
+    )
+
+    allow(Airbrake::Loggable.instance).to receive(:debug)
+    expect(subject).to have_workers
   end
 
   describe "#send" do
-    it "limits the size of the queue" do
-      stdout = StringIO.new
-      notices_count = 1000
-      queue_size = 10
-      config = Airbrake::Config.new(
-        logger: Logger.new(stdout), workers: 3, queue_size: queue_size
-      )
-      sender = described_class.new(config)
-      expect(sender).to have_workers
-
-      notice = Airbrake::Notice.new(config, AirbrakeTestError.new)
-      notices_count.times { sender.send(notice, Airbrake::Promise.new) }
-      sender.close
-
-      log = stdout.string.split("\n")
-      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)
+    it "sends payload to Airbrake" do
+      2.times do
+        subject.send(notice, Airbrake::Promise.new)
+      end
+      subject.close
+
+      expect(a_request(:post, endpoint)).to have_been_made.twice
     end
-  end
 
-  describe "#close" do
-    before do
-      @stderr = StringIO.new
-      config = Airbrake::Config.new(logger: Logger.new(@stderr))
-      @sender = described_class.new(config)
-      expect(@sender).to have_workers
+    context "when the queue is full" do
+      before do
+        allow(subject.unsent).to receive(:size).and_return(queue_size)
+      end
+
+      it "discards payload" do
+        200.times do
+          subject.send(notice, Airbrake::Promise.new)
+        end
+        subject.close
+
+        expect(a_request(:post, endpoint)).not_to have_been_made
+      end
+
+      it "logs discarded payload" do
+        expect(Airbrake::Loggable.instance).to receive(:error).with(
+          /reached its capacity/
+        ).exactly(15).times
+
+        15.times do
+          subject.send(notice, Airbrake::Promise.new)
+        end
+        subject.close
+      end
     end
+  end
 
+  describe "#close" do
     context "when there are no unsent notices" do
       it "joins the spawned thread" do
-        workers = @sender.instance_variable_get(:@workers).list
-
+        workers = subject.workers.list
         expect(workers).to all(be_alive)
-        @sender.close
+
+        subject.close
         expect(workers).to all(be_stop)
       end
     end
 
     context "when there are some unsent notices" do
-      before do
-        notice = Airbrake::Notice.new(Airbrake::Config.new, AirbrakeTestError.new)
-        300.times { @sender.send(notice, Airbrake::Promise.new) }
-        expect(@sender.instance_variable_get(:@unsent).size).not_to be_zero
-        @sender.close
-      end
-
-      it "warns about the number of notices" do
-        expect(@stderr.string).to match(/waiting to send \d+ unsent notice/)
-      end
-
-      it "prints the correct number of log messages" do
-        log = @stderr.string.split("\n")
-        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)
+      it "logs how many notices are left to send" do
+        expect(Airbrake::Loggable.instance).to receive(:debug).with(
+          /waiting to send \d+ unsent notice\(s\)/
+        )
+        expect(Airbrake::Loggable.instance).to receive(:debug).with(/closed/)
+
+        300.times { subject.send(notice, Airbrake::Promise.new) }
+        subject.close
       end
 
       it "waits until the unsent notices queue is empty" do
-        expect(@sender.instance_variable_get(:@unsent).size).to be_zero
+        subject.close
+        expect(subject.unsent.size).to be_zero
       end
     end
 
     context "when it was already closed" do
       it "doesn't increase the unsent queue size" do
         begin
-          @sender.close
+          subject.close
         rescue Airbrake::Error
           nil
         end
 
-        expect(@sender.instance_variable_get(:@unsent).size).to be_zero
+        expect(subject.unsent.size).to be_zero
       end
 
       it "raises error" do
-        @sender.close
+        subject.close
 
-        expect(@sender).to be_closed
-        expect { @sender.close }.
-          to raise_error(Airbrake::Error, 'attempted to close already closed sender')
+        expect(subject).to be_closed
+        expect { subject.close }.to raise_error(
+          Airbrake::Error, 'attempted to close already closed sender'
+        )
       end
     end
 
     context "when workers were not spawned" do
       it "correctly closes the notifier nevertheless" do
-        sender = described_class.new(Airbrake::Config.new)
-        sender.close
-
-        expect(sender).to be_closed
+        subject.close
+        expect(subject).to be_closed
       end
     end
   end
 
   describe "#has_workers?" do
-    before do
-      @sender = described_class.new(Airbrake::Config.new)
-      expect(@sender).to have_workers
-    end
-
     it "returns false when the sender is not closed, but has 0 workers" do
-      @sender.instance_variable_get(:@workers).list.each(&:kill)
-      sleep 1
-      expect(@sender).not_to have_workers
+      subject.workers.list.each do |worker|
+        worker.kill.join
+      end
+      expect(subject).not_to have_workers
     end
 
     it "returns false when the sender is closed" do
-      @sender.close
-      expect(@sender).not_to have_workers
+      subject.close
+      expect(subject).not_to have_workers
     end
 
     it "respawns workers on fork()", skip: %w[jruby rbx].include?(RUBY_ENGINE) do
-      pid = fork do
-        expect(@sender).to have_workers
-      end
+      pid = fork { expect(subject).to have_workers }
       Process.wait(pid)
-      @sender.close
-      expect(@sender).not_to have_workers
+      subject.close
+      expect(subject).not_to have_workers
     end
   end
 
   describe "#spawn_workers" do
     it "spawns alive threads in an enclosed ThreadGroup" do
-      sender = described_class.new(Airbrake::Config.new)
-      expect(sender).to have_workers
+      expect(subject.workers).to be_a(ThreadGroup)
+      expect(subject.workers.list).to all(be_alive)
+      expect(subject.workers).to be_enclosed
 
-      workers = sender.instance_variable_get(:@workers)
-
-      expect(workers).to be_a(ThreadGroup)
-      expect(workers.list).to all(be_alive)
-      expect(workers).to be_enclosed
-
-      sender.close
+      subject.close
     end
 
     it "spawns exactly config.workers workers" do
-      workers_count = 5
-      sender = described_class.new(Airbrake::Config.new(workers: workers_count))
-      expect(sender).to have_workers
-
-      workers = sender.instance_variable_get(:@workers)
-
-      expect(workers.list.size).to eq(workers_count)
-      sender.close
+      expect(subject.workers.list.size).to eq(Airbrake::Config.instance.workers)
+      subject.close
     end
   end
 end