airbrake-ruby 6.1.0-java → 6.1.1-java

data/spec/fixtures/project_root/code.rb

@@ -1,221 +0,0 @@
-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

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

data/spec/fixtures/project_root/short_file.rb

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

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

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

data/spec/helpers.rb

@@ -1,9 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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/loggable_spec.rb

@@ -1,17 +0,0 @@
-RSpec.describe Airbrake::Loggable do
-  describe ".instance" do
-    it "returns a logger" do
-      expect(described_class.instance).to be_a(Logger)
-    end
-  end
-
-  describe "#logger" do
-    subject(:class_with_logger) do
-      Class.new { include Airbrake::Loggable }.new
-    end
-
-    it "returns a logger that has Logger::WARN severity" do
-      expect(class_with_logger.logger.level).to eq(Logger::WARN)
-    end
-  end
-end

data/spec/monotonic_time_spec.rb

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

data/spec/nested_exception_spec.rb

@@ -1,73 +0,0 @@
-RSpec.describe Airbrake::NestedException do
-  describe "#as_json" do
-    context "given exceptions with backtraces" do
-      # rubocop:disable RSpec/MultipleExpectations
-      it "unwinds nested exceptions" do
-        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
-      # rubocop:enable RSpec/MultipleExpectations
-
-      # rubocop:disable RSpec/MultipleExpectations
-      it "unwinds no more than 3 nested exceptions" do
-        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
-      # rubocop:enable RSpec/MultipleExpectations
-    end
-
-    context "given exceptions without backtraces" do
-      # rubocop:disable RSpec/MultipleExpectations
-      it "sets backtrace to nil" do
-        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
-      # rubocop:enable RSpec/MultipleExpectations
-    end
-  end
-end

data/spec/notice_notifier/options_spec.rb

@@ -1,269 +0,0 @@
-RSpec.describe Airbrake::NoticeNotifier do
-  subject(:notice_notifier) { described_class.new }
-
-  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: '{}')
-            notice_notifier.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 with port" 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
-        notice_notifier.add_filter(
-          Airbrake::Filters::RootDirectoryFilter.new('/home/kyrylo/code'),
-        )
-      end
-
-      it "filters out frames" do
-        notice_notifier.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
-            notice_notifier.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
-
-    # rubocop:disable RSpec/MultipleMemoizedHelpers
-    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
-        notice_notifier.notify_sync(ex)
-
-        proxied_request = requests.pop(true)
-
-        expect(proxied_request.header['proxy-authorization'].first)
-          .to eq('Basic dXNlcjpwYXNzd29yZA==')
-
-        # rubocop:disable Layout/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 Layout/LineLength
-      end
-    end
-    # rubocop:enable RSpec/MultipleMemoizedHelpers
-
-    describe ":environment" do
-      context "when present" do
-        before { Airbrake::Config.instance.merge(environment: :production) }
-
-        it "being included into the notice's payload" do
-          notice_notifier.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
-          notice_notifier.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
-          notice_notifier.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
-          allow(Airbrake::Notice).to receive(:new)
-
-          expect(notice_notifier.notify_sync(ex))
-            .to eq('error' => "current environment 'development' is ignored")
-
-          expect(Airbrake::Notice).not_to have_received(:new)
-        end
-
-        it "doesn't make an HTTP request" do
-          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 ":blocklist_keys" do
-      # Fixes https://github.com/airbrake/airbrake-ruby/issues/276
-      context "when specified along with :allowlist_keys" do
-        context "and when context payload is present" do
-          before do
-            Airbrake::Config.instance.merge(
-              blocklist_keys: %i[password password_confirmation],
-              allowlist_keys: [:email, /user/i, 'account_id'],
-            )
-          end
-
-          it "sends a notice" do
-            notice = notice_notifier.build_notice(ex)
-            notice[:context][:headers] = 'banana'
-            notice_notifier.notify_sync(notice)
-
-            expect(a_request(:post, endpoint)).to have_been_made
-          end
-        end
-      end
-    end
-  end
-end