honeybadger 5.0.2 → 5.1.0

data/lib/honeybadger/util/request_payload.rb

@@ -1,41 +1,41 @@
-require 'honeybadger/util/sanitizer'
-
-module Honeybadger
-  module Util
-    # Constructs/sanitizes request data for notices
-    module RequestPayload
-      # Default values to use for request data.
-      DEFAULTS = {
-        url: nil,
-        component: nil,
-        action: nil,
-        params: {}.freeze,
-        session: {}.freeze,
-        cgi_data: {}.freeze
-      }.freeze
-
-      # Allowed keys.
-      KEYS = DEFAULTS.keys.freeze
-
-      # The cgi_data key where the raw Cookie header is stored.
-      HTTP_COOKIE_KEY = 'HTTP_COOKIE'.freeze
-
-      def self.build(opts = {})
-        sanitizer = opts.fetch(:sanitizer) { Sanitizer.new }
-
-        payload = DEFAULTS.dup
-        KEYS.each do |key|
-          next unless opts[key]
-          payload[key] = sanitizer.sanitize(opts[key])
-        end
-
-        payload[:url] = sanitizer.filter_url(payload[:url]) if payload[:url]
-        if payload[:cgi_data][HTTP_COOKIE_KEY]
-          payload[:cgi_data][HTTP_COOKIE_KEY] = sanitizer.filter_cookies(payload[:cgi_data][HTTP_COOKIE_KEY])
-        end
-
-        payload
-      end
-    end
-  end
-end
+require 'honeybadger/util/sanitizer'
+
+module Honeybadger
+  module Util
+    # Constructs/sanitizes request data for notices
+    module RequestPayload
+      # Default values to use for request data.
+      DEFAULTS = {
+        url: nil,
+        component: nil,
+        action: nil,
+        params: {}.freeze,
+        session: {}.freeze,
+        cgi_data: {}.freeze
+      }.freeze
+
+      # Allowed keys.
+      KEYS = DEFAULTS.keys.freeze
+
+      # The cgi_data key where the raw Cookie header is stored.
+      HTTP_COOKIE_KEY = 'HTTP_COOKIE'.freeze
+
+      def self.build(opts = {})
+        sanitizer = opts.fetch(:sanitizer) { Sanitizer.new }
+
+        payload = DEFAULTS.dup
+        KEYS.each do |key|
+          next unless opts[key]
+          payload[key] = sanitizer.sanitize(opts[key])
+        end
+
+        payload[:url] = sanitizer.filter_url(payload[:url]) if payload[:url]
+        if payload[:cgi_data][HTTP_COOKIE_KEY]
+          payload[:cgi_data][HTTP_COOKIE_KEY] = sanitizer.filter_cookies(payload[:cgi_data][HTTP_COOKIE_KEY])
+        end
+
+        payload
+      end
+    end
+  end
+end

data/lib/honeybadger/util/revision.rb

@@ -1,39 +1,39 @@
-module Honeybadger
-  module Util
-    class Revision
-      class << self
-        def detect(root = Dir.pwd)
-          revision = from_heroku ||
-            from_capistrano(root) ||
-            from_git
-
-          revision = revision.to_s.strip
-          return unless revision =~ /\S/
-
-          revision
-        end
-
-        private
-
-        # Requires (currently) alpha platform feature `heroku labs:enable
-        # runtime-dyno-metadata`
-        #
-        # See https://devcenter.heroku.com/articles/dyno-metadata
-        def from_heroku
-          ENV['HEROKU_SLUG_COMMIT']
-        end
-
-        def from_capistrano(root)
-          file = File.join(root, 'REVISION')
-          return nil unless File.file?(file)
-          File.read(file) rescue nil
-        end
-
-        def from_git
-          return nil unless File.directory?('.git')
-          `git rev-parse HEAD 2> #{File::NULL}` rescue nil
-        end
-      end
-    end
-  end
-end
+module Honeybadger
+  module Util
+    class Revision
+      class << self
+        def detect(root = Dir.pwd)
+          revision = from_heroku ||
+            from_capistrano(root) ||
+            from_git
+
+          revision = revision.to_s.strip
+          return unless revision =~ /\S/
+
+          revision
+        end
+
+        private
+
+        # Requires (currently) alpha platform feature `heroku labs:enable
+        # runtime-dyno-metadata`
+        #
+        # See https://devcenter.heroku.com/articles/dyno-metadata
+        def from_heroku
+          ENV['HEROKU_SLUG_COMMIT']
+        end
+
+        def from_capistrano(root)
+          file = File.join(root, 'REVISION')
+          return nil unless File.file?(file)
+          File.read(file) rescue nil
+        end
+
+        def from_git
+          return nil unless File.directory?('.git')
+          `git rev-parse HEAD 2> #{File::NULL}` rescue nil
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/util/sanitizer.rb

