exception_handling 1.2.1 → 2.2.1

data/lib/exception_handling/exception_catalog.rb

@@ -15,14 +15,16 @@ module ExceptionHandling
     private
 
     def refresh_filters
-      mtime = last_modified_time
-      if @filters_last_modified_time.nil? || mtime != @filters_last_modified_time
-        ExceptionHandling.logger.info("Reloading filter list from: #{@filter_path}.  Last loaded time: #{@filters_last_modified_time}. Last modified time: #{mtime}")
-        load_file
+      if (mtime = last_modified_time)
+        if @filters_last_modified_time.nil? || mtime != @filters_last_modified_time
+          ExceptionHandling.logger.info("Reloading filter list from: #{@filter_path}.  Last loaded time: #{@filters_last_modified_time}. Last modified time: #{mtime}")
+          load_file
+        end
       end
 
     rescue => ex # any exceptions
-      ExceptionHandling::log_error(ex, "ExceptionRegexes::refresh_filters: #{@filter_path}", nil, true)
+      # DO NOT CALL ExceptionHandling.log_error because this method is called from that.  It can loop and cause mayhem.
+      ExceptionHandling.write_exception_to_log(ex, "ExceptionCatalog#refresh_filters: #{@filter_path}", Time.now.to_i)
     end
 
     def load_file
@@ -34,7 +36,7 @@ module ExceptionHandling
     end
 
     def last_modified_time
-      File.mtime(@filter_path)
+      @filter_path && File.mtime(@filter_path)
     end
   end
 end

data/lib/exception_handling/exception_description.rb

@@ -3,13 +3,14 @@ module ExceptionHandling
     MATCH_SECTIONS =  [:error, :request, :session, :environment, :backtrace, :event_response]
 
     CONFIGURATION_SECTIONS = {
-        send_email:  false,  # should email be sent?
-        send_metric: true,   # should the metric be sent.
-        metric_name: nil,    # Will be derived from section name if not passed
-        notes:       nil     # Will be included in exception email if set, used to keep notes and relevant links
+        send_email:           false,  # should email be sent?
+        send_to_honeybadger:  false,  # should be sent to honeybadger?
+        send_metric:          true,   # should the metric be sent.
+        metric_name:          nil,    # Will be derived from section name if not passed
+        notes:                nil     # Will be included in exception email if set, used to keep notes and relevant links
     }
 
-    attr_reader :filter_name, :send_email, :send_metric, :metric_name, :notes
+    attr_reader :filter_name, :send_email, :send_to_honeybadger, :send_metric, :metric_name, :notes
 
     def initialize(filter_name, configuration)
       @filter_name = filter_name
@@ -19,13 +20,14 @@ module ExceptionHandling
 
       @configuration = CONFIGURATION_SECTIONS.merge(configuration)
       @send_email  = @configuration[:send_email]
+      @send_to_honeybadger = @configuration[:send_to_honeybadger]
       @send_metric = @configuration[:send_metric]
       @metric_name = (@configuration[:metric_name] || @filter_name ).to_s.gsub(" ","_")
       @notes       = @configuration[:notes]
 
       regex_config = @configuration.reject { |k,v| k.in?(CONFIGURATION_SECTIONS.keys) || v.blank? }
 
-      @regexes = Hash[regex_config.map { |section, regex| [section, Regexp.new(regex, 'i') ] }]
+      @regexes = Hash[regex_config.map { |section, regex| [section, Regexp.new(regex, Regexp::IGNORECASE | Regexp::MULTILINE) ] }]
 
       !@regexes.empty? or raise ArgumentError, "Filter #{filter_name} has all blank regexes: #{configuration.inspect}"
     end

data/lib/exception_handling/exception_info.rb

