airbrake-ruby 2.5.1 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c824b0d3f9372ab651d5e308df76080b2000f519
-  data.tar.gz: 2fc17c502f0bd474db41d00697a12bcdfeb0ac6e
+  metadata.gz: 10cd1c4c112ec8325d9e800128cb3598ecca5e79
+  data.tar.gz: e06b612001f91e0a6e928250d735fc57b2d9a313
 SHA512:
-  metadata.gz: 191e18fafeddbfe6501f5acdf17cd5ec9fd759e41e78b2c3637625b87024561d2ab9599292c420607051b0043079f88490d8470f6caebe6e5e431640a5bdcf43
-  data.tar.gz: 1d16bdffa0fd2c37184b2e95be230b6816e3e9b5d0c2f01b09c9867d70e8d0551f73b9001de35eb0529a0104b7d59b1c86a6fa8236bc7d742bad2101e9844899
+  metadata.gz: 39edba81094187bde03fd1f5fc916255737dde0fabcd0f5c720075c22c97d914c602bdda046669db3b48680ec0bae798bf4225a4645d4a08e450171de76a34d0
+  data.tar.gz: 3d0b4de47de97f5cc9bd425a70aa1128449df90329f33e93f843c6729571cd2ca38d371477fa98ea46d380c116dd7bf20a670f230bef59eeb34d8fd72d1b0f23

data/lib/airbrake-ruby/notice.rb

@@ -180,7 +180,9 @@ module Airbrake
     end
 
     def truncate
-      TRUNCATABLE_KEYS.each { |key| @truncator.truncate_object(self[key]) }
+      TRUNCATABLE_KEYS.each do |key|
+        @payload[key] = @truncator.truncate(@payload[key])
+      end
 
       new_max_size = @truncator.reduce_max_size
       if new_max_size == 0

data/lib/airbrake-ruby/truncator.rb

@@ -1,55 +1,34 @@
 module Airbrake
-  ##
   # This class is responsible for truncation of too big objects. Mainly, you
   # should use it for simple objects such as strings, hashes, & arrays.
   #
   # @api private
   # @since v1.0.0
   class Truncator
-    ##
     # @return [Hash] the options for +String#encode+
     ENCODING_OPTIONS = { invalid: :replace, undef: :replace }.freeze
 
-    ##
     # @return [String] the temporary encoding to be used when fixing invalid
     #   strings with +ENCODING_OPTIONS+
     TEMP_ENCODING = 'utf-16'.freeze
 
-    ##
     # @param [Integer] max_size maximum size of hashes, arrays and strings
     def initialize(max_size)
       @max_size = max_size
     end
 
-    ##
-    # Performs deep truncation of arrays, hashes and sets. Uses a
+    # Performs deep truncation of arrays, hashes, sets & strings. Uses a
     # placeholder for recursive objects (`[Circular]`).
     #
-    # @param [Hash,Array] object The object to truncate
-    # @param [Hash] seen The hash that helps to detect recursion
-    # @return [void]
-    # @note This method is public to simplify testing. You probably want to use
-    #   {truncate_notice} instead
-    def truncate_object(object, seen = {})
-      return seen[object] if seen[object]
-
-      seen[object] = '[Circular]'.freeze
-      truncated =
-        if object.is_a?(Hash)
-          truncate_hash(object, seen)
-        elsif object.is_a?(Array)
-          truncate_array(object, seen)
-        elsif object.is_a?(Set)
-          truncate_set(object, seen)
-        else
-          raise Airbrake::Error,
-                "cannot truncate object: #{object} (#{object.class})"
-        end
-      seen[object] = truncated
+    # @param [Object] object The object to truncate
+    # @param [Set] seen The cache that helps to detect recursion
+    # @return [Object] truncated object
+    def truncate(object, seen = Set.new)
+      return '[Circular]'.freeze if seen.include?(object)
+      truncate_object(object, seen << object)
     end
 
