airbrake-ruby 4.7.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/options_spec.rb

@@ -0,0 +1,259 @@
+RSpec.describe Airbrake::NoticeNotifier do
+  let(:project_id) { 105138 }
+  let(:project_key) { 'fd04e13d806a90f96614ad8e529b2822' }
+  let(:localhost) { 'http://localhost:8080' }
+
+  let(:endpoint) do
+    "https://api.airbrake.io/api/v3/projects/#{project_id}/notices"
+  end
+
+  let(:params) { {} }
+  let(:ex) { AirbrakeTestError.new }
+
+  before do
+    stub_request(:post, endpoint).to_return(status: 201, body: '{}')
+
+    Airbrake::Config.instance = Airbrake::Config.new(
+      project_id: project_id,
+      project_key: project_key
+    )
+  end
+
+  describe "options" do
+    describe ":host" do
+      context "when custom" do
+        shared_examples 'endpoint' do |host, endpoint, title|
+          before { Airbrake::Config.instance.merge(host: host) }
+
+          example(title) do
+            stub_request(:post, endpoint).to_return(status: 201, body: '{}')
+            subject.notify_sync(ex)
+
+            expect(a_request(:post, endpoint)).to have_been_made.once
+          end
+        end
+
+        path = '/api/v3/projects/105138/notices'
+
+        context "given a full host" do
+          include_examples('endpoint', localhost = 'http://localhost:8080',
+                           URI.join(localhost, path),
+                           "sends notices to the specified host's endpoint")
+        end
+
+        context "given a full host" do
+          include_examples('endpoint', localhost = 'http://localhost',
+                           URI.join(localhost, path),
+                           "assumes port 80 by default")
+        end
+
+        context "given a host without scheme" do
+          include_examples 'endpoint', localhost = 'localhost:8080',
+                           URI.join("https://#{localhost}", path),
+                           "assumes https by default"
+        end
+
+        context "given only hostname" do
+          include_examples 'endpoint', localhost = 'localhost',
+                           URI.join("https://#{localhost}", path),
+                           "assumes https and port 80 by default"
+        end
+      end
+    end
+
+    describe ":root_directory" do
+      before do
+        subject.add_filter(
+          Airbrake::Filters::RootDirectoryFilter.new('/home/kyrylo/code')
+        )
+      end
+
+      it "filters out frames" do
+        subject.notify_sync(ex)
+
+        expect(
+          a_request(:post, endpoint)
+          .with(body: %r|{"file":"/PROJECT_ROOT/airbrake/ruby/spec/airbrake_spec.+|)
+        ).to have_been_made.once
+      end
+
+      context "when present and is a" do
+        shared_examples 'root directory' do |dir|
+          before { Airbrake::Config.instance.merge(root_directory: dir) }
+
+          it "being included into the notice's payload" do
+            subject.notify_sync(ex)
+            expect(
+              a_request(:post, endpoint)
+              .with(body: %r{"rootDirectory":"/bingo/bango"})
+            ).to have_been_made.once
+          end
+        end
+
+        context "String" do
+          include_examples 'root directory', '/bingo/bango'
+        end
+
+        context "Pathname" do
+          include_examples 'root directory', Pathname.new('/bingo/bango')
+        end
+      end
+    end
+
+    describe ":proxy" do
+      let(:proxy) do
+        WEBrick::HTTPServer.new(
+          Port: 0,
+          Logger: WEBrick::Log.new('/dev/null'),
+          AccessLog: []
+        )
+      end
+
+      let(:requests) { Queue.new }
+
+      let(:proxy_params) do
+        { host: 'localhost',
+          port: proxy.config[:Port],
+          user: 'user',
+          password: 'password' }
+      end
+
+      before do
+        Airbrake::Config.instance.merge(
+          proxy: proxy_params,
+          host: "http://localhost:#{proxy.config[:Port]}"
+        )
+
+        proxy.mount_proc '/' do |req, res|
+          requests << req
+          res.status = 201
+          res.body = "OK\n"
+        end
+
+        Thread.new { proxy.start }
+      end
+
+      after { proxy.stop }
+
+      it "is being used if configured" do
+        if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.6.0")
+          skip(
+            "We use Webmock 2, which doesn't support Ruby 2.6+. It's " \
+            "safe to run this test on 2.6+ once we upgrade to Webmock 3.5+"
+          )
+        end
+        subject.notify_sync(ex)
+
+        proxied_request = requests.pop(true)
+
+        expect(proxied_request.header['proxy-authorization'].first)
+          .to eq('Basic dXNlcjpwYXNzd29yZA==')
+
+        # rubocop:disable Metrics/LineLength
+        expect(proxied_request.request_line)
+          .to eq("POST http://localhost:#{proxy.config[:Port]}/api/v3/projects/105138/notices HTTP/1.1\r\n")
+        # rubocop:enable Metrics/LineLength
+      end
+    end
+
+    describe ":environment" do
+      context "when present" do
+        before { Airbrake::Config.instance.merge(environment: :production) }
+
+        it "being included into the notice's payload" do
+          subject.notify_sync(ex)
+          expect(
+            a_request(:post, endpoint)
+            .with(body: /"context":{.*"environment":"production".*}/)
+          ).to have_been_made.once
+        end
+      end
+    end
+
+    describe ":ignore_environments" do
+      shared_examples 'sent notice' do |params|
+        before { Airbrake::Config.instance.merge(params) }
+
+        it "sends a notice" do
+          subject.notify_sync(ex)
+          expect(a_request(:post, endpoint)).to have_been_made
+        end
+      end
+
+      shared_examples 'ignored notice' do |params|
+        before { Airbrake::Config.instance.merge(params) }
+
+        it "ignores exceptions occurring in envs that were not configured" do
+          subject.notify_sync(ex)
+          expect(a_request(:post, endpoint)).not_to have_been_made
+        end
+      end
+
+      context "when env is set and ignore_environments doesn't mention it" do
+        params = {
+          environment: :development,
+          ignore_environments: [:production]
+        }
+
+        include_examples 'sent notice', params
+      end
+
+      context "when the current env and notify envs are the same" do
+        params = {
+          environment: :development,
+          ignore_environments: %i[production development]
+        }
+
+        include_examples 'ignored notice', params
+
+        it "returns early and doesn't try to parse the given exception" do
+          expect(Airbrake::Notice).not_to receive(:new)
+          expect(subject.notify_sync(ex))
+            .to eq('error' => "current environment 'development' is ignored")
+          expect(a_request(:post, endpoint)).not_to have_been_made
+        end
+      end
+
+      context "when the current env is not set and notify envs are present" do
+        params = { ignore_environments: %i[production development] }
+
+        include_examples 'sent notice', params
+      end
+
+      context "when the current env is set and notify envs aren't" do
+        include_examples 'sent notice', environment: :development
+      end
+
+      context "when ignore_environments specifies a Regexp pattern" do
+        params = {
+          environment: :testing,
+          ignore_environments: ['staging', /test.+/]
+        }
+
+        include_examples 'ignored notice', params
+      end
+    end
+
+    describe ":blacklist_keys" do
+      # Fixes https://github.com/airbrake/airbrake-ruby/issues/276
+      context "when specified along with :whitelist_keys" do
+        context "and when context payload is present" do
+          before do
+            Airbrake::Config.instance.merge(
+              blacklist_keys: %i[password password_confirmation],
+              whitelist_keys: [:email, /user/i, 'account_id']
+            )
+          end
+
+          it "sends a notice" do
+            notice = subject.build_notice(ex)
+            notice[:context][:headers] = 'banana'
+            subject.notify_sync(notice)
+
+            expect(a_request(:post, endpoint)).to have_been_made
+          end
+        end
+      end
+    end
+  end
+end