@@ -0,0 +1,272 @@
+module ExceptionHandling
+  class ExceptionInfo
+
+    ENVIRONMENT_WHITELIST = [
+      /^HTTP_/,
+      /^QUERY_/,
+      /^REQUEST_/,
+      /^SERVER_/
+    ]
+
+    ENVIRONMENT_OMIT =(
+<<EOF
+CONTENT_TYPE: application/x-www-form-urlencoded
+GATEWAY_INTERFACE: CGI/1.2
+HTTP_ACCEPT: */*
+HTTP_ACCEPT: */*, text/javascript, text/html, application/xml, text/xml, */*
+HTTP_ACCEPT_CHARSET: ISO-8859-1,utf-8;q=0.7,*;q=0.7
+HTTP_ACCEPT_ENCODING: gzip, deflate
+HTTP_ACCEPT_ENCODING: gzip,deflate
+HTTP_ACCEPT_LANGUAGE: en-us
+HTTP_CACHE_CONTROL: no-cache
+HTTP_CONNECTION: Keep-Alive
+HTTP_HOST: www.invoca.com
+HTTP_MAX_FORWARDS: 10
+HTTP_UA_CPU: x86
+HTTP_VERSION: HTTP/1.1
+HTTP_X_FORWARDED_HOST: www.invoca.com
+HTTP_X_FORWARDED_SERVER: www2.invoca.com
+HTTP_X_REQUESTED_WITH: XMLHttpRequest
+LANG:
+PATH: /sbin:/usr/sbin:/bin:/usr/bin
+PWD: /
+RAILS_ENV: production
+RAW_POST_DATA: id=500
+REMOTE_ADDR: 10.251.34.225
+SCRIPT_NAME: /
+SERVER_NAME: www.invoca.com
+SERVER_PORT: 80
+SERVER_PROTOCOL: HTTP/1.1
+SERVER_SOFTWARE: Mongrel 1.1.4
+SHLVL: 1
+TERM: linux
+TERM: xterm-color
+_: /usr/bin/mongrel_cluster_ctl
+EOF
+      ).split("\n")
+
+    SECTIONS = [:request, :session, :environment, :backtrace, :event_response]
+    HONEYBADGER_CONTEXT_SECTIONS = [:timestamp, :error_class, :exception_context, :server, :scm_revision, :notes, :user_details, :request, :session, :environment, :backtrace, :event_response]
+
+    attr_reader :exception, :controller, :exception_context, :timestamp
+
+    def initialize(exception, exception_context, timestamp, controller = nil, data_callback = nil)
+      @exception = exception
+      @exception_context = exception_context
+      @timestamp = timestamp
+      @controller = controller || controller_from_context(exception_context)
+      @data_callback = data_callback
+    end
+
+    def data
+      @data ||= exception_to_data
+    end
+
+    def enhanced_data
+      @enhanced_data ||= exception_to_enhanced_data
+    end
+
+    def exception_description
+      @exception_description ||= ExceptionHandling.exception_catalog.find(enhanced_data)
+    end
+
+    def send_to_honeybadger?
+      ExceptionHandling.honeybadger? && (!exception_description || exception_description.send_to_honeybadger)
+    end
+
+    def honeybadger_context_data
+      @honeybadger_context_data ||= enhanced_data_to_honeybadger_context
+    end
+
+    private
+
+    def controller_from_context(exception_context)
+      exception_context.is_a?(Hash) ? exception_context["action_controller.instance"] : nil
+    end
+
+    def exception_to_data
+      exception_message = @exception.message.to_s
+      data = ActiveSupport::HashWithIndifferentAccess.new
+      data[:error_class] = @exception.class.name
+      data[:error_string]= "#{data[:error_class]}: #{ExceptionHandling.encode_utf8(exception_message)}"
+      data[:timestamp]   = @timestamp
+      data[:backtrace]   = ExceptionHandling.clean_backtrace(@exception)
+      if @exception_context && @exception_context.is_a?(Hash)
+        # if we are a hash, then we got called from the DebugExceptions rack middleware filter
+        # and we need to do some things different to get the info we want
+        data[:error] = "#{data[:error_class]}: #{ExceptionHandling.encode_utf8(exception_message)}"
+        data[:session] = @exception_context['rack.session']
+        data[:environment] = @exception_context
+      else
+        data[:error]       = "#{data[:error_string]}#{': ' + @exception_context.to_s unless @exception_context.blank?}"
+        data[:environment] = { message: @exception_context }
+      end
+      data
+    end
+
+    def exception_to_enhanced_data
+      enhanced_data = exception_to_data
+      extract_and_merge_controller_data(enhanced_data)
+      customize_from_data_callback(enhanced_data)
+      enhance_exception_data(enhanced_data)
+      normalize_exception_data(enhanced_data)
+      clean_exception_data(enhanced_data)
+      stringify_sections(enhanced_data)
+
+      description = ExceptionHandling.exception_catalog.find(enhanced_data)
+      description ? ActiveSupport::HashWithIndifferentAccess.new(description.exception_data.merge(enhanced_data)) : enhanced_data
+    end
+
+    def enhance_exception_data(data)
+      return if ! ExceptionHandling.custom_data_hook
+      begin
+        ExceptionHandling.custom_data_hook.call(data)
+      rescue Exception => ex
+        # can't call log_error here or we will blow the call stack
+        traces = ex.backtrace.join("\n")
+        ExceptionHandling.log_info("Unable to execute custom custom_data_hook callback. #{ExceptionHandling.encode_utf8(ex.message.to_s)} #{traces}\n")
+      end
+    end
+
+    def normalize_exception_data(data)
+      if data[:location].nil?
+        data[:location] = {}
+        if data[:request] && data[:request].key?(:params)
+          data[:location][:controller] = data[:request][:params]['controller']
+          data[:location][:action]     = data[:request][:params]['action']
+        end
+      end
+      if data[:backtrace] && data[:backtrace].first
+        first_line = data[:backtrace].first
+
+        # template exceptions have the line number and filename as the first element in backtrace
+        if matched = first_line.match( /on line #(\d*) of (.*)/i )
+          backtrace_hash = {}
+          backtrace_hash[:line] = matched[1]
+          backtrace_hash[:file] = matched[2]
+        else
+          backtrace_hash = Hash[* [:file, :line].zip( first_line.split( ':' )[0..1]).flatten ]
+        end
+
+        data[:location].merge!( backtrace_hash )
+      end
+    end
+
+    def clean_exception_data( data )
+      if (as_array = data[:backtrace].to_a).size == 1
+        data[:backtrace] = as_array.first.to_s.split(/\n\s*/)
+      end
+
+      if data[:request].is_a?(Hash) && data[:request][:params].is_a?(Hash)
+        data[:request][:params] = deep_clean_hash(data[:request][:params])
+      end
+
+      if data[:environment].is_a?(Hash)
+        data[:environment] = clean_environment(data[:environment])
+      end
+    end
+
+    def clean_environment(env)
+      Hash[ env.map do |k, v|
+        [k, v] if !"#{k}: #{v}".in?(ENVIRONMENT_OMIT) && ENVIRONMENT_WHITELIST.any? { |regex| k =~ regex }
+      end.compact ]
+    end
+
+    def deep_clean_hash(hash)
+      hash.is_a?(Hash) or return hash
+
+      hash.build_hash do |k, v|
+        value = v.is_a?(Hash) ? deep_clean_hash(v) : filter_sensitive_value(k, v)
+        [k, value]
+      end
+    end
+
+    def filter_sensitive_value(key, value)
+      if key =~ /(password|oauth_token)/
+        "[FILTERED]"
+      elsif key == "rack.request.form_vars" && value.respond_to?(:match) && (captured_matches = value.match(/(.*)(password=)([^&]+)(.*)/)&.captures)
+        [*captured_matches[0..1], "[FILTERED]", *captured_matches[3..-1]].join
+      else
+        value
+      end
+    end
+
+    #
+    # Pull certain fields out of the controller and add to the data hash.
+    #
+    def extract_and_merge_controller_data(data)
+      if @controller
+        data[:request] = {
+          params:      @controller.request.parameters.to_hash,
+          rails_root:  defined?(Rails) && defined?(Rails.root) ? Rails.root : "Rails.root not defined. Is this a test environment?",
+          url:         @controller.complete_request_uri
+        }
+        data[:environment].merge!(@controller.request.env.to_hash)
+
+        @controller.session[:fault_in_session]
+        data[:session] = {
+          key:         @controller.request.session_options[:id],
+          data:        @controller.session.to_hash
+        }
+      end
+    end
+
+    def customize_from_data_callback(data)
+      if @data_callback
+        # the expectation is that if the caller passed a block then they will be
+        # doing their own merge of hash values into data
+        begin
+          @data_callback.call(data)
+        rescue Exception => ex
+          data.merge!(environment: "Exception in yield: #{ex.class}:#{ex}")
+        end
+      end
+    end
+
+    def stringify_sections(data)
+      SECTIONS.each { |section| add_to_s(data[section]) if data[section].is_a?(Hash) }
+    end
+
+    def unstringify_sections(data)
+      SECTIONS.each do |section|
+        if data[section].is_a?(Hash) && data[section].key?(:to_s)
+          data[section] = data[section].dup
+          data[section].delete(:to_s)
+        end
+      end
+    end
+
+    def add_to_s( data_section )
+      data_section[:to_s] = dump_hash( data_section )
+    end
+
+    def dump_hash( h, indent_level = 0 )
+      result = ""
+      h.sort { |a, b| a.to_s <=> b.to_s }.each do |key, value|
+        result << ' ' * (2 * indent_level)
+        result << "#{key}:"
+        case value
+        when Hash
+          result << "\n" << dump_hash( value, indent_level + 1 )
+        else
+          result << " #{value}\n"
+        end
+      end unless h.nil?
+      result
+    end
+
+    def enhanced_data_to_honeybadger_context
+      data = enhanced_data.dup
+      data[:server] = ExceptionHandling.server_name
+      data[:exception_context] = deep_clean_hash(@exception_context) if @exception_context.present?
+      unstringify_sections(data)
+      context_data = HONEYBADGER_CONTEXT_SECTIONS.reduce({}) do |context, section|
+        if data[section].present?
+          context[section] = data[section]
+        end
+        context
+      end
+      context_data
+    end
+  end
+end