-    ##
-    # Reduces maximum allowed size of the truncated object.
+    # Reduces maximum allowed size of hashes, arrays, sets & strings by half.
     # @return [Integer] current +max_size+ value
     def reduce_max_size
       @max_size /= 2
@@ -57,67 +36,68 @@ module Airbrake
 
     private
 
-    def truncate(val, seen)
-      case val
-      when String
-        truncate_string(val)
-      when Array, Hash, Set
-        truncate_object(val, seen)
-      when Numeric, TrueClass, FalseClass, Symbol, NilClass
-        val
+    def truncate_object(object, seen)
+      case object
+      when Hash then truncate_hash(object, seen)
+      when Array then truncate_array(object, seen)
+      when Set then truncate_set(object, seen)
+      when String then truncate_string(object)
+      when Numeric, TrueClass, FalseClass, Symbol, NilClass then object
       else
-        stringified_val =
-          begin
-            val.to_json
-          rescue *Notice::JSON_EXCEPTIONS
-            val.to_s
-          end
-        truncate_string(stringified_val)
+        truncate_string(stringify_object(object))
       end
     end
 
     def truncate_string(str)
-      str = replace_invalid_characters!(str)
-      return str if str.length <= @max_size
-      str.slice(0, @max_size) + '[Truncated]'.freeze
+      fixed_str = replace_invalid_characters(str)
+      return fixed_str if fixed_str.length <= @max_size
+      (fixed_str.slice(0, @max_size) + '[Truncated]').freeze
     end
 
-    ##
-    # Replaces invalid characters in string with arbitrary encoding.
-    #
-    # @param [String] str The string to replace characters
-    # @return [String] a UTF-8 encoded string
-    # @note This method mutates +str+ unless it's frozen,
-    #   in which case it creates a duplicate
-    # @see https://github.com/flori/json/commit/3e158410e81f94dbbc3da6b7b35f4f64983aa4e3
-    def replace_invalid_characters!(str)
-      encoding = str.encoding
-      utf8_string = (encoding == Encoding::UTF_8 || encoding == Encoding::ASCII)
-      return str if utf8_string && str.valid_encoding?
-
-      str = str.dup if str.frozen?
-      str.encode!(TEMP_ENCODING, ENCODING_OPTIONS) if utf8_string
-      str.encode!('utf-8', ENCODING_OPTIONS)
+    def stringify_object(object)
+      object.to_json
+    rescue *Notice::JSON_EXCEPTIONS
+      object.to_s
     end
 
     def truncate_hash(hash, seen)
+      truncated_hash = {}
       hash.each_with_index do |(key, val), idx|
-        if idx < @max_size
-          hash[key] = truncate(val, seen)
-        else
-          hash.delete(key)
-        end
+        break if idx + 1 > @max_size
+        truncated_hash[key] = truncate(val, seen)
       end
+
+      truncated_hash.freeze
     end
 
     def truncate_array(array, seen)
-      array.slice(0, @max_size).map! { |val| truncate(val, seen) }
+      array.slice(0, @max_size).map! { |elem| truncate(elem, seen) }.freeze
     end
 
     def truncate_set(set, seen)
-      set.keep_if.with_index { |_val, idx| idx < @max_size }.map! do |val|
-        truncate(val, seen)
+      truncated_set = Set.new
+
+      set.each do |elem|
+        truncated_set << truncate(elem, seen)
+        break if truncated_set.size >= @max_size
       end
+
+      truncated_set.freeze
+    end
+
+    # Replaces invalid characters in a string with arbitrary encoding.
+    #
+    # @param [String] str The string to replace characters
+    # @return [String] a UTF-8 encoded string
+    # @see https://github.com/flori/json/commit/3e158410e81f94dbbc3da6b7b35f4f64983aa4e3
+    def replace_invalid_characters(str)
+      encoding = str.encoding
+      utf8_string = (encoding == Encoding::UTF_8 || encoding == Encoding::ASCII)
+      return str if utf8_string && str.valid_encoding?
+
+      temp_str = str.dup
+      temp_str.encode!(TEMP_ENCODING, ENCODING_OPTIONS) if utf8_string
+      temp_str.encode!('utf-8', ENCODING_OPTIONS)
     end
   end
 end

