honeybadger 2.0.6 → 2.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 45184c861193f93cac6f5079c6d0501f44fb1e29
-  data.tar.gz: 5dc11986399b1c0e712b3102358a76b4b65616a4
+  metadata.gz: 5f7f7f0ed185071b638c1397c651de08defdd67f
+  data.tar.gz: dc426f168bc4fc433638826c744df12f2f11e137
 SHA512:
-  metadata.gz: 7b0b237ca43d56e272df5dce38446dbd73d15c3979e7aa749d839b89dfb18ae827d405931b7c2542f428e89fcac373ddd340d6b07167765cb8cd7d7f6fc9183e
-  data.tar.gz: 934975d16d06daf5215c5b34ba97127cafad4df667d2c8d508b445fac36c1b2e44ab4bb3e6a9a0ff3acf2e739068a7b373b21c4a0172e896fbdbd08d8e85250d
+  metadata.gz: 19f26d5077e250b8faee7309504bc93ae568d87f8fb5eed8274a4810181dcb865e6688190bfba68c43cc3ac5dbd405f6ddd9ebc98aacf4e736605386c2a6b943
+  data.tar.gz: 1227af632c510f6255b24766622a921a5f2487d71450453a700db852da47cf4b0991b27b11714b0c71227ce224bd9d55a7701c90596704fdbd81fe405b278c35

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+* Handle bad encodings in exception payloads.
+
+  *Joshua Wood*
+
+* Include full backtrace when logging worker exceptions.
+
+  *Joshua Wood*
+
+* Always send a test notice on install.
+
+  *Joshua Wood*
+
+* Send the id of the current process with error reports.
+
+  *Joshua Wood*
+
 * Don't sub partial project root in backtrace lines.
 
   *Joshua Wood*

data/lib/honeybadger/agent.rb

@@ -282,7 +282,10 @@ module Honeybadger
     def run
       loop { work }
     rescue Exception => e