data/lib/exception_handling/honeybadger_callbacks.rb

@@ -0,0 +1,42 @@
+module ExceptionHandling
+  module HoneybadgerCallbacks
+    def self.register_callbacks
+      if ExceptionHandling.honeybadger?
+        Honeybadger.local_variable_filter(&method(:local_variable_filter))
+      end
+    end
+
+    private
+
+    def self.local_variable_filter(symbol, object, filter_keys)
+      case object
+      # Honeybadger will filter these data types for us
+      when String, Hash, Array, Set, Numeric, TrueClass, FalseClass, NilClass
+        object
+      else # handle other Ruby objects, intended for POROs
+        inspection_output = object.inspect
+        if contains_filter_key?(filter_keys, inspection_output)
+          filtered_object(object)
+        else
+          inspection_output
+        end
+      end
+    end
+
+    def self.contains_filter_key?(filter_keys, string)
+      filter_keys._?.any? { |key| string.include?(key) }
+    end
+
+    def self.filtered_object(object)
+      # make the output look similar to inspect
+      # use [FILTERED], just like honeybadger does
+      if object.respond_to?(:to_pk)
+        "#<#{object.class.name} @pk=#{object.to_pk}, [FILTERED]>"
+      elsif object.respond_to?(:id)
+        "#<#{object.class.name} @id=#{object.id}, [FILTERED]>"
+      else
+        "#<#{object.class.name} [FILTERED]>"
+      end
+    end
+  end
+end

