airbrake-ruby 4.6.0

data/spec/fixtures/notroot.txt

@@ -0,0 +1,7 @@
+This
+file
+is
+not
+inside
+root
+directory

data/spec/fixtures/project_root/code.rb

@@ -0,0 +1,221 @@
+module Airbrake
+  ##
+  # Represents a chunk of information that is meant to be either sent to
+  # Airbrake or ignored completely.
+  #
+  # @since v1.0.0
+  class Notice
+    ##
+    # @return [Hash{Symbol=>String}] the information about the notifier library
+    NOTIFIER = {
+      name: 'airbrake-ruby'.freeze,
+      version: Airbrake::AIRBRAKE_RUBY_VERSION,
+      url: 'https://github.com/airbrake/airbrake-ruby'.freeze
+    }.freeze
+
+    ##
+    # @return [Hash{Symbol=>String,Hash}] the information to be displayed in the
+    #   Context tab in the dashboard
+    CONTEXT = {
+      os: RUBY_PLATFORM,
+      language: "#{RUBY_ENGINE}/#{RUBY_VERSION}".freeze,
+      notifier: NOTIFIER
+    }.freeze
+
+    ##
+    # @return [Integer] the maxium size of the JSON payload in bytes
+    MAX_NOTICE_SIZE = 64000
+
+    ##
+    # @return [Integer] the maximum size of hashes, arrays and strings in the
+    #   notice.
+    PAYLOAD_MAX_SIZE = 10000
+
+    ##
+    # @return [Array<StandardError>] the list of possible exceptions that might
+    #   be raised when an object is converted to JSON
+    JSON_EXCEPTIONS = [
+      IOError,
+      NotImplementedError,
+      JSON::GeneratorError,
+      Encoding::UndefinedConversionError
+    ].freeze
+
+    # @return [Array<Symbol>] the list of keys that can be be overwritten with
+    #   {Airbrake::Notice#[]=}
+    WRITABLE_KEYS = %i[notifier context environment session params].freeze
+
+    ##
+    # @return [Array<Symbol>] parts of a Notice's payload that can be modified
+    #   by the truncator
+    TRUNCATABLE_KEYS = %i[errors environment session params].freeze
+
+    ##
+    # @return [String] the name of the host machine
+    HOSTNAME = Socket.gethostname.freeze
+
+    ##
+    # @return [String]
+    DEFAULT_SEVERITY = 'error'.freeze
+
+    ##
+    # @since v1.7.0
+    # @return [Hash{Symbol=>Object}] the hash with arbitrary objects to be used
+    #   in filters
+    attr_reader :stash
+
+    def initialize(config, exception, params = {})
+      @config = config
+
+      @payload = {
+        errors: NestedException.new(config, exception).as_json,
+        context: context,
+        environment: {
+          program_name: $PROGRAM_NAME
+        },
+        session: {},
+        params: params
+      }
+      @stash = { exception: exception }
+      @truncator = Airbrake::Truncator.new(PAYLOAD_MAX_SIZE)
+
+      extract_custom_attributes(exception)
+    end
+
+    ##
+    # Converts the notice to JSON. Calls +to_json+ on each object inside
+    # notice's payload. Truncates notices, JSON representation of which is
+    # bigger than {MAX_NOTICE_SIZE}.
+    #
+    # @return [Hash{String=>String}, nil]
+    def to_json
+      loop do
+        begin
+          json = @payload.to_json
+        rescue *JSON_EXCEPTIONS => ex
+          @config.logger.debug("#{LOG_LABEL} `notice.to_json` failed: #{ex.class}: #{ex}")
+        else
+          return json if json && json.bytesize <= MAX_NOTICE_SIZE
+        end
+
+        break if truncate == 0
+      end
+    end
+
+    ##
+    # Ignores a notice. Ignored notices never reach the Airbrake dashboard.
+    #
+    # @return [void]
+    # @see #ignored?
+    # @note Ignored noticed can't be unignored
+    def ignore!
+      @payload = nil
+    end
+
+    ##
+    # Checks whether the notice was ignored.
+    #
+    # @return [Boolean]
+    # @see #ignore!
+    def ignored?
+      @payload.nil?
+    end
+
+    ##
+    # Reads a value from notice's payload.
+    # @return [Object]
+    #
+    # @raise [Airbrake::Error] if the notice is ignored
+    def [](key)
+      raise_if_ignored
+      @payload[key]
+    end
+
+    ##
+    # Writes a value to the payload hash. Restricts unrecognized
+    # writes.
+    # @example
+    #   notice[:params][:my_param] = 'foobar'
+    #
+    # @return [void]
+    # @raise [Airbrake::Error] if the notice is ignored
+    # @raise [Airbrake::Error] if the +key+ is not recognized
+    # @raise [Airbrake::Error] if the root value is not a Hash
+    def []=(key, value)
+      raise_if_ignored
+
+      unless WRITABLE_KEYS.include?(key)
+        raise Airbrake::Error,
+              ":#{key} is not recognized among #{WRITABLE_KEYS}"
+      end
+
+      unless value.respond_to?(:to_hash)
+        raise Airbrake::Error, "Got #{value.class} value, wanted a Hash"
+      end
+
+      @payload[key] = value.to_hash
+    end
+
+    private
+
+    def context
+      {
+        version: @config.app_version,
+        # We ensure that root_directory is always a String, so it can always be
+        # converted to JSON in a predictable manner (when it's a Pathname and in
+        # Rails environment, it converts to unexpected JSON).
+        rootDirectory: @config.root_directory.to_s,
+        environment: @config.environment,
+
+        # Make sure we always send hostname.
+        hostname: HOSTNAME,
+
+        severity: DEFAULT_SEVERITY
+      }.merge(CONTEXT).delete_if { |_key, val| val.nil? || val.empty? }
+    end
+
+    def raise_if_ignored
+      return unless ignored?
+      raise Airbrake::Error, 'cannot access ignored notice'
+    end
+
+    def truncate
+      TRUNCATABLE_KEYS.each { |key| @truncator.truncate(self[key]) }
+
+      new_max_size = @truncator.reduce_max_size
+      if new_max_size == 0
+        @config.logger.error(
+          "#{LOG_LABEL} truncation failed. File an issue at " \
+          "https://github.com/airbrake/airbrake-ruby " \
+          "and attach the following payload: #{@payload}"
+        )
+      end
+
+      new_max_size
+    end
+
+    def extract_custom_attributes(exception)
+      return unless exception.respond_to?(:to_airbrake)
+      attributes = nil
+
+      begin
+        attributes = exception.to_airbrake
+      rescue StandardError => ex
+        @config.logger.error(
+          "#{LOG_LABEL} #{exception.class}#to_airbrake failed: #{ex.class}: #{ex}"
+        )
+      end
+
+      return unless attributes
+
+      begin
+        @payload.merge!(attributes)
+      rescue TypeError
+        @config.logger.error(
+          "#{LOG_LABEL} #{exception.class}#to_airbrake failed:" \
+          " #{attributes} must be a Hash"
+        )
+      end
+    end
+  end
+end

