honeybadger 1.13.2 → 1.14.0

data/lib/honeybadger/payload.rb

@@ -0,0 +1,101 @@
+require 'delegate'
+
+module Honeybadger
+  class Payload < SimpleDelegator
+    TOP_LEVEL_KEYS = [:api_key, :notifier, :error, :request, :server]
+    OBJECT_WHITELIST = [Hash, Array, String, Integer, Float, TrueClass, FalseClass, NilClass]
+
+    # Define getters for top level keys
+    TOP_LEVEL_KEYS.each do |key|
+      define_method key do
+        self[key]
+      end
+    end
+
+    def initialize(hash = {}, options = {})
+      fail ArgumentError, 'must be a Hash' unless hash.kind_of?(Hash)
+
+      @max_depth = options[:max_depth] || 20
+      @filters = options[:filters]
+
+      super(sanitize(hash))
+
+      TOP_LEVEL_KEYS.each {|k| self[k] ||= {} }
+
+      filter_url!(request[:url]) if request[:url]
+      filter_urls!(request[:cgi_data]) if request[:cgi_data]
+
+      filter!(request[:params]) if request[:params]
+      filter!(request[:session]) if request[:session]
+      filter!(request[:cgi_data]) if request[:cgi_data]
+      filter!(request[:local_variables]) if request[:local_variables]
+    end
+
+    protected
+
+    attr_reader :max_depth, :filters
+
+    # 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 }
+
+      if 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]))
+        end
+      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
+      elsif OBJECT_WHITELIST.any? {|c| data.kind_of?(c) }
+        data
+      else
+        data.to_s
+      end
+    end
+
+    def filter!(hash)
+      if filters
+        hash.each do |key, value|
+          if filter_key?(key)
+            hash[key] = "[FILTERED]"
+          elsif value.respond_to?(:to_hash)
+            filter!(hash[key])
+          end
+        end
+      end
+    end
+
+    def filter_key?(key)
+      return false unless filters
+
+      filters.any? do |filter|
+        if filter.is_a?(Regexp)
+          key.to_s =~ filter
+        else
+          key.to_s.eql?(filter.to_s)
+        end
+      end
+    end
+
+    def filter_url!(url)
+      return nil unless url =~ /\S/
+
+      url.scan(/(?:^|&|\?)([^=?&]+)=([^&]+)/).each do |m|
+        next unless filter_key?(m[0])
+        url.gsub!(/#{m[1]}/, '[FILTERED]')
+      end
+
+      url
+    end
+
+    def filter_urls!(hash)
+      hash.each_pair do |key, value|
+        next unless value.kind_of?(String) && key =~ /\A[A-Z_]+\Z/ && value =~ /\S/
+        filter_url!(value)
+      end
+    end
+  end
+end

data/lib/honeybadger/rack.rb

@@ -1,58 +1,12 @@
-module Honeybadger
-  # Middleware for Rack applications. Any errors raised by the upstream
-  # application will be delivered to Honeybadger and re-raised.
-  #
-  # Synopsis:
-  #
-  #   require 'rack'
-  #   require 'honeybadger'
-  #
-  #   Honeybadger.configure do |config|
-  #     config.api_key = 'my_api_key'
-  #   end
-  #
-  #   app = Rack::Builder.app do
-  #     run lambda { |env| raise "Rack down" }
-  #   end
-  #
-  #   use Honeybadger::Rack
-  #   run app
-  #
-  # Use a standard Honeybadger.configure call to configure your api key.
-  class Rack
-    def initialize(app)
-      @app = app
-      Honeybadger.configuration.framework = "Rack: #{::Rack.release}"
-    end
+require 'honeybadger/rack/error_notifier'
+require 'honeybadger/rack/user_informer'
+require 'honeybadger/rack/user_feedback'
 
-    def ignored_user_agent?(env)
-      true if Honeybadger.
-        configuration.
-        ignore_user_agent.
-        flatten.
-        any? { |ua| ua === env['HTTP_USER_AGENT'] }
-    end
-
-    def notify_honeybadger(exception,env)
-      Honeybadger.notify_or_ignore(exception, :rack_env => env) unless ignored_user_agent?(env)
-    end
-
-    def call(env)
-      begin
-        response = @app.call(env)
-      rescue Exception => raised
-        env['honeybadger.error_id'] = notify_honeybadger(raised, env)
-        raise
-      ensure
-        Honeybadger.context.clear!
-      end
-
-      framework_exception = env['rack.exception'] || env['sinatra.error']
-      if framework_exception
-        env['honeybadger.error_id'] = notify_honeybadger(framework_exception, env)
-      end
-
-      response
+module Honeybadger
+  module Rack
+    def self.new(*args, &block)
+      warn '[DEPRECATION] Honeybadger::Rack is deprecated in 2.0. Use Honeybadger::Rack::ErrorNotifier.'
+      ErrorNotifier.new(*args, &block)
     end
   end
 end

data/lib/honeybadger/rack/error_notifier.rb

@@ -0,0 +1,60 @@
+module Honeybadger
+  module Rack
+    # Middleware for Rack applications. Any errors raised by the upstream
+    # application will be delivered to Honeybadger and re-raised.
+    #
+    # Synopsis:
+    #
+    #   require 'rack'
+    #   require 'honeybadger'
+    #
+    #   Honeybadger.configure do |config|
+    #     config.api_key = 'my_api_key'
+    #   end
+    #
+    #   app = Rack::Builder.app do
+    #     run lambda { |env| raise "Rack down" }
+    #   end
+    #
+    #   use Honeybadger::Rack::ErrorNotifier
+    #   run app
+    #
+    # Use a standard Honeybadger.configure call to configure your api key.
+    class ErrorNotifier
+      def initialize(app)
+        @app = app
+        Honeybadger.configuration.framework = "Rack: #{::Rack.release}"
+      end
+
+      def ignored_user_agent?(env)
+        true if Honeybadger.
+          configuration.
+          ignore_user_agent.
+          flatten.
+          any? { |ua| ua === env['HTTP_USER_AGENT'] }
+      end
+
+      def notify_honeybadger(exception,env)
+        Honeybadger.notify_or_ignore(exception, :rack_env => env) unless ignored_user_agent?(env)
+      end
+
+      def call(env)
+        begin
+          response = @app.call(env)
+        rescue Exception => raised
+          env['honeybadger.error_id'] = notify_honeybadger(raised, env)
+          raise
+        ensure
+          Honeybadger.context.clear!
+        end
+
+        framework_exception = env['rack.exception'] || env['sinatra.error']
+        if framework_exception
+          env['honeybadger.error_id'] = notify_honeybadger(framework_exception, env)
+        end
+
+        response
+      end
+    end
+  end
+end

data/lib/honeybadger/rack/user_feedback.rb

@@ -0,0 +1,74 @@
+require 'erb'
+require 'uri'
+
+begin
+  require 'i18n'
+rescue LoadError
+  module Honeybadger
+    module I18n
+      def self.t(key, options={})
+        options[:default]
+      end
+    end
+  end
+end
+
+module Honeybadger
+  module Rack
+    class UserFeedback
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        status, headers, body = @app.call(env)
+        if enabled? && env['honeybadger.error_id'] && form = render_form(env['honeybadger.error_id'])
+          new_body = []
+          body.each do |chunk|
+            new_body << chunk.gsub("<!-- HONEYBADGER FEEDBACK -->", form)
+          end
+          body.close if body.respond_to?(:close)
+          headers['Content-Length'] = new_body.reduce(0) { |a,e| a += e.bytesize }.to_s
+          body = new_body
+        end
+        [status, headers, body]
+      end
+
+      def config
+        Honeybadger.configuration
+      end
+
+      def enabled?
+        config.feedback && config.features['feedback']
+      end
+
+      def action
+        URI.parse("#{config.protocol}://#{config.host}:#{config.port}/v1/feedback/").to_s
+      rescue URI::InvalidURIError
+        nil
+      end
+
+      def render_form(error_id, action = action)
+        return unless action
+        ERB.new(@template ||= File.read(template_file)).result(binding)
+      end
+
+      def custom_template_file
+        @custom_template_file ||= config.project_root &&
+          File.join(config.project_root, 'lib', 'honeybadger', 'templates', 'feedback_form.erb')
+      end
+
+      def custom_template_file?
+        custom_template_file && File.exists?(custom_template_file)
+      end
+
+      def template_file
+        if custom_template_file?
+          custom_template_file
+        else
+          File.expand_path('../../templates/feedback_form.erb', __FILE__)
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/rack/user_informer.rb

@@ -0,0 +1,28 @@
+module Honeybadger
+  module Rack
+    class UserInformer
+      def initialize(app)
+        @app = app
+      end
+
+      def replacement(with)
+        Honeybadger.configuration.user_information.gsub(/\{\{\s*error_id\s*\}\}/, with.to_s)
+      end
+
+      def call(env)
+        status, headers, body = @app.call(env)
+        if env['honeybadger.error_id'] && Honeybadger.configuration.user_information
+          new_body = []
+          replace  = replacement(env['honeybadger.error_id'])
+          body.each do |chunk|
+            new_body << chunk.gsub("<!-- HONEYBADGER ERROR -->", replace)
+          end
+          body.close if body.respond_to?(:close)
+          headers['Content-Length'] = new_body.reduce(0) { |a,e| a += e.bytesize }.to_s
+          body = new_body
+        end
+        [status, headers, body]
+      end
+    end
+  end
+end

data/lib/honeybadger/rails.rb

@@ -18,11 +18,11 @@ module Honeybadger
 
       if defined?(::Rails.configuration) && ::Rails.configuration.respond_to?(:middleware)
         ::Rails.configuration.middleware.insert_after 'ActionController::Failsafe',
-                                                      Honeybadger::Rack
+                                                      Honeybadger::Rack::ErrorNotifier
         ::Rails.configuration.middleware.insert_after 'Rack::Lock',
-                                                      Honeybadger::UserInformer
-        ::Rails.configuration.middleware.insert_after Honeybadger::UserInformer,
-                                                      Honeybadger::UserFeedback
+                                                      Honeybadger::Rack::UserInformer
+        ::Rails.configuration.middleware.insert_after Honeybadger::Rack::UserInformer,
+                                                      Honeybadger::Rack::UserFeedback
       end
 
       Honeybadger.configure(true) do |config|
@@ -34,6 +34,7 @@ module Honeybadger
 
       if defined?(::Rails.configuration) && ::Rails.configuration.respond_to?(:after_initialize)
         ::Rails.configuration.after_initialize do
+          Honeybadger::Dependency.inject!
           Honeybadger.ping(Honeybadger.configuration)
         end
       end

data/lib/honeybadger/railtie.rb

@@ -10,9 +10,9 @@ module Honeybadger
     end
 
     initializer "honeybadger.use_rack_middleware" do |app|
-      app.config.middleware.insert 0, "Honeybadger::UserInformer"
-      app.config.middleware.insert_after "Honeybadger::UserInformer","Honeybadger::UserFeedback"
-      app.config.middleware.insert_after "Honeybadger::UserFeedback","Honeybadger::Rack"
+      app.config.middleware.insert 0, "Honeybadger::Rack::UserInformer"
+      app.config.middleware.insert_after "Honeybadger::Rack::UserInformer","Honeybadger::Rack::UserFeedback"
+      app.config.middleware.insert_after "Honeybadger::Rack::UserFeedback","Honeybadger::Rack::ErrorNotifier"
     end
 
     config.after_initialize do
@@ -44,6 +44,7 @@ module Honeybadger
         ::ActionDispatch::ShowExceptions.send(:include,Honeybadger::Rails::Middleware::ExceptionsCatcher)
       end
 
+      Honeybadger::Dependency.inject!
       Honeybadger.ping(Honeybadger.configuration)
     end
   end

data/lib/honeybadger/user_feedback.rb

@@ -1,72 +1,8 @@
-require 'erb'
-require 'uri'
-
-begin
-  require 'i18n'
-rescue LoadError
-  module Honeybadger
-    module I18n
-      def self.t(key, options={})
-        options[:default]
-      end
-    end
-  end
-end
-
 module Honeybadger
-  class UserFeedback
+  class UserFeedback < Rack::UserFeedback
     def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      status, headers, body = @app.call(env)
-      if enabled? && env['honeybadger.error_id'] && form = render_form(env['honeybadger.error_id'])
-        new_body = []
-        body.each do |chunk|
-          new_body << chunk.gsub("<!-- HONEYBADGER FEEDBACK -->", form)
-        end
-        body.close if body.respond_to?(:close)
-        headers['Content-Length'] = new_body.reduce(0) { |a,e| a += e.bytesize }.to_s
-        body = new_body
-      end
-      [status, headers, body]
-    end
-
-    def config
-      Honeybadger.configuration
-    end
-
-    def enabled?
-      config.feedback && config.features['feedback']
-    end
-
-    def action
-      URI.parse("#{config.protocol}://#{config.host}:#{config.port}/v1/feedback/").to_s
-    rescue URI::InvalidURIError
-      nil
-    end
-
-    def render_form(error_id, action = action)
-      return unless action
-      ERB.new(@template ||= File.read(template_file)).result(binding)
-    end
-
-    def custom_template_file
-      @custom_template_file ||= config.project_root &&
-        File.join(config.project_root, 'lib', 'honeybadger', 'templates', 'feedback_form.erb')
-    end
-
-    def custom_template_file?
-      custom_template_file && File.exists?(custom_template_file)
-    end
-
-    def template_file
-      if custom_template_file?
-        custom_template_file
-      else
-        File.expand_path('../templates/feedback_form.erb', __FILE__)
-      end
+      warn '[DEPRECATION] Honeybadger::UserFeedback is deprecated in 2.0. Use Honeybadger::Rack::UserFeedback.'
+      super
     end
   end
 end