airbrake-ruby 4.6.0 → 6.2.2

data/spec/filters/thread_filter_spec.rb

@@ -1,277 +0,0 @@
-RSpec.describe Airbrake::Filters::ThreadFilter do
-  let(:notice) { Airbrake::Notice.new(AirbrakeTestError.new) }
-
-  def new_thread
-    Thread.new do
-      th = Thread.current
-
-      # Ensure a thread always has some variable to make sure the
-      # :fiber_variables Hash is always present.
-      th[:random_var] = 42
-      yield(th)
-    end.join
-  end
-
-  describe "thread variables" do
-    shared_examples "expected thread variable" do |var|
-      it "attaches the thread variable" do
-        new_thread do |th|
-          th.thread_variable_set(:bingo, var)
-          subject.call(notice)
-        end
-
-        expect(notice[:params][:thread][:thread_variables][:bingo]).to eq(var)
-      end
-    end
-
-    context "given nil" do
-      include_examples "expected thread variable", nil
-    end
-
-    context "given true" do
-      include_examples "expected thread variable", true
-    end
-
-    context "given false" do
-      include_examples "expected thread variable", false
-    end
-
-    context "given a String" do
-      include_examples "expected thread variable", 'bango'
-    end
-
-    context "given a Symbol" do
-      include_examples "expected thread variable", :bango
-    end
-
-    context "given a Regexp" do
-      include_examples "expected thread variable", /bango/
-    end
-
-    context "given an Integer" do
-      include_examples "expected thread variable", 1
-    end
-
-    context "given a Float" do
-      include_examples "expected thread variable", 1.01
-    end
-
-    context "given an Object" do
-      it "converts it to a String and attaches" do
-        new_thread do |th|
-          th.thread_variable_set(:bingo, Object.new)
-          subject.call(notice)
-        end
-
-        vars = notice[:params][:thread][:thread_variables]
-        expect(vars[:bingo]).to match(/\A#<Object:.+>\z/)
-      end
-    end
-
-    context "given an Array of nested Hashes with complex objects" do
-      let(:var) do
-        [
-          {
-            bango: {
-              bongo: [
-                {
-                  bish: {
-                    bash: 'foo',
-                    bosh: Object.new
-                  }
-                }
-              ]
-            }
-          },
-          123
-        ]
-      end
-
-      it "converts objects to a safe objects" do
-        new_thread do |th|
-          th.thread_variable_set(:bingo, var)
-          subject.call(notice)
-        end
-
-        vars = notice[:params][:thread][:thread_variables]
-        expect(vars[:bingo]).to(
-          match(
-            [
-              {
-                bango: {
-                  bongo: [
-                    {
-                      bish: {
-                        bash: 'foo',
-                        bosh: /\A#<Object:.+>\z/
-                      }
-                    }
-                  ]
-                }
-              },
-              123
-            ]
-          )
-        )
-      end
-    end
-
-    it "ignores thread variables starting with an underscore" do
-      var = :__recursive_key__
-
-      new_thread do |th|
-        th.thread_variable_set(var, :bingo)
-        subject.call(notice)
-      end
-
-      thread_variables = notice[:params][:thread][:thread_variables]
-      expect(thread_variables).to be_nil
-    end
-  end
-
-  describe "fiber variables" do
-    shared_examples "expected fiber variable" do |var|
-      it "attaches the fiber variable" do
-        new_thread do |th|
-          th[:bingo] = var
-          subject.call(notice)
-        end
-
-        expect(notice[:params][:thread][:fiber_variables][:bingo]).to eq(var)
-      end
-    end
-
-    context "given nil" do
-      include_examples "expected fiber variable", nil
-    end
-
-    context "given true" do
-      include_examples "expected fiber variable", true
-    end
-
-    context "given false" do
-      include_examples "expected fiber variable", false
-    end
-
-    context "given a String" do
-      include_examples "expected fiber variable", 'bango'
-    end
-
-    context "given a Symbol" do
-      include_examples "expected fiber variable", :bango
-    end
-
-    context "given a Regexp" do
-      include_examples "expected fiber variable", /bango/
-    end
-
-    context "given an Integer" do
-      include_examples "expected fiber variable", 1
-    end
-
-    context "given a Float" do
-      include_examples "expected fiber variable", 1.01
-    end
-
-    context "given an Object" do
-      it "converts it to a String and attaches" do
-        new_thread do |th|
-          th[:bingo] = Object.new
-          subject.call(notice)
-        end
-
-        vars = notice[:params][:thread][:fiber_variables]
-        expect(vars[:bingo]).to match(/\A#<Object:.+>\z/)
-      end
-    end
-
-    context "given an Array of nested Hashes with complex objects" do
-      let(:var) do
-        [
-          {
-            bango: {
-              bongo: [
-                {
-                  bish: {
-                    bash: 'foo',
-                    bosh: Object.new
-                  }
-                }
-              ]
-            }
-          },
-          123
-        ]
-      end
-
-      it "converts objects to a safe objects" do
-        new_thread do |th|
-          th[:bingo] = var
-          subject.call(notice)
-        end
-
-        vars = notice[:params][:thread][:fiber_variables]
-        expect(vars[:bingo]).to(
-          match(
-            [
-              {
-                bango: {
-                  bongo: [
-                    {
-                      bish: {
-                        bash: 'foo',
-                        bosh: /\A#<Object:.+>\z/
-                      }
-                    }
-                  ]
-                }
-              },
-              123
-            ]
-          )
-        )
-      end
-    end
-  end
-
-  it "appends name", skip: !Thread.current.respond_to?(:name) do
-    new_thread do |th|
-      th.name = 'bingo'
-      subject.call(notice)
-    end
-
-    expect(notice[:params][:thread][:name]).to eq('bingo')
-  end
-
-  it "appends thread inspect (self)" do
-    subject.call(notice)
-    expect(notice[:params][:thread][:self]).to match(/\A#<Thread:.+ run>\z/)
-  end
-
-  it "appends thread group" do
-    subject.call(notice)
-    expect(notice[:params][:thread][:group][0]).to match(/\A#<Thread:.+ run>\z/)
-  end
-
-  it "appends priority" do
-    subject.call(notice)
-    expect(notice[:params][:thread][:priority]).to eq(0)
-  end
-
-  it "appends safe_level", skip: Airbrake::JRUBY do
-    subject.call(notice)
-    expect(notice[:params][:thread][:safe_level]).to eq(0)
-  end
-
-  it "ignores fiber variables starting with an underscore" do
-    key = :__recursive_key__
-
-    new_thread do |th|
-      th[key] = :bingo
-      subject.call(notice)
-    end
-
-    fiber_variables = notice[:params][:thread][:fiber_variables]
-    expect(fiber_variables[key]).to be_nil
-  end
-end

data/spec/fixtures/notroot.txt

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

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/monotonic_time_spec.rb

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

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