data/spec/fixtures/project_root/long_line.txt

@@ -0,0 +1 @@
+loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong line

data/spec/fixtures/project_root/short_file.rb

@@ -0,0 +1,3 @@
+module Banana
+  attr_reader :bingo
+end

data/spec/fixtures/project_root/vendor/bundle/ignored_file.rb

@@ -0,0 +1,5 @@
+module IgnoredFile
+  def ignore_me
+    puts 'Anybody here?'
+  end
+end

data/spec/helpers.rb

@@ -0,0 +1,9 @@
+module Helpers
+  def fixture_path(filename)
+    File.expand_path(File.join('spec', 'fixtures', filename))
+  end
+
+  def project_root_path(filename)
+    fixture_path(File.join('project_root', filename))
+  end
+end

data/spec/ignorable_spec.rb

@@ -0,0 +1,14 @@
+RSpec.describe Airbrake::Ignorable do
+  let(:klass) do
+    mod = subject
+    Class.new { include(mod) }
+  end
+
+  it "ignores includee" do
+    instance = klass.new
+    expect(instance).not_to be_ignored
+
+    instance.ignore!
+    expect(instance).to be_ignored
+  end
+end

data/spec/inspectable_spec.rb

@@ -0,0 +1,45 @@
+RSpec.describe Airbrake::Inspectable do
+  let(:klass) do
+    mod = subject
+    Class.new do
+      include(mod)
+
+      def initialize
+        @config = Airbrake::Config.new
+        @filter_chain = nil
+      end
+    end
+  end
+
+  describe "#inspect" do
+    it "displays object information" do
+      instance = klass.new
+      expect(instance.inspect).to match(/
+        #<:0x\w+\s
+          project_id=""\s
+          project_key=""\s
+          host="http.+"\s
+          filter_chain=nil>
+      /x)
+    end
+  end
+
+  describe "#pretty_print" do
+    it "displays object information in a beautiful way" do
+      q = PP.new
+
+      instance = klass.new
+      # Guarding is needed to fix JRuby failure:
+      # NoMethodError: undefined method `[]' for nil:NilClass
+      q.guard_inspect_key { instance.pretty_print(q) }
+
+      expect(q.output).to match(/
+        #<:0x\w+\s
+          project_id=""\s
+          project_key=""\s
+          host="http.+"\s
+          filter_chain=nil
+      /x)
+    end
+  end
+end