data/lib/airbrake-ruby/version.rb

@@ -4,5 +4,5 @@
 module Airbrake
   ##
   # @return [String] the library version
-  AIRBRAKE_RUBY_VERSION = '2.5.1'.freeze
+  AIRBRAKE_RUBY_VERSION = '2.6.0'.freeze
 end

data/spec/fixtures/project_root/code.rb

@@ -180,7 +180,7 @@ module Airbrake
     end
 
     def truncate
-      TRUNCATABLE_KEYS.each { |key| @truncator.truncate_object(self[key]) }
+      TRUNCATABLE_KEYS.each { |key| @truncator.truncate(self[key]) }
 
       new_max_size = @truncator.reduce_max_size
       if new_max_size == 0

data/spec/truncator_spec.rb

@@ -1,437 +1,214 @@
 require 'spec_helper'
 
 RSpec.describe Airbrake::Truncator do
-  let(:max_size) { 1000 }
-  let(:truncated_len) { '[Truncated]'.length }
-  let(:max_len) { max_size + truncated_len }
-
-  before do
-    @truncator = described_class.new(max_size)
+  def multiply_by_2_max_len(chr)
+    chr * 2 * max_len
   end
 
-  describe "#truncate_object" do
-    describe "error backtrace" do
-      let(:error) do
-        { type: 'AirbrakeTestError', message: 'App crashed!', backtrace: [] }
-      end
-
-      before do
-        backtrace = Array.new(size) do
-          { file: 'foo.rb', line: 23, function: '<main>' }
-        end
-
-        @error = error.merge(backtrace: backtrace)
-        described_class.new(max_size).truncate_object(@error)
-      end
-
-      context "when long" do
-        let(:size) { 2003 }
+  describe "#truncate" do
+    let(:max_size) { 3 }
+    let(:truncated) { '[Truncated]' }
+    let(:max_len) { max_size + truncated.length }
 
-        it "truncates the backtrace to the max size" do
-          expect(@error[:backtrace].size).to eq(1000)
-        end
-      end
+    subject { described_class.new(max_size).truncate(object) }
 
-      context "when short" do
-        let(:size) { 999 }
+    context "given a frozen string" do
+      let(:object) { multiply_by_2_max_len('a') }
 
-        it "does not truncate the backtrace" do
-          expect(@error[:backtrace].size).to eq(size)
-        end
+      it "returns a new truncated frozen string" do
+        expect(subject.length).to eq(max_len)
+        expect(subject).to be_frozen
       end
     end
 
-    describe "error message" do
-      let(:error) do
-        { type: 'AirbrakeTestError', message: 'App crashed!', backtrace: [] }
+    context "given a frozen hash of strings" do
+      let(:object) do
+        {
+          banana: multiply_by_2_max_len('a'),
+          kiwi: multiply_by_2_max_len('b'),
+          strawberry: 'c',
+          shrimp: 'd'
+        }.freeze
       end
 
-      before do
-        @error = error.merge(message: message)
-        described_class.new(max_size).truncate_object(@error)
-      end
+      it "returns a new truncated frozen hash" do
+        expect(subject.size).to eq(max_size)
+        expect(subject).to be_frozen
 
-      context "when long" do
-        let(:message) { 'App crashed!' * 2000 }
+        expect(subject).to eq(
+          banana: 'aaa[Truncated]', kiwi: 'bbb[Truncated]', strawberry: 'c'
+        )
+        expect(subject[:banana]).to be_frozen
+        expect(subject[:kiwi]).to be_frozen
+        expect(subject[:strawberry]).not_to be_frozen
+      end
+    end
 
-        it "truncates the message" do
-          expect(@error[:message].length).to eq(max_len)
-        end
+    context "given a frozen array of strings" do
+      let(:object) do
+        [
+          multiply_by_2_max_len('a'),
+          'b',
+          multiply_by_2_max_len('c'),
+          'd'
+        ].freeze
       end
 