data/lib/exception_handling/log_stub_error.rb

@@ -11,16 +11,31 @@ module LogErrorStub
     stub_log_error unless respond_to?(:dont_stub_log_error) && dont_stub_log_error
   end
 
+  # if used in Minitest::Test this should be called in `before teardown`
+  # if used in Test::Unit this should be called as the first line of `teardown`
   def teardown_log_error_stub
     ExceptionHandling.stub_handler = nil
     return unless @exception_whitelist
-    @exception_whitelist.each do |item|
-      add_failure("log_error expected #{item[1][:expected]} times with pattern: '#{item[0].is_a?(Regexp) ? item[0].source : item[0]}' #{item[1][:count]} found #{item[1][:found]}") unless item[1][:expected] == item[1][:found]
+
+    @exception_whitelist.each do |pattern, match|
+      unless match[:expected] == match[:found]
+        message = "log_error expected #{match[:expected]} times with pattern: '#{pattern.is_a?(Regexp) ? pattern.source : pattern}' found #{match[:found]}"
+
+        if is_mini_test?
+         flunk(message)
+        else
+          add_failure(message)
+        end
+      end
     end
   end
 
   attr_accessor :exception_whitelist
 
+  # for overriding when testing this module
+  def is_mini_test?
+    defined?(Minitest::Test) && self.is_a?(Minitest::Test)
+  end
   #
   # Call this function in your functional tests - usually first line after a "should" statement
   # once called, you can then call expects_exception