data/spec/monotonic_time_spec.rb

@@ -0,0 +1,12 @@
+RSpec.describe Airbrake::MonotonicTime do
+  describe ".time_in_ms" do
+    it "returns monotonic time in milliseconds" do
+      expect(subject.time_in_ms).to be_a(Float)
+    end
+
+    it "always returns time in the future" do
+      old_time = subject.time_in_ms
+      expect(subject.time_in_ms).to be > old_time
+    end
+  end
+end

data/spec/nested_exception_spec.rb

@@ -0,0 +1,73 @@
+RSpec.describe Airbrake::NestedException do
+  describe "#as_json" do
+    context "given exceptions with backtraces" do
+      it "unwinds nested exceptions" do
+        begin
+          begin
+            raise AirbrakeTestError
+          rescue AirbrakeTestError
+            Ruby21Error.raise_error('bingo')
+          end
+        rescue Ruby21Error => ex
+          nested_exception = described_class.new(ex)
+          exceptions = nested_exception.as_json
+
+          expect(exceptions.size).to eq(2)
+          expect(exceptions[0][:message]).to eq('bingo')
+          expect(exceptions[1][:message]).to eq('App crashed!')
+          expect(exceptions[0][:backtrace]).not_to be_empty
+          expect(exceptions[1][:backtrace]).not_to be_empty
+        end
+      end
+
+      it "unwinds no more than 3 nested exceptions" do
+        begin
+          begin
+            raise AirbrakeTestError
+          rescue AirbrakeTestError
+            begin
+              Ruby21Error.raise_error('bongo')
+            rescue Ruby21Error
+              begin
+                Ruby21Error.raise_error('bango')
+              rescue Ruby21Error
+                Ruby21Error.raise_error('bingo')
+              end
+            end
+          end
+        rescue Ruby21Error => ex
+          nested_exception = described_class.new(ex)
+          exceptions = nested_exception.as_json
+
+          expect(exceptions.size).to eq(3)
+          expect(exceptions[0][:message]).to eq('bingo')
+          expect(exceptions[1][:message]).to eq('bango')
+          expect(exceptions[2][:message]).to eq('bongo')
+          expect(exceptions[0][:backtrace]).not_to be_empty
+          expect(exceptions[1][:backtrace]).not_to be_empty
+        end
+      end
+    end
+
+    context "given exceptions without backtraces" do
+      it "sets backtrace to nil" do
+        begin
+          begin
+            raise AirbrakeTestError
+          rescue AirbrakeTestError => ex2
+            ex2.set_backtrace([])
+            Ruby21Error.raise_error('bingo')
+          end
+        rescue Ruby21Error => ex1
+          ex1.set_backtrace([])
+          nested_exception = described_class.new(ex1)
+          exceptions = nested_exception.as_json
+
+          expect(exceptions.size).to eq(2)
+          expect(exceptions[0][:backtrace]).to be_empty
+          expect(exceptions[1][:backtrace]).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/notice_notifier_spec.rb