@@ -1,214 +1,214 @@
-require 'bigdecimal'
-require 'set'
-
-require 'honeybadger/conversions'
-
-module Honeybadger
-  module Util
-    # Sanitizer sanitizes data for sending to Honeybadger's API. The filters
-    # are based on Rails' HTTP parameter filter.
-    class Sanitizer
-      COOKIE_PAIRS = /[;,]\s?/
-      COOKIE_SEP = '='.freeze
-      COOKIE_PAIR_SEP = '; '.freeze
-
-      ENCODE_OPTS = { invalid: :replace, undef: :replace, replace: '?'.freeze }.freeze
-
-      BASIC_OBJECT = '#<BasicObject>'.freeze
-      DEPTH = '[DEPTH]'.freeze
-      FILTERED = '[FILTERED]'.freeze
-      RAISED = '[RAISED]'.freeze
-      RECURSION = '[RECURSION]'.freeze
-      TRUNCATED = '[TRUNCATED]'.freeze
-
-      IMMUTABLE = [NilClass, FalseClass, TrueClass, Symbol, Numeric, BigDecimal, Method].freeze
-
-      MAX_STRING_SIZE = 65536
-
-      VALID_ENCODINGS = [Encoding::UTF_8, Encoding::ISO_8859_1].freeze
-
-      def self.sanitize(data)
-        @sanitizer ||= new
-        @sanitizer.sanitize(data)
-      end
-
-      def initialize(max_depth: 20, filters: [])
-        @filters = !filters.empty?
-        @max_depth = max_depth
-
-        strings, @regexps, @blocks = [], [], []
-
-        filters.each do |item|
-          case item
-          when Proc
-            @blocks << item
-          when Regexp
-            @regexps << item
-          else
-            strings << Regexp.escape(item.to_s)
-          end
-        end
-
-        @deep_regexps, @regexps = @regexps.partition { |r| r.to_s.include?('\\.'.freeze) }
-        deep_strings, @strings = strings.partition { |s| s.include?('\\.'.freeze) }
-
-        @regexps << Regexp.new(strings.join('|'.freeze), true) unless strings.empty?
-        @deep_regexps << Regexp.new(deep_strings.join('|'.freeze), true) unless deep_strings.empty?
-      end
-
-      def sanitize(data, depth = 0, stack = nil, parents = [])
-        return BASIC_OBJECT if basic_object?(data)
-
-        if recursive?(data)
-          return RECURSION if stack && stack.include?(data.object_id)
-
-          stack = stack ? stack.dup : Set.new
-          stack << data.object_id
-        end
-
-        case data
-        when Hash
-          return DEPTH if depth >= max_depth
-
-          hash = data.to_hash
-          new_hash = {}
-
-          hash.each_pair do |key, value|
-            parents.push(key) if deep_regexps
-            key = key.kind_of?(Symbol) ? key : sanitize(key, depth+1, stack, parents)
-
-            if filter_key?(key, parents)
-              new_hash[key] = FILTERED
-            else
-              value = sanitize(value, depth+1, stack, parents)
-
-              if blocks.any? && !recursive?(value)
-                key = key.dup if can_dup?(key)
-                value = value.dup if can_dup?(value)
-                blocks.each { |b| b.call(key, value) }
-              end
-
-              new_hash[key] = value
-            end
-
-            parents.pop if deep_regexps
-          end
-
-          new_hash
-        when Array, Set
-          return DEPTH if depth >= max_depth
-
-          data.to_a.map do |value|
-            sanitize(value, depth+1, stack, parents)
-          end
-        when Numeric, TrueClass, FalseClass, NilClass
-          data
-        when String
-          sanitize_string(data)
-        when -> (d) { d.respond_to?(:to_honeybadger) }
-          return DEPTH if depth >= max_depth
-
-          begin
-            data = data.to_honeybadger
-          rescue
-            return RAISED
-          end
-
-          sanitize(data, depth+1, stack, parents)
-        else # all other objects
-          klass = data.class
-
-          begin
-            data = String(data)
-          rescue
-            return RAISED
-          end
-
-          return "#<#{klass.name}>" if inspected?(data)
-
-          sanitize_string(data)
-        end
-      end
-
-      def filter_cookies(raw_cookies)
-        return raw_cookies unless filters?
-
-        cookies = []
-
-        raw_cookies.to_s.split(COOKIE_PAIRS).each do |pair|
-          name, values = pair.split(COOKIE_SEP, 2)
-          values = FILTERED if filter_key?(name)
-          cookies << "#{name}=#{values}"
-        end
-
-        cookies.join(COOKIE_PAIR_SEP)
-      end
-
-      def filter_url(url)
-        return url unless filters?
-
-        filtered_url = url.to_s.dup
-
-        filtered_url.scan(/(?:^|&|\?)([^=?&]+)=([^&]+)/).each do |m|
-          next unless filter_key?(m[0])
-          filtered_url.gsub!(/#{Regexp.escape(m[1])}/, FILTERED)
-        end
-
-        filtered_url
-      end
-
-    private
-
-      attr_reader :max_depth, :regexps, :deep_regexps, :blocks
-
-      def filters?
-        !!@filters
-      end
-
-      def filter_key?(key, parents = nil)
-        return false unless filters?
-        return true if regexps.any? { |r| key =~ r }
-        return true if deep_regexps && parents && (joined = parents.join(".")) && deep_regexps.any? { |r| joined =~ r }
-        false
-      end
-
-      def sanitize_string(string)
-        string = valid_encoding(string)
-        return string unless string.respond_to?(:size) && string.size > MAX_STRING_SIZE
-        string[0...MAX_STRING_SIZE] + TRUNCATED
-      end
-
-      def valid_encoding?(string)
-        string.valid_encoding? && (
-          VALID_ENCODINGS.include?(string.encoding) ||
-          VALID_ENCODINGS.include?(Encoding.compatible?(''.freeze, string))
-        )
-      end
-
-      def valid_encoding(string)
-        return string if valid_encoding?(string)
-        string.encode(Encoding::UTF_8, **ENCODE_OPTS)
-      end
-
-      def recursive?(data)
-        data.is_a?(Hash) || data.is_a?(Array) || data.is_a?(Set) || data.respond_to?(:to_honeybadger)
-      end
-
-      def basic_object?(object)
-        object.respond_to?(:to_s)
-        false
-      rescue
-        # BasicObject doesn't respond to `#respond_to?`.
-        true
-      end
-
-      def can_dup?(obj)
-        !IMMUTABLE.any? {|k| obj.kind_of?(k) }
-      end
-
-      def inspected?(string)
-        String(string) =~ /#<.*>/
-      end
-    end
-  end
-end
+require 'bigdecimal'
+require 'set'
+
+require 'honeybadger/conversions'
+
+module Honeybadger
+  module Util
+    # Sanitizer sanitizes data for sending to Honeybadger's API. The filters
+    # are based on Rails' HTTP parameter filter.
+    class Sanitizer
+      COOKIE_PAIRS = /[;,]\s?/
+      COOKIE_SEP = '='.freeze
+      COOKIE_PAIR_SEP = '; '.freeze
+
+      ENCODE_OPTS = { invalid: :replace, undef: :replace, replace: '?'.freeze }.freeze
+
+      BASIC_OBJECT = '#<BasicObject>'.freeze
+      DEPTH = '[DEPTH]'.freeze
+      FILTERED = '[FILTERED]'.freeze
+      RAISED = '[RAISED]'.freeze
+      RECURSION = '[RECURSION]'.freeze
+      TRUNCATED = '[TRUNCATED]'.freeze
+
+      IMMUTABLE = [NilClass, FalseClass, TrueClass, Symbol, Numeric, BigDecimal, Method].freeze
+
+      MAX_STRING_SIZE = 65536
+
+      VALID_ENCODINGS = [Encoding::UTF_8, Encoding::ISO_8859_1].freeze
+
+      def self.sanitize(data)
+        @sanitizer ||= new
+        @sanitizer.sanitize(data)
+      end
+
+      def initialize(max_depth: 20, filters: [])
+        @filters = !filters.empty?
+        @max_depth = max_depth
+
+        strings, @regexps, @blocks = [], [], []
+
+        filters.each do |item|
+          case item
+          when Proc
+            @blocks << item
+          when Regexp
+            @regexps << item
+          else
+            strings << Regexp.escape(item.to_s)
+          end
+        end
+
+        @deep_regexps, @regexps = @regexps.partition { |r| r.to_s.include?('\\.'.freeze) }
+        deep_strings, @strings = strings.partition { |s| s.include?('\\.'.freeze) }
+
+        @regexps << Regexp.new(strings.join('|'.freeze), true) unless strings.empty?
+        @deep_regexps << Regexp.new(deep_strings.join('|'.freeze), true) unless deep_strings.empty?
+      end
+
+      def sanitize(data, depth = 0, stack = nil, parents = [])
+        return BASIC_OBJECT if basic_object?(data)
+
+        if recursive?(data)
+          return RECURSION if stack && stack.include?(data.object_id)
+
+          stack = stack ? stack.dup : Set.new
+          stack << data.object_id
+        end
+
+        case data
+        when Hash
+          return DEPTH if depth >= max_depth
+
+          hash = data.to_hash
+          new_hash = {}
+
+          hash.each_pair do |key, value|
+            parents.push(key) if deep_regexps
+            key = key.kind_of?(Symbol) ? key : sanitize(key, depth+1, stack, parents)
+
+            if filter_key?(key, parents)
+              new_hash[key] = FILTERED
+            else
+              value = sanitize(value, depth+1, stack, parents)
+
+              if blocks.any? && !recursive?(value)
+                key = key.dup if can_dup?(key)
+                value = value.dup if can_dup?(value)
+                blocks.each { |b| b.call(key, value) }
+              end
+
+              new_hash[key] = value
+            end
+
+            parents.pop if deep_regexps
+          end
+
+          new_hash
+        when Array, Set
+          return DEPTH if depth >= max_depth
+
+          data.to_a.map do |value|
+            sanitize(value, depth+1, stack, parents)
+          end
+        when Numeric, TrueClass, FalseClass, NilClass
+          data
+        when String
+          sanitize_string(data)
+        when -> (d) { d.respond_to?(:to_honeybadger) }
+          return DEPTH if depth >= max_depth
+
+          begin
+            data = data.to_honeybadger
+          rescue
+            return RAISED
+          end
+
+          sanitize(data, depth+1, stack, parents)
+        else # all other objects
+          klass = data.class
+
+          begin
+            data = String(data)
+          rescue
+            return RAISED
+          end
+
+          return "#<#{klass.name}>" if inspected?(data)
+
+          sanitize_string(data)
+        end
+      end
+
+      def filter_cookies(raw_cookies)
+        return raw_cookies unless filters?
+
+        cookies = []
+
+        raw_cookies.to_s.split(COOKIE_PAIRS).each do |pair|
+          name, values = pair.split(COOKIE_SEP, 2)
+          values = FILTERED if filter_key?(name)
+          cookies << "#{name}=#{values}"
+        end
+
+        cookies.join(COOKIE_PAIR_SEP)
+      end
+
+      def filter_url(url)
+        return url unless filters?
+
+        filtered_url = url.to_s.dup
+
+        filtered_url.scan(/(?:^|&|\?)([^=?&]+)=([^&]+)/).each do |m|
+          next unless filter_key?(m[0])
+          filtered_url.gsub!(/#{Regexp.escape(m[1])}/, FILTERED)
+        end
+
+        filtered_url
+      end
+
+    private
+
+      attr_reader :max_depth, :regexps, :deep_regexps, :blocks
+
+      def filters?
+        !!@filters
+      end
+
+      def filter_key?(key, parents = nil)
+        return false unless filters?
+        return true if regexps.any? { |r| key =~ r }
+        return true if deep_regexps && parents && (joined = parents.join(".")) && deep_regexps.any? { |r| joined =~ r }
+        false
+      end
+
+      def sanitize_string(string)
+        string = valid_encoding(string)
+        return string unless string.respond_to?(:size) && string.size > MAX_STRING_SIZE
+        string[0...MAX_STRING_SIZE] + TRUNCATED
+      end
+
+      def valid_encoding?(string)
+        string.valid_encoding? && (
+          VALID_ENCODINGS.include?(string.encoding) ||
+          VALID_ENCODINGS.include?(Encoding.compatible?(''.freeze, string))
+        )
+      end
+
+      def valid_encoding(string)
+        return string if valid_encoding?(string)
+        string.encode(Encoding::UTF_8, **ENCODE_OPTS)
+      end
+
+      def recursive?(data)
+        data.is_a?(Hash) || data.is_a?(Array) || data.is_a?(Set) || data.respond_to?(:to_honeybadger)
+      end
+
+      def basic_object?(object)
+        object.respond_to?(:to_s)
+        false
+      rescue
+        # BasicObject doesn't respond to `#respond_to?`.
+        true
+      end
+
+      def can_dup?(obj)
+        !IMMUTABLE.any? {|k| obj.kind_of?(k) }
+      end
+
+      def inspected?(string)
+        String(string) =~ /#<.*>/
+      end
+    end
+  end
+end

data/lib/honeybadger/util/sql.rb

@@ -1,34 +1,34 @@
-module Honeybadger
-  module Util
-    class SQL
-      EscapedQuotes = /(\\"|\\')/.freeze
-      SQuotedData = /'(?:[^']|'')*'/.freeze
-      DQuotedData = /"(?:[^"]|"")*"/.freeze
-      NumericData = /\b\d+\b/.freeze
-      Newline = /\n/.freeze
-      Replacement = "?".freeze
-      EmptyReplacement = "".freeze
-      DoubleQuoters = /(postgres|sqlite|postgis)/.freeze
-
-      def self.obfuscate(sql, adapter)
-        force_utf_8(sql.dup).tap do |s|
-          s.gsub!(EscapedQuotes, EmptyReplacement)
-          s.gsub!(SQuotedData, Replacement)
-          s.gsub!(DQuotedData, Replacement) if adapter =~ DoubleQuoters
-          s.gsub!(NumericData, Replacement)
-          s.gsub!(Newline, EmptyReplacement)
-          s.squeeze!(' ')
-        end
-      end
-
-      def self.force_utf_8(string)
-        string.encode(
-          Encoding.find('UTF-8'),
-          invalid: :replace, 
-          undef: :replace, 
-          replace: ''
-        )
-      end
-    end
-  end
-end
+module Honeybadger
+  module Util
+    class SQL
+      EscapedQuotes = /(\\"|\\')/.freeze
+      SQuotedData = /'(?:[^']|'')*'/.freeze
+      DQuotedData = /"(?:[^"]|"")*"/.freeze
+      NumericData = /\b\d+\b/.freeze
+      Newline = /\n/.freeze
+      Replacement = "?".freeze
+      EmptyReplacement = "".freeze
+      DoubleQuoters = /(postgres|sqlite|postgis)/.freeze
+
+      def self.obfuscate(sql, adapter)
+        force_utf_8(sql.dup).tap do |s|
+          s.gsub!(EscapedQuotes, EmptyReplacement)
+          s.gsub!(SQuotedData, Replacement)
+          s.gsub!(DQuotedData, Replacement) if adapter =~ DoubleQuoters
+          s.gsub!(NumericData, Replacement)
+          s.gsub!(Newline, EmptyReplacement)
+          s.squeeze!(' ')
+        end
+      end
+
+      def self.force_utf_8(string)
+        string.encode(
+          Encoding.find('UTF-8'),
+          invalid: :replace, 
+          undef: :replace, 
+          replace: ''
+        )
+      end
+    end
+  end
+end