-      context "when short" do
-        let(:message) { 'App crashed!' }
-        let(:msg_len) { message.length }
+      it "returns a new truncated frozen array" do
+        expect(subject.size).to eq(max_size)
+        expect(subject).to be_frozen
 
-        it "doesn't truncate the message" do
-          expect(@error[:message].length).to eq(msg_len)
-        end
+        expect(subject).to eq(['aaa[Truncated]', 'b', 'ccc[Truncated]'])
+        expect(subject[0]).to be_frozen
+        expect(subject[1]).not_to be_frozen
+        expect(subject[2]).to be_frozen
       end
     end
 
-    describe "given a hash with short values" do
-      let(:params) do
-        { bingo: 'bango', bongo: 'bish', bash: 'bosh' }
+    context "given a frozen set of strings" do
+      let(:object) do
+        Set.new([
+          multiply_by_2_max_len('a'),
+          'b',
+          multiply_by_2_max_len('c'),
+          'd'
+        ]).freeze
       end
 
-      it "doesn't get truncated" do
-        @truncator.truncate_object(params)
-        expect(params).to eq(bingo: 'bango', bongo: 'bish', bash: 'bosh')
+      it "returns a new truncated frozen array" do
+        expect(subject.size).to eq(max_size)
+        expect(subject).to be_frozen
+
+        expect(subject).to eq(
+          Set.new(['aaa[Truncated]', 'b', 'ccc[Truncated]'])
+        )
+        expect(subject).to be_frozen
       end
     end
 
-    describe "given a hash with a lot of elements" do
-      context "the elements of which are also hashes with a lot of elements" do
-        let(:params) do
-          Hash[(0...4124).each_cons(2).to_a].tap do |h|
-            h[0] = Hash[(0...4124).each_cons(2).to_a]
-          end
+    context "given an arbitrary frozen object that responds to #to_json" do
+      let(:object) do
+        obj = Object.new
+        def obj.to_json
+          '{"object":"shrimp"}'
         end
+        obj.freeze
+      end
 
-        it "truncates all the hashes to the max allowed size" do
-          expect(params.size).to eq(4123)
-          expect(params[0].size).to eq(4123)
-
-          @truncator.truncate_object(params)
+      it "converts the object to truncated JSON" do
+        expect(subject.length).to eq(max_len)
+        expect(subject).to be_frozen
 
-          expect(params.size).to eq(1000)
-          expect(params[0].size).to eq(1000)
-        end
+        expect(subject).to eq('{"o[Truncated]')
       end
     end
 
-    describe "given a set with a lot of elements" do
-      context "the elements of which are also sets with a lot of elements" do
-        let(:params) do
-          row = (0...4124).each_cons(2)
-          set = Set.new(row.to_a.unshift(row.to_a))
-          { bingo: set }
-        end
-
-        it "truncates all the sets to the max allowed size" do
-          expect(params[:bingo].size).to eq(4124)
-          expect(params[:bingo].to_a[0].size).to eq(4123)
-
-          @truncator.truncate_object(params)
-
-          expect(params[:bingo].size).to eq(1000)
-          expect(params[:bingo].to_a[0].size).to eq(1000)
-        end
+    context "given an arbitrary object that doesn't respond to #to_json" do
+      let(:object) do
+        obj = Object.new
+        allow(obj).to receive(:to_json).
+          and_raise(Airbrake::Notice::JSON_EXCEPTIONS.first)
+        obj
       end
 
-      context "including recursive sets" do
-        let(:params) do
-          a = Set.new
-          a << a << :bango
-          { bingo: a }
-        end
-
-        it "prevents recursion" do
-          @truncator.truncate_object(params)
-
-          expect(params).to eq(bingo: Set.new(['[Circular]', :bango]))
-        end
+      it "converts the object to a truncated string" do
+        expect(subject.length).to eq(max_len)
+        expect(subject).to eq('#<O[Truncated]')
       end
     end
 