@@ -0,0 +1,356 @@
+RSpec.describe Airbrake::NoticeNotifier do
+  before do
+    Airbrake::Config.instance = Airbrake::Config.new(
+      project_id: 1,
+      project_key: 'abc',
+      logger: Logger.new('/dev/null'),
+      performance_stats: true
+    )
+  end
+
+  describe "#new" do
+    describe "default filter addition" do
+      before { allow_any_instance_of(Airbrake::FilterChain).to receive(:add_filter) }
+
+      it "appends the context filter" do
+        expect_any_instance_of(Airbrake::FilterChain).to receive(:add_filter)
+          .with(instance_of(Airbrake::Filters::ContextFilter))
+        subject
+      end
+
+      it "appends the exception attributes filter" do
+        expect_any_instance_of(Airbrake::FilterChain).to receive(:add_filter)
+          .with(instance_of(Airbrake::Filters::ExceptionAttributesFilter))
+        subject
+      end
+    end
+  end
+
+  describe "#notify" do
+    let(:endpoint) { 'https://api.airbrake.io/api/v3/projects/1/notices' }
+
+    let(:body) do
+      {
+        'id' => '00054414-b147-6ffa-85d6-1524d83362a6',
+        'url' => 'http://localhost/locate/00054414-b147-6ffa-85d6-1524d83362a6'
+      }.to_json
+    end
+
+    before { stub_request(:post, endpoint).to_return(status: 201, body: body) }
+
+    it "returns a promise" do
+      expect(subject.notify('ex')).to be_an(Airbrake::Promise)
+      sleep 1
+    end
+
+    it "refines the notice object" do
+      subject.add_filter { |n| n[:params] = { foo: 'bar' } }
+      notice = subject.build_notice('ex')
+      subject.notify(notice)
+      expect(notice[:params]).to eq(foo: 'bar')
+      sleep 1
+    end
+
+    context "when config is invalid" do
+      before { Airbrake::Config.instance.merge(project_id: nil) }
+
+      it "returns a rejected promise" do
+        promise = subject.notify({})
+        expect(promise).to be_rejected
+      end
+    end
+
+    context "when a notice is not ignored" do
+      it "yields the notice" do
+        expect { |b| subject.notify('ex', &b) }
+          .to yield_with_args(Airbrake::Notice)
+        sleep 1
+      end
+    end
+
+    context "when a notice is ignored via a filter" do
+      before { subject.add_filter(&:ignore!) }
+
+      it "yields the notice" do
+        expect { |b| subject.notify('ex', &b) }
+          .to yield_with_args(Airbrake::Notice)
+      end
+
+      it "returns a rejected promise" do
+        value = subject.notify('ex').value
+        expect(value['error']).to match(/was marked as ignored/)
+      end
+    end
+
+    context "when a notice is ignored via an inline filter" do
+      before { subject.add_filter { raise AirbrakeTestError } }
+
+      it "doesn't invoke regular filters" do
+        expect { subject.notify('ex', &:ignore!) }.not_to raise_error
+      end
+    end
+
+    context "when async sender has workers" do
+      it "sends an exception asynchronously" do
+        expect_any_instance_of(Airbrake::AsyncSender).to receive(:send)
+        subject.notify('foo', bingo: 'bango')
+      end
+    end
+
+    context "when async sender doesn't have workers" do
+      it "sends an exception synchronously" do
+        expect_any_instance_of(Airbrake::AsyncSender)
+          .to receive(:has_workers?).and_return(false)
+        expect_any_instance_of(Airbrake::SyncSender).to receive(:send)
+        subject.notify('foo', bingo: 'bango')
+      end
+    end
+
+    context "when the provided environment is ignored" do
+      before do
+        Airbrake::Config.instance.merge(
+          environment: 'test',
+          ignore_environments: %w[test]
+        )
+      end
+
+      it "doesn't send an notice" do
+        expect_any_instance_of(Airbrake::AsyncSender).not_to receive(:send)
+        subject.notify('foo', bingo: 'bango')
+      end
+
+      it "returns a rejected promise" do
+        promise = subject.notify('foo', bingo: 'bango')
+        expect(promise.value).to eq('error' => "current environment 'test' is ignored")
+      end
+    end
+  end
+
+  describe "#notify_sync" do
+    let(:endpoint) { 'https://api.airbrake.io/api/v3/projects/1/notices' }
+
+    let(:body) do
+      {
+        'id' => '00054414-b147-6ffa-85d6-1524d83362a6',
+        'url' => 'http://localhost/locate/00054414-b147-6ffa-85d6-1524d83362a6'
+      }
+    end
+
+    before { stub_request(:post, endpoint).to_return(status: 201, body: body.to_json) }
+
+    it "returns a reponse hash" do
+      expect(subject.notify_sync('ex')).to eq(body)
+    end
+
+    it "refines the notice object" do
+      subject.add_filter { |n| n[:params] = { foo: 'bar' } }
+      notice = subject.build_notice('ex')
+      subject.notify_sync(notice)
+      expect(notice[:params]).to eq(foo: 'bar')
+    end
+
+    it "sends an exception synchronously" do
+      subject.notify_sync('foo', bingo: 'bango')
+      expect(
+        a_request(:post, endpoint).with(
+          body: /"params":{.*"bingo":"bango".*}/
+        )
+      ).to have_been_made.once
+    end
+
+    context "when a notice is not ignored" do
+      it "yields the notice" do
+        expect { |b| subject.notify_sync('ex', &b) }
+          .to yield_with_args(Airbrake::Notice)
+      end
+    end
+
+    context "when a notice is ignored via a filter" do
+      before { subject.add_filter(&:ignore!) }
+
+      it "yields the notice" do
+        expect { |b| subject.notify_sync('ex', &b) }
+          .to yield_with_args(Airbrake::Notice)
+      end
+
+      it "returns an error hash" do
+        response = subject.notify_sync('ex')
+        expect(response['error']).to match(/was marked as ignored/)
+      end
+    end
+
+    context "when a notice is ignored via an inline filter" do
+      before { subject.add_filter { raise AirbrakeTestError } }
+
+      it "doesn't invoke regular filters" do
+        expect { subject.notify('ex', &:ignore!) }.not_to raise_error
+      end
+    end
+
+    context "when the provided environment is ignored" do
+      before do
+        Airbrake::Config.instance.merge(
+          environment: 'test', ignore_environments: %w[test]
+        )
+      end
+
+      it "doesn't send an notice" do
+        expect_any_instance_of(Airbrake::SyncSender).not_to receive(:send)
+        subject.notify_sync('foo', bingo: 'bango')
+      end
+
+      it "returns an error hash" do
+        expect(subject.notify_sync('foo'))
+          .to eq('error' => "current environment 'test' is ignored")
+      end
+    end
+  end
+
+  describe "#add_filter" do
+    context "given a block" do
+      it "appends a new filter to the filter chain" do
+        notifier = subject
+        b = proc {}
+        expect_any_instance_of(Airbrake::FilterChain)
+          .to receive(:add_filter) { |*args| expect(args.last).to be(b) }
+        notifier.add_filter(&b)
+      end
+    end
+
+    context "given a class" do
+      it "appends a new filter to the filter chain" do
+        notifier = subject
+        klass = Class.new
+        expect_any_instance_of(Airbrake::FilterChain)
+          .to receive(:add_filter).with(klass)
+        notifier.add_filter(klass)
+      end
+    end
+  end
+
+  describe "#build_notice" do
+    context "when given exception is another notice" do
+      it "merges params with the notice" do
+        notice = subject.build_notice('ex')
+        other = subject.build_notice(notice, foo: 'bar')
+        expect(other[:params]).to eq(foo: 'bar')
+      end
+
+      it "it returns the provided notice" do
+        notice = subject.build_notice('ex')
+        other = subject.build_notice(notice, foo: 'bar')
+        expect(other).to eq(notice)
+      end
+    end
+
+    context "when given exception is an Exception" do
+      it "prevents mutation of passed-in params hash" do
+        params = { immutable: true }
+        notice = subject.build_notice('ex', params)
+        notice[:params][:mutable] = true
+        expect(params).to eq(immutable: true)
+      end
+
+      context "and also when it doesn't have own backtrace" do
+        context "and when the generated backtrace consists only of library frames" do
+          it "returns the full generated backtrace" do
+            backtrace = [
+              "/lib/airbrake-ruby/a.rb:84:in `build_notice'",
+              "/lib/airbrake-ruby/b.rb:124:in `send_notice'"
+            ]
+            allow(Kernel).to receive(:caller).and_return(backtrace)
+
+            notice = subject.build_notice(Exception.new)
+
+            expect(notice[:errors].first[:backtrace]).to eq(
+              [
+                { file: '/lib/airbrake-ruby/a.rb', line: 84, function: 'build_notice' },
+                { file: '/lib/airbrake-ruby/b.rb', line: 124, function: 'send_notice' }
+              ]
+            )
+          end
+        end
+
+        context "and when the generated backtrace consists of mixed frames" do
+          it "returns the filtered backtrace" do
+            backtrace = [
+              "/airbrake-ruby/lib/airbrake-ruby/a.rb:84:in `b'",
+              "/airbrake-ruby/lib/foo/b.rb:84:in `build'",
+              "/airbrake-ruby/lib/bar/c.rb:124:in `send'"
+            ]
+            allow(Kernel).to receive(:caller).and_return(backtrace)
+
+            notice = subject.build_notice(Exception.new)
+
+            expect(notice[:errors].first[:backtrace]).to eq(
+              [
+                { file: '/airbrake-ruby/lib/foo/b.rb', line: 84, function: 'build' },
+                { file: '/airbrake-ruby/lib/bar/c.rb', line: 124, function: 'send' }
+              ]
+            )
+          end
+        end
+      end
+    end
+
+    # TODO: this seems to be bugged. Fix later.
+    context "when given exception is a Java exception", skip: true do
+      before do
+        expect(Airbrake::Backtrace).to receive(:java_exception?).and_return(true)
+      end
+
+      it "automatically generates the backtrace" do
+        backtrace = [
+          "org/jruby/RubyKernel.java:998:in `eval'",
+          "/ruby/stdlib/irb/workspace.rb:87:in `evaluate'",
+          "/ruby/stdlib/irb.rb:489:in `block in eval_input'"
+        ]
+        allow(Kernel).to receive(:caller).and_return(backtrace)
+
+        notice = subject.build_notice(Exception.new)
+
+        # rubocop:disable Metrics/LineLength
+        expect(notice[:errors].first[:backtrace]).to eq(
+          [
+            { file: 'org/jruby/RubyKernel.java', line: 998, function: 'eval' },
+            { file: '/ruby/stdlib/irb/workspace.rb', line: 87, function: 'evaluate' },
+            { file: '/ruby/stdlib/irb.rb:489', line: 489, function: 'block in eval_input' }
+          ]
+        )
+        # rubocop:enable Metrics/LineLength
+      end
+    end
+
+    context "when async sender is closed" do
+      before do
+        expect_any_instance_of(Airbrake::AsyncSender)
+          .to receive(:closed?).and_return(true)
+      end
+
+      it "raises error" do
+        expect { subject.build_notice(Exception.new) }.to raise_error(
+          Airbrake::Error,
+          'attempted to build Exception with closed Airbrake instance'
+        )
+      end
+    end
+  end
+
+  describe "#close" do
+    it "sends the close message to async sender" do
+      expect_any_instance_of(Airbrake::AsyncSender).to receive(:close)
+      subject.close
+    end
+  end
+
+  describe "#configured?" do
+    it { is_expected.to be_configured }
+  end
+
+  describe "#merge_context" do
+    it "merges the provided context with the notice object" do
+      expect_any_instance_of(Hash).to receive(:merge!).with(apples: 'oranges')
+      subject.merge_context(apples: 'oranges')
+    end
+  end
+end