honeybadger 2.7.2 → 3.0.0.beta1

data/lib/honeybadger/plugins/delayed_job/plugin.rb

@@ -1,5 +1,5 @@
 require 'delayed_job'
-require 'honeybadger'
+require 'honeybadger/ruby'
 
 module Honeybadger
   module Plugins
@@ -36,14 +36,13 @@ module Honeybadger
 
               block.call(job)
             rescue Exception => error
-              ::Honeybadger.notify_or_ignore(
+              ::Honeybadger.notify(
                 :component     => component,
                 :action        => action,
                 :error_class   => error.class.name,
                 :error_message => "#{ error.class.name }: #{ error.message }",
-                :backtrace     => error.backtrace,
-                :exception     => error
-              ) if job.attempts.to_i >= ::Honeybadger::Agent.config[:'delayed_job.attempt_threshold'].to_i
+                :backtrace     => error.backtrace
+              ) if job.attempts.to_i >= ::Honeybadger.config[:'delayed_job.attempt_threshold'].to_i
               raise error
             ensure
               ::Honeybadger.context.clear!

data/lib/honeybadger/plugins/passenger.rb

@@ -10,12 +10,11 @@ module Honeybadger
         execution do
           ::PhusionPassenger.on_event(:starting_worker_process) do |forked|
             logger.debug('Starting passenger worker process')
-            Honeybadger::Agent.fork if forked
           end
 
           ::PhusionPassenger.on_event(:stopping_worker_process) do
             logger.debug('Stopping passenger worker process')
-            Honeybadger::Agent.stop
+            Honeybadger.stop
           end
         end
       end

data/lib/honeybadger/plugins/rails.rb

@@ -34,34 +34,6 @@ module Honeybadger
         end
       end
 
-      module ControllerMethods
-        def honeybadger_request_data
-          warn('#honeybadger_request_data has been deprecated and has no effect.')
-          {}
-        end
-
-        def notify_honeybadger(*args, &block)
-          warn('#notify_honeybadger has been deprecated; please use `Honeybadger.notify`.')
-          Honeybadger.notify(*args, &block)
-        end
-
-        def notify_honeybadger_or_ignore(*args, &block)
-          warn('#notify_honeybadger_or_ignore has been deprecated; please use `Honeybadger.notify`.')
-          Honeybadger.notify(*args, &block)
-        end
-      end
-
-      Plugin.register :rails_controller_methods do
-        requirement { defined?(::Rails) }
-
-        execution do
-          ActiveSupport.on_load(:action_controller) do
-            # Lazily load action_controller methods
-            include ::Honeybadger::Plugins::Rails::ControllerMethods
-          end
-        end
-      end
-
       Plugin.register :rails_exceptions_catcher do
         requirement { defined?(::Rails) }
 

data/lib/honeybadger/plugins/resque.rb

@@ -1,5 +1,5 @@
 require 'honeybadger/plugin'
-require 'honeybadger'
+require 'honeybadger/ruby'
 
 module Honeybadger
   module Plugins
@@ -20,7 +20,7 @@ module Honeybadger
 
         def send_exception?(e, args)
           return true unless respond_to?(:retry_criteria_valid?)
-          return true if ::Honeybadger::Agent.config[:'resque.resque_retry.send_exceptions_when_retrying']
+          return true if ::Honeybadger.config[:'resque.resque_retry.send_exceptions_when_retrying']
 
           !retry_criteria_valid?(e)
         rescue => e
@@ -61,9 +61,6 @@ module Honeybadger
 
         execution do
           ::Resque::Job.send(:include, Installer)
-          ::Resque.after_fork do |job|
-            Honeybadger::Agent.fork
-          end
         end
       end
     end

data/lib/honeybadger/plugins/shoryuken.rb

@@ -1,5 +1,5 @@
 require 'honeybadger/plugin'
-require 'honeybadger'
+require 'honeybadger/ruby'
 
 module Honeybadger
   module Plugins
@@ -16,7 +16,7 @@ module Honeybadger
               yield
             rescue => e
               receive_count = sqs_msg.attributes['ApproximateReceiveCount'.freeze]