-    describe "given an array with a lot of elements" do
-      context "the elements of which are also arrays with a lot of elements" do
-        let(:params) do
-          row = (0...4124).each_cons(2)
-          { bingo: row.to_a.unshift(row.to_a) }
-        end
-
-        it "truncates all the arrays to the max allowed size" do
-          expect(params[:bingo].size).to eq(4124)
-          expect(params[:bingo][0].size).to eq(4123)
-
-          @truncator.truncate_object(params)
-
-          expect(params[:bingo].size).to eq(1000)
-          expect(params[:bingo][0].size).to eq(1000)
-        end
+    shared_examples 'self returning objects' do |object|
+      it "returns the passed object" do
+        expect(described_class.new(max_size).truncate(object)).to eql(object)
       end
     end
 
-    describe "given a hash with long values" do
-      context "which are strings" do
-        let(:params) do
-          { bingo: 'bango' * 2000, bongo: 'bish', bash: 'bosh' * 1000 }
-        end
-
-        it "truncates only long strings" do
-          expect(params[:bingo].length).to eq(10_000)
-          expect(params[:bongo].length).to eq(4)
-          expect(params[:bash].length).to eq(4000)
-
-          @truncator.truncate_object(params)
+    [1, true, false, :symbol, nil].each do |object|
+      include_examples 'self returning objects', object
+    end
 
-          expect(params[:bingo].length).to eq(max_len)
-          expect(params[:bongo].length).to eq(4)
-          expect(params[:bash].length).to eq(max_len)
-        end
+    context "given a recursive array" do
+      let(:object) do
+        a = %w[aaaaa bb]
+        a << a
+        a << 'c'
+        a
       end
 