@@ -81,4 +96,4 @@ module LogErrorStub
           "------")
   end
 
-end
+end

data/lib/exception_handling/mailer.rb

@@ -48,6 +48,20 @@ module ExceptionHandling
            :subject => subject)
     end
 
+    def escalate_custom(summary, data, recipients)
+      subject       = "#{email_environment} Escalation: #{summary}"
+      from          = sender_address.gsub('xception', 'scalation')
+      recipients    = recipients
+
+      @summary      = summary
+      @server       = ExceptionHandling.server_name
+      @cleaned_data = data
+
+      mail(:from    => from,
+           :to      => recipients,
+           :subject => subject)
+    end
+
     def log_parser_exception_notification( cleaned_data, key )
       if cleaned_data.is_a?(Hash)
         cleaned_data = cleaned_data.symbolize_keys

data/lib/exception_handling/methods.rb

@@ -1,5 +1,8 @@
+require 'active_support/concern'
+
 module ExceptionHandling
   module Methods # included on models and controllers
+    extend ActiveSupport::Concern
 
     protected
 
@@ -13,7 +16,7 @@ module ExceptionHandling
     end
 
     def log_warning(message)
-      log_error(Warning.new(message))
+      ExceptionHandling.log_warning(message)
     end
 
     def log_info(message)
@@ -57,23 +60,38 @@ module ExceptionHandling
       end
     end
 
-    # Store aside the current controller when included
-    LONG_REQUEST_SECONDS = (defined?(Rails) && Rails.env == 'test' ? 300 : 30)
+    def long_controller_action_timeout
+      if defined?(Rails) && Rails.respond_to?(:env) && Rails.env == 'test'
+        300
+      else
+        30
+      end
+    end
+
     def set_current_controller
       ExceptionHandling.current_controller = self
       result = nil
       time = Benchmark.measure do
         result = yield
       end
-      name = " in #{controller_name}::#{action_name}" rescue " "
-      log_error( "Long controller action detected#{name} %.4fs  " % time.real ) if time.real > LONG_REQUEST_SECONDS && !['development', 'test'].include?(ExceptionHandling.email_environment)
+      if time.real > self.long_controller_action_timeout && !['development', 'test'].include?(ExceptionHandling.email_environment)
+        name = " in #{controller_name}::#{action_name}" rescue " "
+        log_error( "Long controller action detected#{name} %.4fs  " % time.real )
+      end
       result
     ensure
       ExceptionHandling.current_controller = nil
     end
 
-    def self.included( controller )
-      controller.around_filter :set_current_controller if controller.respond_to? :around_filter
+    included do
+      around_filter :set_current_controller if respond_to? :around_filter
+    end
+
+    class_methods do
+      def set_long_controller_action_timeout(timeout)
+        define_method(:long_controller_action_timeout) { timeout }
+        protected :long_controller_action_timeout
+      end
     end
   end
-end
+end