-      error(sprintf('error in agent thread (shutting down) class=%s message=%s at=%s', e.class, e.message.dump, e.backtrace.first.dump))
+      error {
+        msg = "error in agent thread (shutting down) class=%s message=%s\n\t%s"
+        sprintf(msg, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
+      }
     ensure
       d { sprintf('stopping agent') }
     end
@@ -291,7 +294,10 @@ module Honeybadger
       flush_metrics if metrics.flush?
       flush_traces if traces.flush?
     rescue StandardError => e
-      error(sprintf('error in agent thread class=%s message=%s at=%s', e.class, e.message.dump, e.backtrace.first.dump))
+      error {
+        msg = "error in agent thread class=%s message=%s\n\t%s"
+        sprintf(msg, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
+      }
     ensure
       sleep(delay)
     end

data/lib/honeybadger/agent/worker.rb

@@ -131,7 +131,10 @@ module Honeybadger
           d { sprintf('stopping worker feature=%s', feature) }
         end
       rescue Exception => e
-        error(sprintf('error in worker thread (shutting down) feature=%s class=%s message=%s at=%s', feature, e.class, e.message.dump, e.backtrace.first.dump))
+        error {
+          msg = "error in worker thread (shutting down) feature=%s class=%s message=%s\n\t%s"
+          sprintf(msg, feature, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
+        }
       ensure
         release_marker
       end
@@ -140,7 +143,10 @@ module Honeybadger
         handle_response(notify_backend(msg))
         sleep(throttle_interval)
       rescue StandardError => e
-        error(sprintf('error in worker thread feature=%s class=%s message=%s at=%s', feature, e.class, e.message.dump, e.backtrace.first.dump))
+        error {
+          msg = "error in worker thread feature=%s class=%s message=%s\n\t%s"
+          sprintf(msg, feature, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
+        }
         sleep(1)
       end
 

data/lib/honeybadger/cli/helpers.rb

@@ -125,7 +125,7 @@ module Honeybadger
 
           def test_honeybadger
             puts "Raising '#{test_exception_class.name}' to simulate application failure."
-            raise #{test_exception_class}.new, 'Testing honeybadger via "honeybadger testhoneybadger test", it works.'
+            raise #{test_exception_class}.new, 'Testing honeybadger via "honeybadger test", it works.'
           end
 
           # Ensure we actually have an action to go to.

data/lib/honeybadger/cli/main.rb

@@ -127,7 +127,6 @@ module Honeybadger
 
         if (path = config.config_path).exist?
           say("You're already on Honeybadger, so you're all set.", :yellow)
-          skip_test = true if options[:test].nil? # Only if it wasn't specified.
         else
           say("Writing configuration to: #{path}", :yellow)
 
@@ -153,7 +152,7 @@ module Honeybadger
           end
         end
 
-        if !skip_test && (options[:test].nil? || options[:test])
+        if options[:test].nil? || options[:test]
           Honeybadger.start(config) unless load_rails_env(verbose: true)
           say('Sending test notice', :yellow)
           unless Agent.instance && send_test(false)

data/lib/honeybadger/config.rb

@@ -352,7 +352,13 @@ api_key: '#{self[:api_key]}'
         end
       end
     rescue ConfigError => e
-      logger.error("Error while loading config from disk: #{e}")
+      error("error while loading config from disk: #{e}")
+      nil
+    rescue StandardError => e
+      error {
+        msg = "error while loading config from disk class=%s message=%s\n\t%s"
+        sprintf(msg, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
+      }
       nil
     end
 

data/lib/honeybadger/config/yaml.rb

@@ -19,9 +19,6 @@ module Honeybadger
           yaml.merge!(yaml[env]) if yaml[env].kind_of?(Hash)
           update(dotify_keys(yaml))
         end
-
-      rescue StandardError => e
-        raise ConfigError, "An unknown error occured: #{e.class} -- #{e.message}\n\t#{e.backtrace.first}"
       end
 
       private

data/lib/honeybadger/logging.rb

@@ -54,7 +54,7 @@ module Honeybadger
       end
 
       def level
-        Logger::Severity::Debug
+        Logger::Severity::DEBUG
       end
     end
 

data/lib/honeybadger/notice.rb

@@ -7,7 +7,6 @@ require 'honeybadger/version'
 require 'honeybadger/backtrace'
 require 'honeybadger/util/stats'
 require 'honeybadger/util/sanitizer'
-require 'honeybadger/util/request_sanitizer'
 require 'honeybadger/rack/request_hash'
 
 module Honeybadger
@@ -132,10 +131,12 @@ module Honeybadger
 
     def initialize(config, opts = {})
       @now = Time.now.utc
+      @pid = Process.pid
       @id = SecureRandom.uuid
 
       @opts = opts
       @config = config
+      @sanitizer = Util::Sanitizer.new(filters: config.params_filters)
 
       @exception = opts[:exception]
       @error_class = exception_attribute(:error_class) {|exception| exception.class.name }
@@ -148,10 +149,9 @@ module Honeybadger
       @source = extract_source_from_backtrace(@backtrace, config, opts)
       @fingerprint = construct_fingerprint(opts)
 
-      @sanitizer = Util::Sanitizer.new(filters: config.params_filters)
-      @request_sanitizer = Util::RequestSanitizer.new(@sanitizer)
-      @request = OpenStruct.new(construct_request_hash(config.request, opts, @request_sanitizer, config.excluded_request_keys))
-      @context = construct_context_hash(opts, @sanitizer)
+      @request = OpenStruct.new(construct_request_hash(config.request, opts, config.excluded_request_keys))
+
+      @context = construct_context_hash(opts)
 
       @causes = unwrap_causes(opts[:exception])
 
@@ -160,7 +160,7 @@ module Honeybadger
 
       @stats = Util::Stats.all
 
-      @local_variables = local_variables_from_exception(exception, config, @sanitizer)
+      @local_variables = local_variables_from_exception(exception, config)
 
       @api_key = opts[:api_key] || config[:api_key]
 
@@ -172,34 +172,35 @@ module Honeybadger
     # Returns Hash JSON representation of notice
     def as_json(*args)
       {
-        api_key: api_key,
+        api_key: s(api_key),
         notifier: NOTIFIER,
         error: {
           token: id,
-          class: error_class,
-          message: error_message,
-          backtrace: backtrace,
-          source: source,
-          fingerprint: fingerprint,
-          tags: tags,
-          causes: causes
+          class: s(error_class),
+          message: s(error_message),
+          backtrace: s(backtrace),
+          source: s(source),
+          fingerprint: s(fingerprint),
+          tags: s(tags),
+          causes: s(causes)
         },
         request: {
-          url: url,
-          component: component,
-          action: action,
-          params: params,
-          session: session,
-          cgi_data: cgi_data,
-          context: context,
-          local_variables: local_variables
+          url: sanitized_url,
+          component: s(component),
+          action: s(action),
+          params: s(params),
+          session: s(session),
+          cgi_data: s(cgi_data),
+          context: s(context),
+          local_variables: s(local_variables)
         },
         server: {
-          project_root: config[:root],
-          environment_name: config[:env],
-          hostname: config[:hostname],
+          project_root: s(config[:root]),
+          environment_name: s(config[:env]),
+          hostname: s(config[:hostname]),
           stats: stats,
-          time: now
+          time: now,
+          pid: pid
         }
       }
     end
@@ -208,7 +209,7 @@ module Honeybadger
     #
     # Returns valid JSON representation of Notice
     def to_json(*a)
-      as_json.to_json(*a)
+      ::JSON.generate(as_json(*a))
     end
 
     # Public: Allows properties to be accessed using a hash-like syntax
@@ -236,7 +237,7 @@ module Honeybadger
 
     private
 
-    attr_reader :config, :opts, :context, :stats, :api_key, :now, :causes
+    attr_reader :config, :opts, :context, :stats, :api_key, :now, :pid, :causes, :sanitizer
 
     def ignore_by_origin?
       opts[:origin] == :rake && !config[:'exceptions.rescue_rake']
@@ -328,7 +329,7 @@ module Honeybadger
       ].compact | BACKTRACE_FILTERS
     end
 
-    def construct_request_hash(rack_request, opts, sanitizer, excluded_keys = [])
+    def construct_request_hash(rack_request, opts, excluded_keys = [])
       request = {}
       request.merge!(Rack::RequestHash.new(rack_request)) if rack_request
 
@@ -342,14 +343,14 @@ module Honeybadger
 
       request[:session] = request[:session][:data] if request[:session][:data]
 
-      sanitizer.sanitize(request)
+      request
     end
 
-    def construct_context_hash(opts, sanitizer)
+    def construct_context_hash(opts)
       context = {}
       context.merge!(Thread.current[:__honeybadger_context]) if Thread.current[:__honeybadger_context]
       context.merge!(opts[:context]) if opts[:context]
-      context.empty? ? nil : sanitizer.sanitize(context)
+      context.empty? ? nil : context
     end
 
     def extract_source_from_backtrace(backtrace, config, opts)
@@ -401,12 +402,21 @@ module Honeybadger
       ret
     end
 
+    def s(data)
+      sanitizer.sanitize(data)
+    end
+
+    def sanitized_url
+      return nil unless url
+      sanitizer.filter_url(s(url))
+    end
+
     # Internal: Fetch local variables from first frame of backtrace.
     #
     # exception - The Exception containing the bindings stack.
     #
     # Returns a Hash of local variables
-    def local_variables_from_exception(exception, config, sanitizer)
+    def local_variables_from_exception(exception, config)
       return {} unless send_local_variables?(config)
       return {} unless Exception === exception
       return {} unless exception.respond_to?(:__honeybadger_bindings_stack)
@@ -419,9 +429,7 @@ module Honeybadger
       binding ||= exception.__honeybadger_bindings_stack[0]
 
       vars = binding.eval('local_variables')
-      h = Hash[vars.map {|arg| [arg, binding.eval(arg.to_s)]}]
-
-      sanitizer.sanitize(h)
+      Hash[vars.map {|arg| [arg, binding.eval(arg.to_s)]}]
     end
 
     # Internal: Should local variables be sent?

data/lib/honeybadger/plugin.rb

@@ -71,7 +71,7 @@ module Honeybadger
     def ok?(config)
       @requirements.all? {|r| Execution.new(config, &r).call }
     rescue => e
-      config.logger.error(sprintf('plugin error name=%s class=%s message=%s at=%s', name, e.class, e.message.dump, e.backtrace.first.dump))
+      config.logger.error(sprintf("plugin error name=%s class=%s message=%s\n\t%s", name, e.class, e.message.dump, Array(e.backtrace).join("\n\t")))
       false
     end
 
@@ -89,7 +89,7 @@ module Honeybadger
 
       @loaded
     rescue => e
-      config.logger.error(sprintf('plugin error name=%s class=%s message=%s at=%s', name, e.class, e.message.dump, e.backtrace.first.dump))
+      config.logger.error(sprintf("plugin error name=%s class=%s message=%s\n\t%s", name, e.class, e.message.dump, Array(e.backtrace).join("\n\t")))
       @loaded = true
       false
     end

data/lib/honeybadger/util/http.rb

@@ -64,11 +64,6 @@ module Honeybadger
         end
 
         http
-      rescue => e
-        error do
-          sprintf('http error class=%s message=%s at=%s', e.class, e.message.dump, e.backtrace.first.dump)
-        end
-        raise e
       end
 
       def compress(string, level = Zlib::DEFAULT_COMPRESSION)

data/lib/honeybadger/util/sanitizer.rb

@@ -3,41 +3,46 @@ module Honeybadger
     class Sanitizer
       OBJECT_WHITELIST = [Hash, Array, String, Integer, Float, TrueClass, FalseClass, NilClass]
 
+      FILTERED_REPLACEMENT = '[FILTERED]'.freeze
+
       def initialize(opts = {})
-        @max_depth = opts[:max_depth] || 20
-        @filters = Array(opts[:filters])
+        @max_depth = opts.fetch(:max_depth, 20)
+        @filters = Array(opts.fetch(:filters, nil)).collect do |f|
+          f.kind_of?(Regexp) ? f : f.to_s
+        end
       end
 
-      # Removes non-serializable data and truncates to max depth.
-      def sanitize(data, depth = 0, stack = [])
-        return '[possible infinite recursion halted]' if stack.any?{|item| item == data.object_id }
+      def sanitize(data, depth = 0, stack = nil)
+        if recursive?(data)
+          return '[possible infinite recursion halted]' if stack && stack.include?(data.object_id)
+          stack = stack ? stack.dup : Set.new
+          stack << data.object_id
+        end
 
-        if data.respond_to?(:to_hash)
+        if data.kind_of?(String)
+          sanitize_string(data)
+        elsif data.respond_to?(:to_hash)
           return '[max depth reached]' if depth >= max_depth
-          data.to_hash.reduce({}) do |result, (key, value)|
-            result.merge(key => sanitize(value, depth+1, stack + [data.object_id]))
+          hash = data.to_hash
+          new_hash = {}
+          hash.each_pair do |key, value|
+            k = key.kind_of?(Symbol) ? key : sanitize(key, depth+1, stack)
+            if filter_key?(k)
+              new_hash[k] = FILTERED_REPLACEMENT
+            else
+              new_hash[k] = sanitize(value, depth+1, stack)
+            end
           end
+          new_hash
         elsif data.respond_to?(:to_ary)
           return '[max depth reached]' if depth >= max_depth
-          data.to_ary.collect do |value|
-            sanitize(value, depth+1, stack + [data.object_id])
-          end
+          data.to_ary.map do |value|
+            sanitize(value, depth+1, stack)
+          end.compact
         elsif OBJECT_WHITELIST.any? {|c| data.kind_of?(c) }
           data
         else
-          data.to_s
-        end
-      end
-
-      def filter(hash)
-        {}.tap do |filtered_hash|
-          hash.each_pair do |key, value|
-            if value.respond_to?(:to_hash)
-              filtered_hash[key] = filter(hash[key])
-            else
-              filtered_hash[key] = filter_key?(key) ? '[FILTERED]' : hash[key]
-            end
-          end
+          sanitize_string(data.to_s)
         end
       end
 
@@ -53,19 +58,44 @@ module Honeybadger
 
       private
 
+      VALID_ENCODINGS = [Encoding::UTF_8, Encoding::ISO_8859_1].freeze
+      ENCODE_OPTS = { invalid: :replace, undef: :replace, replace: '?'.freeze }.freeze
+      UTF8_STRING = ''.freeze
+
       attr_reader :max_depth, :filters
 
+      def recursive?(data)
+        data.respond_to?(:to_hash) || data.respond_to?(:to_ary)
+      end
+
       def filter_key?(key)
         return false unless filters
 
         filters.any? do |filter|
           if filter.is_a?(Regexp)
-            key.to_s =~ filter
+            filter =~ key.to_s
           else
             key.to_s.eql?(filter.to_s)
           end
         end
       end
+
+      def valid_encoding?(data)
+         data.valid_encoding? && (
+           VALID_ENCODINGS.include?(data.encoding) ||
+           VALID_ENCODINGS.include?(Encoding.compatible?(UTF8_STRING, data))
+         )
+      end
+
+      def sanitize_string(data)
+        return data if valid_encoding?(data)
+
+        if data.encoding == Encoding::UTF_8
+          data.encode(Encoding::UTF_16, ENCODE_OPTS).encode!(Encoding::UTF_8)
+        else
+          data.encode(Encoding::UTF_8, ENCODE_OPTS)
+        end
+      end
     end
   end
 end

data/lib/honeybadger/version.rb

@@ -1,4 +1,4 @@
 module Honeybadger
   # Public: The current String Honeybadger version.
-  VERSION = '2.0.6'.freeze
+  VERSION = '2.0.8'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: honeybadger
 version: !ruby/object:Gem::Version
-  version: 2.0.6
+  version: 2.0.8
 platform: ruby
 authors:
 - Honeybadger Industries LLC
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-16 00:00:00.000000000 Z
+date: 2015-03-11 00:00:00.000000000 Z
 dependencies: []
 description: Make managing application errors a more pleasant experience.
 email:
@@ -73,7 +73,6 @@ files:
 - lib/honeybadger/templates/feedback_form.erb
 - lib/honeybadger/trace.rb
 - lib/honeybadger/util/http.rb
-- lib/honeybadger/util/request_sanitizer.rb
 - lib/honeybadger/util/sanitizer.rb
 - lib/honeybadger/util/stats.rb
 - lib/honeybadger/version.rb

data/lib/honeybadger/util/request_sanitizer.rb

@@ -1,35 +0,0 @@
-module Honeybadger
-  module Util
-    class RequestSanitizer
-
-      def initialize(sanitizer)
-        @sanitizer = sanitizer
-      end
-
-      def sanitize(request_hash)
-        request_hash.merge({
-          url: sanitize_url(request_hash[:url]),
-          component: request_hash[:component],
-          action: request_hash[:action],
-          params: sanitize_hash(request_hash[:params]),
-          session: sanitize_hash(request_hash[:session]),
-          cgi_data: sanitize_hash(request_hash[:cgi_data])
-        })
-      end
-
-      private
-
-      def sanitize_url(url)
-        if url
-          @sanitizer.filter_url(url)
-        end
-      end
-
-      def sanitize_hash(hash)
-        if hash
-          @sanitizer.filter(@sanitizer.sanitize(hash))
-        end
-      end
-    end
-  end
-end