-              if receive_count && ::Honeybadger::Agent.config[:'shoryuken.attempt_threshold'].to_i <= receive_count.to_i
+              if receive_count && ::Honeybadger.config[:'shoryuken.attempt_threshold'].to_i <= receive_count.to_i
                 Honeybadger.notify(e, parameters: body)
               end
               raise e

data/lib/honeybadger/plugins/sidekiq.rb

@@ -1,5 +1,5 @@
 require 'honeybadger/plugin'
-require 'honeybadger'
+require 'honeybadger/ruby'
 
 module Honeybadger
   module Plugins
@@ -27,7 +27,7 @@ module Honeybadger
                 return if params['retry'.freeze] && params['retry_count'.freeze].to_i < config[:'sidekiq.attempt_threshold'].to_i
                 opts = {parameters: params}
                 opts[:component] = params['wrapped'.freeze] || params['class'.freeze] if config[:'sidekiq.use_component']
-                Honeybadger.notify_or_ignore(ex, opts)
+                Honeybadger.notify(ex, opts)
               }
             end
           end

data/lib/honeybadger/plugins/sucker_punch.rb

@@ -1,4 +1,5 @@
 require 'honeybadger/plugin'
+require 'honeybadger/ruby'
 
 module Honeybadger
   Plugin.register do

data/lib/honeybadger/plugins/thor.rb

@@ -1,5 +1,5 @@
 require 'honeybadger/plugin'
-require 'honeybadger'
+require 'honeybadger/ruby'
 
 module Honeybadger
   module Plugins
@@ -16,7 +16,7 @@ module Honeybadger
       def invoke_command_with_honeybadger(*args)
         invoke_command_without_honeybadger(*args)
       rescue Exception => e
-        Honeybadger.notify_or_ignore(e)
+        Honeybadger.notify(e)
         raise
       end
     end

data/lib/honeybadger/plugins/warden.rb

@@ -1,4 +1,5 @@
 require 'honeybadger/plugin'
+require 'honeybadger/ruby'
 
 module Honeybadger
   Plugin.register do

data/lib/honeybadger/rack/error_notifier.rb

@@ -1,6 +1,7 @@
-require 'rack/request'
-require 'honeybadger'
 require 'forwardable'
+require 'rack/request'
+
+require 'honeybadger/ruby'
 
 module Honeybadger
   module Rack
@@ -21,13 +22,13 @@ module Honeybadger
     class ErrorNotifier
       extend Forwardable
 
-      def initialize(app, config)
+      def initialize(app, agent = nil)
         @app = app
-        @config = config
+        @agent = agent.kind_of?(Agent) ? agent : Honeybadger::Agent.instance
       end
 
       def call(env)
-        config.with_request(::Rack::Request.new(env)) do
+        agent.with_rack_env(env) do
           begin
             env['honeybadger.config'] = config
             response = @app.call(env)
@@ -44,13 +45,14 @@ module Honeybadger
           response
         end
       ensure
-        Honeybadger.context.clear!
+        agent.context.clear!
       end
 
       private
 
-      attr_reader :config
-      def_delegator :@config, :logger
+      attr_reader :agent
+      def_delegator :agent, :config
+      def_delegator :config, :logger
 
       def ignored_user_agent?(env)
         true if config[:'exceptions.ignored_user_agents'].
@@ -60,7 +62,7 @@ module Honeybadger
 
       def notify_honeybadger(exception, env)
         return if ignored_user_agent?(env)
-        Honeybadger.notify_or_ignore(exception)
+        agent.notify(exception)
       end
 
       def framework_exception(env)

data/lib/honeybadger/rack/user_feedback.rb

@@ -19,12 +19,13 @@ module Honeybadger
     class UserFeedback
       extend Forwardable
 
-      def initialize(app, config)
+      def initialize(app, agent = nil)
         @app = app
-        @config = config
+        @agent = agent.kind_of?(Agent) ? agent : Honeybadger::Agent.instance
       end
 
       def call(env)
+        return @app.call(env) unless config[:'feedback.enabled']
         status, headers, body = @app.call(env)
         if env['honeybadger.error_id'] && form = render_form(env['honeybadger.error_id'])
           new_body = []
@@ -67,8 +68,9 @@ module Honeybadger
 
       private
 
-      attr_reader :config
-      def_delegator :@config, :logger
+      attr_reader :agent
+      def_delegator :agent, :config
+      def_delegator :config, :logger
     end
   end
 end

data/lib/honeybadger/rack/user_informer.rb

@@ -5,9 +5,9 @@ module Honeybadger
     class UserInformer
       extend Forwardable
 
-      def initialize(app, config)
+      def initialize(app, agent = nil)
         @app = app
-        @config = config
+        @agent = agent.kind_of?(Agent) ? agent : Honeybadger::Agent.instance
       end
 
       def replacement(with)
@@ -15,6 +15,7 @@ module Honeybadger
       end
 
       def call(env)
+        return @app.call(env) unless config[:'user_informer.enabled']
         status, headers, body = @app.call(env)
         if env['honeybadger.error_id']
           new_body = []
@@ -31,8 +32,9 @@ module Honeybadger
 
       private
 
-      attr_reader :config
-      def_delegator :@config, :logger
+      attr_reader :agent
+      def_delegator :agent, :config
+      def_delegator :config, :logger
     end
   end
 end

data/lib/honeybadger/ruby.rb

@@ -0,0 +1,2 @@
+require 'honeybadger/const'
+require 'honeybadger/singleton'

data/lib/honeybadger/singleton.rb

@@ -0,0 +1,26 @@
+require 'forwardable'
+require 'honeybadger/agent'
+
+# The Singleton module includes the public API for Honeybadger which can be
+# accessed via the global agent (i.e. `Honeybadger.notify`) or via instances of
+# the `Honeybadger::Agent` class.
+module Honeybadger
+  extend Forwardable
+  extend self
+
+  def_delegators :'Agent.instance', :init!, :config, :configure, :notify,
+    :context, :get_context, :flush, :stop, :with_rack_env, :exception_filter,
+    :exception_fingerprint, :backtrace_filter
+
+  def load_plugins!
+    Dir[File.expand_path('../plugins/*.rb', __FILE__)].each do |plugin|
+      require plugin
+    end
+    Plugin.load!(self.config)
+  end
+
+  # Deprecated
+  def start(config = {})
+    true
+  end
+end

data/lib/honeybadger/util/http.rb

@@ -21,6 +21,18 @@ module Honeybadger
         'User-Agent'.freeze => "HB-Ruby #{VERSION}; #{RUBY_VERSION}; #{RUBY_PLATFORM}".freeze
       }.freeze
 
+      ERRORS = [Timeout::Error,
+                Errno::EINVAL,
+                Errno::ECONNRESET,
+                Errno::ECONNREFUSED,
+                Errno::ENETUNREACH,
+                EOFError,
+                Net::HTTPBadResponse,
+                Net::HTTPHeaderSyntaxError,
+                Net::ProtocolError,
+                OpenSSL::SSL::SSLError,
+                SocketError].freeze
+
       def initialize(config)
         @config = config
       end

data/lib/honeybadger/util/request_hash.rb

@@ -0,0 +1,71 @@
+require 'set'
+
+module Honeybadger
+  module Util
+    # Internal: Constructs a request hash from a Rack::Request matching the
+    # /v1/notices API specification.
+    module RequestHash
+      HTTP_HEADER_PREFIX = 'HTTP_'.freeze
+
+      CGI_WHITELIST = %w(
+        AUTH_TYPE
+        CONTENT_LENGTH
+        CONTENT_TYPE
+        GATEWAY_INTERFACE
+        HTTPS
+        REMOTE_ADDR
+        REMOTE_HOST
+        REMOTE_IDENT
+        REMOTE_USER
+        REQUEST_METHOD
+        SERVER_NAME
+        SERVER_PORT
+        SERVER_PROTOCOL
+        SERVER_SOFTWARE
+      ).freeze
+
+      def self.from_env(env)
+        return {} unless defined?(::Rack::Request)
+
+        hash, request = {}, ::Rack::Request.new(env)
+
+        hash[:url] = extract_url(request)
+        hash[:params] = extract_params(request)
+        hash[:component] = hash[:params]['controller']
+        hash[:action] = hash[:params]['action']
+        hash[:session] = extract_session(request)
+        hash[:cgi_data] = extract_cgi_data(request)
+
+        hash
+      end
+
+      def self.extract_url(request)
+        request.env['honeybadger.request.url'] || request.url
+      rescue => e
+        "Failed to access URL -- #{e}"
+      end
+
+      def self.extract_params(request)
+        (request.env['action_dispatch.request.parameters'] || request.params).to_hash || {}
+      rescue => e
+        { error: "Failed to access params -- #{e}" }
+      end
+
+      def self.extract_session(request)
+        request.session.to_hash
+      rescue => e
+        # Rails raises ArgumentError when `config.secret_token` is missing, and
+        # ActionDispatch::Session::SessionRestoreError when the session can't be
+        # restored.
+        { error: "Failed to access session data -- #{e}" }
+      end
+
+      def self.extract_cgi_data(request)
+        request.env.each_with_object({}) do |(k,v), env|
+          next unless k.start_with?(HTTP_HEADER_PREFIX) || CGI_WHITELIST.include?(k)
+          env[k] = v
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/util/sanitizer.rb

@@ -1,133 +1,170 @@
+require 'bigdecimal'
 require 'set'
 
 module Honeybadger
   module Util
+    # Internal: Sanitizer sanitizes data for sending to Honeybadger's API. The
+    # filters are based on Rails' HTTP parameter filter.
     class Sanitizer
-      FILTERED_REPLACEMENT = '[FILTERED]'.freeze
+      COOKIE_PAIRS = /[;,]\s?/
+      COOKIE_SEP = '='.freeze
+      COOKIE_PAIR_SEP = '; '.freeze
 
-      TRUNCATION_REPLACEMENT = '[TRUNCATED]'.freeze
+      ENCODE_OPTS = { invalid: :replace, undef: :replace, replace: '?'.freeze }.freeze
+
+      FILTERED = '[FILTERED]'.freeze
+
+      IMMUTABLE = [NilClass, FalseClass, TrueClass, Symbol, Numeric, BigDecimal, Method].freeze
 
       MAX_STRING_SIZE = 2048
 
-      COOKIE_PAIRS = /[;,]\s?/
-      COOKIE_SEP = '='.freeze
-      COOKIE_PAIR_SEP = '; '.freeze
+      TRUNCATION_REPLACEMENT = '[TRUNCATED]'.freeze
+
+      VALID_ENCODINGS = [Encoding::UTF_8, Encoding::ISO_8859_1].freeze
+
+      def self.sanitize(data)
+        @sanitizer ||= new
+        @sanitizer.sanitize(data)
+      end
 
-      def initialize(opts = {})
-        @max_depth = opts.fetch(:max_depth, 20)
+      def initialize(max_depth: 20, filters: [])
+        @filters = !filters.empty?
+        @max_depth = max_depth
 
-        if filters = opts.fetch(:filters, nil)
-          @filters = Array(filters).collect do |f|
-            f.kind_of?(Regexp) ? f : f.to_s
+        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)
-        if data.kind_of?(Hash) || data.kind_of?(Array) || data.kind_of?(Set)
-          return '[possible infinite recursion halted]' if stack && stack.include?(data.object_id)
+      def sanitize(data, depth = 0, stack = nil, parents = [])
+        if enumerable?(data)
+          return '[possible infinite recursion halted]'.freeze if stack && stack.include?(data.object_id)
           stack = stack ? stack.dup : Set.new
           stack << data.object_id
         end
 
         case data
         when Hash
-          return '[max depth reached]' if depth >= max_depth
+          return '[max depth reached]'.freeze if depth >= max_depth
           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
+            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
-              new_hash[k] = sanitize(value, depth+1, stack)
+              value = sanitize(value, depth+1, stack, parents)
+              if blocks.any? && !enumerable?(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 '[max depth reached]' if depth >= max_depth
+          return '[max depth reached]'.freeze if depth >= max_depth
           data.to_a.map do |value|
-            sanitize(value, depth+1, stack)
+            sanitize(value, depth+1, stack, parents)
           end.compact
         when Numeric, TrueClass, FalseClass, NilClass
           data
         when String
-          self.class.sanitize_string(data.to_s)
+          sanitize_string(data)
         else # all other objects:
-          self.class.sanitize_string(data.to_s)
+          data.respond_to?(:to_s) ? sanitize_string(data.to_s) : nil
         end
       end
 
+      def sanitize_string(string)
+        string = valid_encoding(string.to_s)
+        return string unless string.respond_to?(:size) && string.size > MAX_STRING_SIZE
+        string[0...MAX_STRING_SIZE] + TRUNCATION_REPLACEMENT
+      end
+
       def filter_cookies(raw_cookies)
-        return raw_cookies unless filters
+        return raw_cookies unless filters?
 
         cookies = []
-        raw_cookies.split(COOKIE_PAIRS).each do |pair|
+
+        raw_cookies.to_s.split(COOKIE_PAIRS).each do |pair|
           name, values = pair.split(COOKIE_SEP, 2)
-          values = FILTERED_REPLACEMENT if filter_key?(name)
-          cookies << "#{ name }=#{ values }"
+          values = FILTERED if filter_key?(name)
+          cookies << "#{name}=#{values}"
         end
 
         cookies.join(COOKIE_PAIR_SEP)
       end
 
       def filter_url(url)
-        return url unless filters
+        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_REPLACEMENT)
+          filtered_url.gsub!(/#{Regexp.escape(m[1])}/, FILTERED)
         end
 
         filtered_url
       end
 
-      VALID_ENCODINGS = [Encoding::UTF_8, Encoding::ISO_8859_1].freeze
-      ENCODE_OPTS = { invalid: :replace, undef: :replace, replace: '?'.freeze }.freeze
-      UTF8_STRING = ''.freeze
-
-      class << self
-
-        def valid_encoding?(data)
-           data.valid_encoding? && (
-             VALID_ENCODINGS.include?(data.encoding) ||
-             VALID_ENCODINGS.include?(Encoding.compatible?(UTF8_STRING, data))
-           )
-        end
+    private
 
-        def valid_encoding(data)
-          return data if valid_encoding?(data)
+      attr_reader :max_depth, :regexps, :deep_regexps, :blocks
 
-          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
+      def filters?
+        !!@filters
+      end
 
-        def sanitize_string(data)
-          data = valid_encoding(data.to_s)
-          return data unless data.respond_to?(:size) && data.size > MAX_STRING_SIZE
-          data[0...MAX_STRING_SIZE] + TRUNCATION_REPLACEMENT
-        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 valid_encoding?(string)
+        string.valid_encoding? && (
+          VALID_ENCODINGS.include?(string.encoding) ||
+          VALID_ENCODINGS.include?(Encoding.compatible?(''.freeze, string))
+        )
       end
 
-      private
+      def valid_encoding(string)
+        return string if valid_encoding?(string)
 
-      attr_reader :max_depth, :filters
+        if string.encoding == Encoding::UTF_8
+          string.encode(Encoding::UTF_16, ENCODE_OPTS).encode!(Encoding::UTF_8)
+        else
+          string.encode(Encoding::UTF_8, ENCODE_OPTS)
+        end
+      end
 
-      def filter_key?(key)
-        return false unless filters
+      def enumerable?(data)
+        data.kind_of?(Hash) || data.kind_of?(Array) || data.kind_of?(Set)
+      end
 
-        filters.any? do |filter|
-          if filter.is_a?(Regexp)
-            filter =~ key.to_s
-          else
-            key.to_s.eql?(filter.to_s)
-          end
-        end
+      def can_dup?(obj)
+        !IMMUTABLE.any? {|k| obj.kind_of?(k) }
       end
     end
   end