-      context "which are arrays" do
-        context "of long strings" do
-          let(:params) do
-            { bingo: ['foo', 'bango' * 2000, 'bar', 'piyo' * 2000, 'baz'],
-              bongo: 'bish',
-              bash: 'bosh' * 1000 }
-          end
-
-          it "truncates long strings in the array, but not short ones" do
-            expect(params[:bingo].map(&:length)).to eq([3, 10_000, 3, 8_000, 3])
-            expect(params[:bongo].length).to eq(4)
-            expect(params[:bash].length).to eq(4000)
-
-            @truncator.truncate_object(params)
-
-            expect(params[:bingo].map(&:length)).to eq([3, max_len, 3, max_len, 3])
-            expect(params[:bongo].length).to eq(4)
-            expect(params[:bash].length).to eq(max_len)
-          end
-        end
-
-        context "of short strings" do
-          let(:params) do
-            { bingo: %w[foo bar baz], bango: 'bongo', bish: 'bash' }
-          end
-
-          it "truncates long strings in the array, but not short ones" do
-            @truncator.truncate_object(params)
-            expect(params).
-              to eq(bingo: %w[foo bar baz], bango: 'bongo', bish: 'bash')
-          end
-        end
-
-        context "of hashes" do
-          context "with long strings" do
-            let(:params) do
-              { bingo: [{}, { bango: 'bongo', hoge: { fuga: 'piyo' * 2000 } }],
-                bish: 'bash',
-                bosh: 'foo' }
-            end
-
-            it "truncates the long string" do
-              expect(params[:bingo][1][:hoge][:fuga].length).to eq(8000)
-
-              @truncator.truncate_object(params)
-
-              expect(params[:bingo][0]).to eq({})
-              expect(params[:bingo][1][:bango]).to eq('bongo')
-              expect(params[:bingo][1][:hoge][:fuga].length).to eq(max_len)
-              expect(params[:bish]).to eq('bash')
-              expect(params[:bosh]).to eq('foo')
-            end
-          end
-
-          context "with short strings" do
-            let(:params) do
-              { bingo: [{}, { bango: 'bongo', hoge: { fuga: 'piyo' } }],
-                bish: 'bash',
-                bosh: 'foo' }
-            end
-
-            it "doesn't truncate the short string" do
-              expect(params[:bingo][1][:hoge][:fuga].length).to eq(4)
-
-              @truncator.truncate_object(params)
-
-              expect(params[:bingo][0]).to eq({})
-              expect(params[:bingo][1][:bango]).to eq('bongo')
-              expect(params[:bingo][1][:hoge][:fuga].length).to eq(4)
-              expect(params[:bish]).to eq('bash')
-              expect(params[:bosh]).to eq('foo')
-            end
-          end
-
-          context "with strings that equal to max_size" do
-            before do
-              @truncator = described_class.new(max_size)
-            end
-
-            let(:params) { { unicode: '1111' } }
-            let(:max_size) { params[:unicode].size }
-
-            it "is doesn't truncate the string" do
-              @truncator.truncate_object(params)
-
-              expect(params[:unicode].length).to eq(max_size)
-              expect(params[:unicode]).to match(/\A1{#{max_size}}\z/)
-            end
-          end
-        end
-
-        context "of recursive hashes" do
-          let(:params) do
-            a = { bingo: {} }
-            a[:bingo][:bango] = a
-          end
-
-          it "prevents recursion" do
-            @truncator.truncate_object(params)
-
-            expect(params).to eq(bingo: { bango: '[Circular]' })
-          end
-        end
-
-        context "of arrays" do
-          context "with long strings" do
-            let(:params) do
-              { bingo: ['bango', ['bongo', ['bish' * 2000]]],
-                bish: 'bash',
-                bosh: 'foo' }
-            end
-
-            it "truncates only the long string" do
-              expect(params[:bingo][1][1][0].length).to eq(8000)
-
-              @truncator.truncate_object(params)
-
-              expect(params[:bingo][1][1][0].length).to eq(max_len)
-            end
-          end
-        end
-
-        context "of recursive arrays" do
-          let(:params) do
-            a = []
-            a << a << :bango
-            { bingo: a }
-          end
-
-          it "prevents recursion" do
-            @truncator.truncate_object(params)
-
-            expect(params).to eq(bingo: ['[Circular]', :bango])
-          end
-        end
+      it "prevents recursion" do
+        expect(subject).to eq(['aaa[Truncated]', 'bb', '[Circular]'])
       end
+    end
 
-      context "which are arbitrary objects" do
-        context "with default #to_s" do
-          let(:params) { { bingo: Object.new } }
-
-          it "converts the object to a safe string" do
-            @truncator.truncate_object(params)
-
-            expect(params[:bingo]).to include('Object')
-          end
-        end
-
-        context "with redefined #to_s" do
-          let(:params) do
-            obj = Object.new
-
-            def obj.to_s
-              'bango' * 2000
-            end
-
-            { bingo: obj }
-          end
-
-          it "truncates the string if it's too long" do
-            @truncator.truncate_object(params)
-
-            expect(params[:bingo].length).to eq(max_len)
-          end
-        end
-
-        context "with other owner than Kernel" do
-          let(:params) do
-            mod = Module.new do
-              def to_s
-                "I am a fancy object" * 2000
-              end
-            end
-
-            klass = Class.new { include mod }
-
-            { bingo: klass.new }
-          end
+    context "given a recursive array with recursive hashes" do
+      let(:object) do
+        a = []
+        a << a
 
-          it "truncates the string it if it's long" do
-            @truncator.truncate_object(params)
+        h = {}
+        h[:k] = h
+        a << h << 'aaaa'
+      end
 
-            expect(params[:bingo].length).to eq(max_len)
-          end
-        end
+      it "prevents recursion" do
+        expect(subject).to eq(['[Circular]', { k: '[Circular]' }, 'aaa[Truncated]'])
+        expect(subject).to be_frozen
       end
+    end
 
-      context "multiple copies of the same object" do
-        let(:params) do
-          bingo = []
-          bango = ['bongo']
-          bingo << bango << bango
-          { bish: bingo }
-        end
+    context "given a recursive set with recursive arrays" do
+      let(:object) do
+        s = Set.new
+        s << s
 
-        it "are not being truncated" do
-          @truncator.truncate_object(params)
+        h = {}
+        h[:k] = h
+        s << h << 'aaaa'
+      end
 
-          expect(params).to eq(bish: [['bongo'], ['bongo']])
-        end
+      it "prevents recursion" do
+        expect(subject).to eq(
+          Set.new(['[Circular]', { k: '[Circular]' }, 'aaa[Truncated]'])
+        )
+        expect(subject).to be_frozen
       end
     end
 
-    describe "unicode payload" do
-      before do
-        @truncator = described_class.new(max_size - 1)
+    context "given a hash with long strings" do
+      let(:object) do
+        {
+          a: multiply_by_2_max_len('a'),
+          b: multiply_by_2_max_len('b'),
+          c: { d: multiply_by_2_max_len('d'), e: 'e' }
+        }
       end
 
-      describe "truncation" do
-        let(:params) { { unicode: "€€€€" } }
-        let(:max_size) { params[:unicode].length }
-
-        it "is performed correctly" do
-          @truncator.truncate_object(params)
-
-          expect(params[:unicode].length).to eq(max_len - 1)
-          expect(params[:unicode]).to match(/\A€{#{max_size - 1}}\[Truncated\]\z/)
-        end
+      it "truncates the long strings" do
+        expect(subject).to eq(
+          a: 'aaa[Truncated]', b: 'bbb[Truncated]', c: { d: 'ddd[Truncated]', e: 'e' }
+        )
+        expect(subject).to be_frozen
       end
+    end
 
-      describe "string encoding conversion" do
-        let(:params) { { unicode: "bad string€\xAE" } }
-        let(:max_size) { 100 }
-
-        it "converts strings to valid UTF-8" do
-          @truncator.truncate_object(params)
-
-          expect(params[:unicode]).to match(/\Abad string€[�\?]\z/)
-          expect { params.to_json }.not_to raise_error
-        end
-
-        it "converts ASCII-8BIT strings with invalid characters to UTF-8 correctly" do
-          # Shenanigans to get a bad ASCII-8BIT string. Direct conversion raises error.
-          encoded = Base64.encode64("\xD3\xE6\xBC\x9D\xBA").encode!('ASCII-8BIT')
-          bad_string = Base64.decode64(encoded)
-
-          params = { unicode: bad_string }
-
-          @truncator.truncate_object(params)
-
-          expect(params[:unicode]).to match(/[�\?]{4}/)
-        end
-
-        it "doesn't fail when string is frozen" do
-          encoded = Base64.encode64("\xD3\xE6\xBC\x9D\xBA").encode!('ASCII-8BIT')
-          bad_string = Base64.decode64(encoded).freeze
-
-          params = { unicode: bad_string }
-
-          @truncator.truncate_object(params)
+    context "given a string with valid unicode characters" do
+      let(:object) { "€€€€€" }
 
-          expect(params[:unicode]).to match(/[�\?]{4}/)
-        end
+      it "truncates the string" do
+        expect(subject).to eq("€€€[Truncated]")
       end
     end
 
-    describe "given a non-recursible object" do
-      it "raises error" do
-        expect { @truncator.truncate_object(:bingo) }.
-          to raise_error(Airbrake::Error, /cannot truncate object/)
+    context "given an ASCII-8BIT string with invalid characters" do
+      let(:object) do
+        # Shenanigans to get a bad ASCII-8BIT string. Direct conversion raises error.
+        encoded = Base64.encode64("\xD3\xE6\xBC\x9D\xBA").encode!('ASCII-8BIT')
+        Base64.decode64(encoded).freeze
+      end
+
+      it "converts and truncates the string to UTF-8" do
+        expect(subject).to eq("���[Truncated]")
+        expect(subject).to be_frozen
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: airbrake-ruby
 version: !ruby/object:Gem::Version
-  version: 2.5.1
+  version: 2.6.0
 platform: ruby
 authors:
 - Airbrake Technologies, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-26 00:00:00.000000000 Z
+date: 2017-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec