rollbar 2.16.2 → 2.22.1

data/lib/rollbar/truncation.rb

@@ -4,6 +4,9 @@ require 'rollbar/truncation/raw_strategy'
 require 'rollbar/truncation/frames_strategy'
 require 'rollbar/truncation/strings_strategy'
 require 'rollbar/truncation/min_body_strategy'
+require 'rollbar/truncation/remove_request_strategy'
+require 'rollbar/truncation/remove_extra_strategy'
+require 'rollbar/truncation/remove_any_key_strategy'
 
 module Rollbar
   module Truncation
@@ -13,13 +16,17 @@ module Rollbar
     STRATEGIES = [RawStrategy,
                   FramesStrategy,
                   StringsStrategy,
-                  MinBodyStrategy]
+                  MinBodyStrategy,
+                  RemoveRequestStrategy,
+                  RemoveExtraStrategy,
+                  RemoveAnyKeyStrategy].freeze
 
-    def self.truncate(payload)
+    def self.truncate(payload, attempts = [])
       result = nil
 
       STRATEGIES.each do |strategy|
         result = strategy.call(payload)
+        attempts << result.bytesize
         break unless truncate?(result)
       end
 

data/lib/rollbar/truncation/min_body_strategy.rb

@@ -11,8 +11,7 @@ module Rollbar
       end
 
       def call(payload)
-        new_payload = Rollbar::Util.deep_copy(payload)
-        body = new_payload['data']['body']
+        body = payload['data']['body']
 
         if body['trace_chain']
           body['trace_chain'] = body['trace_chain'].map do |trace_data|
@@ -22,7 +21,7 @@ module Rollbar
           body['trace'] = truncate_trace_data(body['trace'])
         end
 
-        dump(new_payload)
+        dump(payload)
       end
 
       def truncate_trace_data(trace_data)

data/lib/rollbar/truncation/remove_any_key_strategy.rb

@@ -0,0 +1,123 @@
+require 'rollbar/util'
+
+module Rollbar
+  module Truncation
+    class RemoveAnyKeyStrategy
+      include ::Rollbar::Truncation::Mixin
+
+      attr_accessor :payload, :data, :sizes, :extracted_title
+
+      def self.call(payload)
+        new(payload).call
+      end
+
+      def initialize(payload)
+        @payload = payload
+        @data = payload['data']
+        @extracted_title = extract_title(data['body']) if data['body']
+      end
+
+      def call
+        remove_unknown_root_keys
+
+        json_payload = remove_oversized_data_keys
+
+        return json_payload if json_payload
+
+        dump(payload)
+      end
+
+      def remove_unknown_root_keys
+        payload.keys.reject { |key| root_keys.include?(key) }.each do |key|
+          truncation_key['root'] ||= {}
+          size = dump(payload.delete(key)).bytesize
+          truncation_key['root'][key] = "unknown root key removed, size: #{size} bytes"
+        end
+      end
+
+      def remove_oversized_data_keys
+        data_keys.keys.sort { |a, b| data_keys[b] <=> data_keys[a] }.each do |key|
+          json_payload = remove_key_and_return_payload(key)
+
+          return json_payload unless truncate?(json_payload)
+        end
+
+        false
+      end
+
+      def remove_key_and_return_payload(key)
+        size = data_keys[key]
+
+        data.delete(key)
+
+        replace_message_body if key == 'body'
+
+        truncation_key[key] = "key removed, size: #{size} bytes"
+
+        dump(payload)
+      end
+
+      def replace_message_body
+        data['body'] = message_key
+        data['title'] ||= extracted_title if extracted_title
+      end
+
+      def truncation_key
+        @truncation_key ||=
+          # initialize the diagnostic key for truncation
+          (data['notifier']['diagnostic'] ||= {}) &&
+          (data['notifier']['diagnostic']['truncation'] ||= {})
+      end
+
+      def root_keys
+        # Valid keys in root of payload
+        %w[access_token data]
+      end
+
+      def skip_keys
+        # Don't try to truncate these data keys
+        %w[notifier uuid title platform language framework level]
+      end
+
+      def message_key
+        # use this message if data.body gets removed
+        {
+          'message' => {
+            'body' => 'Payload keys removed due to oversized payload. See diagnostic key'
+          }
+        }
+      end
+
+      def extract_title(body)
+        return body['message']['body'] if body['message'] && body['message']['body']
+        return extract_title_from_trace(body['trace']) if body['trace']
+        return extract_title_from_trace(body['trace_chain'][0]) if body['trace_chain'] && body['trace_chain'][0]
+      end
+
+      def extract_title_from_trace(trace)
+        exception = trace['exception']
+
+        "#{exception['class']}: #{exception['message']}"
+      end
+
+      def data_keys
+        @data_keys ||= {}.tap do |hash|
+          data.keys.reject { |key| skip_keys.include?(key) }.each do |key|
+            set_key_size(key, hash)
+          end
+        end
+      end
+
+      def set_key_size(key, hash)
+        size = dump(data[key]).bytesize
+        hash[key] = size
+      rescue ::JSON::GeneratorError
+        hash[key] = 0 # don't try to truncate non JSON object
+
+        # Log it
+        truncation_key['non_json_keys'] ||= {}
+        truncation_key['non_json_keys'][key] = data[key].class
+      end
+    end
+  end
+end

data/lib/rollbar/truncation/remove_extra_strategy.rb

@@ -0,0 +1,35 @@
+require 'rollbar/util'
+
+module Rollbar
+  module Truncation
+    class RemoveExtraStrategy
+      include ::Rollbar::Truncation::Mixin
+
+      def self.call(payload)
+        new.call(payload)
+      end
+
+      def call(payload)
+        body = payload['data']['body']
+
+        delete_message_extra(body)
+        delete_trace_chain_extra(body)
+        delete_trace_extra(body)
+
+        dump(payload)
+      end
+
+      def delete_message_extra(body)
+        body['message'].delete('extra') if body['message'] && body['message']['extra']
+      end
+
+      def delete_trace_chain_extra(body)
+        body['trace_chain'][0].delete('extra') if body['trace_chain'] && body['trace_chain'][0]['extra']
+      end
+
+      def delete_trace_extra(body)
+        body['trace'].delete('extra') if body['trace'] && body['trace']['extra']
+      end
+    end
+  end
+end

data/lib/rollbar/truncation/remove_request_strategy.rb

@@ -0,0 +1,21 @@
+require 'rollbar/util'
+
+module Rollbar
+  module Truncation
+    class RemoveRequestStrategy
+      include ::Rollbar::Truncation::Mixin
+
+      def self.call(payload)
+        new.call(payload)
+      end
+
+      def call(payload)
+        data = payload['data']
+
+        data.delete('request') if data['request']
+
+        dump(payload)
+      end
+    end
+  end
+end

data/lib/rollbar/truncation/strings_strategy.rb

@@ -6,7 +6,7 @@ module Rollbar
     class StringsStrategy
       include ::Rollbar::Truncation::Mixin
 
-      STRING_THRESHOLDS = [1024, 512, 256]
+      STRING_THRESHOLDS = [1024, 512, 256].freeze
 
       def self.call(payload)
         new.call(payload)
@@ -14,13 +14,12 @@ module Rollbar
 
       def call(payload)
         result = nil
-        new_payload = Rollbar::Util.deep_copy(payload)
 
         STRING_THRESHOLDS.each do |threshold|
           truncate_proc = truncate_strings_proc(threshold)
 
-          ::Rollbar::Util.iterate_and_update(new_payload, truncate_proc)
-          result = dump(new_payload)
+          ::Rollbar::Util.iterate_and_update(payload, truncate_proc)
+          result = dump(payload)
 
           break unless truncate?(result)
         end

data/lib/rollbar/util.rb

@@ -1,83 +1,101 @@
 require 'rollbar/util/hash'
 
 module Rollbar
-  module Util
-    def self.iterate_and_update(obj, block)
-      return if obj.frozen?
+  module Util # :nodoc:
+    def self.iterate_and_update(obj, block, seen = {})
+      return if obj.frozen? || seen[obj.object_id]
+
+      seen[obj.object_id] = true
+
       if obj.is_a?(Array)
-        for i in 0 ... obj.size
-          value = obj[i]
-
-          if value.is_a?(::Hash) || value.is_a?(Array)
-            self.iterate_and_update(value, block)
-          else
-            obj[i] = block.call(value)
-          end
-        end
+        iterate_and_update_array(obj, block, seen)
       else
-        key_updates = []
+        iterate_and_update_hash(obj, block, seen)
+      end
+    end
 
-        obj.each do |k, v|
-          new_key = nil
+    def self.iterate_and_update_array(array, block, seen)
+      array.each_with_index do |value, i|
+        if value.is_a?(::Hash) || value.is_a?(Array)
+          iterate_and_update(value, block, seen)
+        else
+          array[i] = block.call(value)
+        end
+      end
+    end
 
-          if v.is_a?(::Hash) || v.is_a?(Array)
-            self.iterate_and_update(v, block)
-            new_key = block.call(k)
-          else
-            new_key = block.call(k)
-            obj[k] = block.call(v)
-          end
+    def self.iterate_and_update_hash(obj, block, seen)
+      obj.keys.each do |k|
+        v = obj[k]
+        new_key = block.call(k)
 
-          key_updates.push([k, new_key]) if new_key != k
+        if v.is_a?(::Hash) || v.is_a?(Array)
+          iterate_and_update(v, block, seen)
+        else
+          obj[k] = block.call(v)
         end
 
-        key_updates.each do |old_key, new_key|
-          obj[new_key] = obj[old_key]
-          obj.delete(old_key)
+        if new_key != k
+          obj[new_key] = obj[k]
+          obj.delete(k)
         end
       end
     end
 
-    def self.iterate_and_update_hash(hash, block)
-      hash.each do |k, v|
-        if v.is_a?(::Hash)
-          self.iterate_and_update_hash(v, block)
-        else
-          hash[k] = block.call(k, v)
-        end
+    def self.deep_copy(obj, copied = {})
+      # if we've already made a copy, return it.
+      return copied[obj.object_id] if copied[obj.object_id]
+
+      result = clone_obj(obj)
+
+      # Memoize the cloned object before recursive calls to #deep_copy below.
+      # This is the point of doing the work in two steps.
+      copied[obj.object_id] = result
+
+      if obj.is_a?(::Hash)
+        obj.each { |k, v| result[k] = deep_copy(v, copied) }
+      elsif obj.is_a?(Array)
+        obj.each { |v| result << deep_copy(v, copied) }
       end
+
+      result
     end
 
-    def self.deep_copy(obj)
+    def self.clone_obj(obj)
       if obj.is_a?(::Hash)
-        result = obj.clone
-        obj.each { |k, v| result[k] = deep_copy(v)}
-        result
+        obj.dup
       elsif obj.is_a?(Array)
-        result = obj.clone
-        result.clear
-        obj.each { |v| result << deep_copy(v)}
-        result
+        obj.dup.clear
       else
         obj
       end
     end
 
-    def self.deep_merge(hash1, hash2)
+    def self.deep_merge(hash1, hash2, merged = {})
       hash1 ||= {}
       hash2 ||= {}
 
+      # If we've already merged these two objects, return hash1 now.
+      return hash1 if merged[hash1.object_id] && merged[hash1.object_id].include?(hash2.object_id)
+
+      merged[hash1.object_id] ||= []
+      merged[hash1.object_id] << hash2.object_id
+
+      perform_deep_merge(hash1, hash2, merged)
+
+      hash1
+    end
+
+    def self.perform_deep_merge(hash1, hash2, merged) # rubocop:disable Metrics/AbcSize
       hash2.each_key do |k|
         if hash1[k].is_a?(::Hash) && hash2[k].is_a?(::Hash)
-          hash1[k] = deep_merge(hash1[k], hash2[k])
+          hash1[k] = deep_merge(hash1[k], hash2[k], merged)
         elsif hash1[k].is_a?(Array) && hash2[k].is_a?(Array)
           hash1[k] += deep_copy(hash2[k])
         elsif hash2[k]
           hash1[k] = deep_copy(hash2[k])
         end
       end
-
-      hash1
     end
 
     def self.truncate(str, length)
@@ -97,5 +115,17 @@ module Rollbar
 
       Util.iterate_and_update(payload, normalizer)
     end
+
+    def self.count_method_in_stack(method_symbol, file_path = '')
+      caller.grep(/#{file_path}.*#{method_symbol.to_s}/).count
+    end
+
+    def self.method_in_stack(method_symbol, file_path = '')
+      count_method_in_stack(method_symbol, file_path) > 0
+    end
+
+    def self.method_in_stack_twice(method_symbol, file_path = '')
+      count_method_in_stack(method_symbol, file_path) > 1
+    end
   end
 end

data/lib/rollbar/util/hash.rb

@@ -1,24 +1,48 @@
 module Rollbar
   module Util
-    module Hash
-      def self.deep_stringify_keys(hash)
+    module Hash # :nodoc:
+      def self.deep_stringify_keys(hash, seen = {})
+        return if seen[hash.object_id]
+
+        seen[hash.object_id] = true
+        replace_seen_children(hash, seen)
+
         hash.reduce({}) do |h, (key, value)|
-          h[key.to_s] = map_value(value, :deep_stringify_keys)
+          h[key.to_s] = map_value(value, :deep_stringify_keys, seen)
 
           h
         end
       end
 
-      def self.map_value(thing, m)
+      def self.map_value(thing, meth, seen)
         case thing
         when ::Hash
-          send(m, thing)
+          send(meth, thing, seen)
         when Array
-          thing.map { |v| map_value(v, m) }
+          if seen[thing.object_id]
+            thing
+          else
+            seen[thing.object_id] = true
+            replace_seen_children(thing, seen)
+            thing.map { |v| map_value(v, meth, seen) }
+          end
         else
           thing
         end
       end
+
+      def self.replace_seen_children(thing, seen)
+        case thing
+        when ::Hash
+          thing.keys.each do |key|
+            thing[key] = "removed circular reference: #{thing[key]}" if seen[thing[key].object_id]
+          end
+        when Array
+          thing.each_with_index do |_, i|
+            thing[i] = "removed circular reference: #{thing[i]}" if seen[thing[i].object_id]
+          end
+        end
+      end
     end
   end
 end