exception_handling 1.2.1 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: b1a9a9df6c3ca8dd4f61b7e35f62271deec138d9
-  data.tar.gz: 8fb61925651d34146c4d86394f4ebb638d45032c
+SHA256:
+  metadata.gz: 925c7332d4385df7c8ccd52f2df818d887e31d64a643c99cc5e682d89ddba535
+  data.tar.gz: 54df02d0d0cedea56c2495de72b2bcf706d2f703111bb46cb80deb34a026d8df
 SHA512:
-  metadata.gz: d43b9121fbffa0b17b2b9ac117d719a8409300c956eb961624e5550dc908b7f6aae0697a7e196ad95d4f9308bbfd137f8dbd0fa937e2f4d316809c9dbf452be3
-  data.tar.gz: 6be898b1d470b87e43e5164954ad2e51e68b6bf01477677da1df75bd50781303e56b14587734162844ebdc4320b70a6732a5e0f475ca0add816911d9b46f19a3
+  metadata.gz: bd8d879e6ea219dbaa979d7436ab30f409f1942277b275fcc6d957d84095da84e14bf6620c4b834d5562012b5abcf6767da3d3a872142d5251f927ffe129191a
+  data.tar.gz: 1a2f9e4c18b47d01919e50ab6c69ef182068b38ff5f9e4656fd6123fcac53d404ce0042c6b23a2aef19791f02dffc248c03a08067a386050ccdd02fb1055657b

data/.ruby-version

@@ -1 +1 @@
-2.1.2
+2.4.2

data/Gemfile

@@ -2,3 +2,20 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in attr_default.gemspec
 gemspec
+
+gem 'hobo_support',   '2.0.1',      git: 'git@github.com:Invoca/hobosupport',    ref: 'b9086322274b474a2b5bae507c4885e55d4aa050'
+gem 'invoca-utils',                 git: 'git@github.com:Invoca/invoca-utils',   ref: '891b8f7e1af0f6324bf85601046907143122e204'
+gem 'activesupport', '>= 4.2.11.1'
+gem 'actionpack',    '>= 4.2.11.1'
+gem 'actionmailer',  '>= 4.2.11.1'
+
+group :development do
+  gem 'rake',    '>=0.9'
+  gem 'shoulda', '> 3.1.1'
+  gem 'rr'
+  gem 'pry'
+end
+
+group :test do
+  gem 'honeybadger', '3.3.1-1', git: 'git@github.com:Invoca/honeybadger-ruby', ref: 'bb5f2b8a86e4147c38a6270d39ad610fab4dd5e6'
+end

data/Gemfile.lock

@@ -1,124 +1,164 @@
+GIT
+  remote: git@github.com:Invoca/hobosupport
+  revision: b9086322274b474a2b5bae507c4885e55d4aa050
+  ref: b9086322274b474a2b5bae507c4885e55d4aa050
+  specs:
+    hobo_support (2.0.1)
+      rails (~> 4.2.10)
+
+GIT
+  remote: git@github.com:Invoca/honeybadger-ruby
+  revision: bb5f2b8a86e4147c38a6270d39ad610fab4dd5e6
+  ref: bb5f2b8a86e4147c38a6270d39ad610fab4dd5e6
+  specs:
+    honeybadger (3.3.1.pre.1)
+
+GIT
+  remote: git@github.com:Invoca/invoca-utils
+  revision: 891b8f7e1af0f6324bf85601046907143122e204
+  ref: 891b8f7e1af0f6324bf85601046907143122e204
+  specs:
+    invoca-utils (0.0.3)
+
 PATH
   remote: .
   specs:
-    exception_handling (1.2.0)
-      actionmailer (~> 3.2)
-      actionpack (~> 3.2)
-      activesupport (~> 3.2)
-      eventmachine (>= 0.12.10)
+    exception_handling (2.2.1)
+      actionmailer (~> 4.2)
+      actionpack (~> 4.2)
+      activesupport (~> 4.2)
+      contextual_logger
+      eventmachine (~> 1.0)
       hobo_support
-      invoca-utils (~> 0.0.2)
+      invoca-utils (~> 0.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    actionmailer (3.2.19)
-      actionpack (= 3.2.19)
-      mail (~> 2.5.4)
-    actionpack (3.2.19)
-      activemodel (= 3.2.19)
-      activesupport (= 3.2.19)
-      builder (~> 3.0.0)
+    actionmailer (4.2.11.1)
+      actionpack (= 4.2.11.1)
+      actionview (= 4.2.11.1)
+      activejob (= 4.2.11.1)
+      mail (~> 2.5, >= 2.5.4)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+    actionpack (4.2.11.1)
+      actionview (= 4.2.11.1)
+      activesupport (= 4.2.11.1)
+      rack (~> 1.6)
+      rack-test (~> 0.6.2)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    actionview (4.2.11.1)
+      activesupport (= 4.2.11.1)
+      builder (~> 3.1)
       erubis (~> 2.7.0)
-      journey (~> 1.0.4)
-      rack (~> 1.4.5)
-      rack-cache (~> 1.2)
-      rack-test (~> 0.6.1)
-      sprockets (~> 2.2.1)
-    activemodel (3.2.19)
-      activesupport (= 3.2.19)
-      builder (~> 3.0.0)
-    activerecord (3.2.19)
-      activemodel (= 3.2.19)
-      activesupport (= 3.2.19)
-      arel (~> 3.0.2)
-      tzinfo (~> 0.3.29)
-    activeresource (3.2.19)
-      activemodel (= 3.2.19)
-      activesupport (= 3.2.19)
-    activesupport (3.2.19)
-      i18n (~> 0.6, >= 0.6.4)
-      multi_json (~> 1.0)
-    arel (3.0.3)
-    bourne (1.3.0)
-      mocha (= 0.13.0)
-    builder (3.0.4)
-    coderay (1.1.0)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+      rails-html-sanitizer (~> 1.0, >= 1.0.3)
+    activejob (4.2.11.1)
+      activesupport (= 4.2.11.1)
+      globalid (>= 0.3.0)
+    activemodel (4.2.11.1)
+      activesupport (= 4.2.11.1)
+      builder (~> 3.1)
+    activerecord (4.2.11.1)
+      activemodel (= 4.2.11.1)
+      activesupport (= 4.2.11.1)
+      arel (~> 6.0)
+    activesupport (4.2.11.1)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    arel (6.0.4)
+    builder (3.2.3)
+    coderay (1.1.2)
+    concurrent-ruby (1.1.5)
+    contextual_logger (0.2.1)
+      json
+    crass (1.0.4)
     erubis (2.7.0)
-    eventmachine (1.0.3)
-    hike (1.2.3)
-    hobo_support (2.0.1)
-      rails (~> 3.2.0)
-    i18n (0.6.11)
-    invoca-utils (0.0.2)
-    journey (1.0.4)
-    json (1.8.1)
-    mail (2.5.4)
-      mime-types (~> 1.16)
-      treetop (~> 1.4.8)
-    metaclass (0.0.1)
-    method_source (0.8.2)
-    mime-types (1.25.1)
-    mocha (0.13.0)
-      metaclass (~> 0.0.1)
-    multi_json (1.10.1)
-    polyglot (0.3.5)
-    pry (0.10.0)
+    eventmachine (1.2.7)
+    globalid (0.4.2)
+      activesupport (>= 4.2.0)
+    i18n (0.9.5)
+      concurrent-ruby (~> 1.0)
+    json (2.2.0)
+    loofah (2.2.3)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    mail (2.7.1)
+      mini_mime (>= 0.1.1)
+    method_source (0.9.2)
+    mini_mime (1.0.1)
+    mini_portile2 (2.4.0)
+    minitest (5.11.3)
+    nokogiri (1.10.3)
+      mini_portile2 (~> 2.4.0)
+    pry (0.12.2)
       coderay (~> 1.1.0)
-      method_source (~> 0.8.1)
-      slop (~> 3.4)
-    rack (1.4.5)
-    rack-cache (1.2)
-      rack (>= 0.4)
-    rack-ssl (1.3.4)
-      rack
-    rack-test (0.6.2)
+      method_source (~> 0.9.0)
+    rack (1.6.11)
+    rack-test (0.6.3)
       rack (>= 1.0)
-    rails (3.2.19)
-      actionmailer (= 3.2.19)
-      actionpack (= 3.2.19)
-      activerecord (= 3.2.19)
-      activeresource (= 3.2.19)
-      activesupport (= 3.2.19)
-      bundler (~> 1.0)
-      railties (= 3.2.19)
-    railties (3.2.19)
-      actionpack (= 3.2.19)
-      activesupport (= 3.2.19)
-      rack-ssl (~> 1.3.2)
+    rails (4.2.11.1)
+      actionmailer (= 4.2.11.1)
+      actionpack (= 4.2.11.1)
+      actionview (= 4.2.11.1)
+      activejob (= 4.2.11.1)
+      activemodel (= 4.2.11.1)
+      activerecord (= 4.2.11.1)
+      activesupport (= 4.2.11.1)
+      bundler (>= 1.3.0, < 2.0)
+      railties (= 4.2.11.1)
+      sprockets-rails
+    rails-deprecated_sanitizer (1.0.3)
+      activesupport (>= 4.2.0.alpha)
+    rails-dom-testing (1.0.9)
+      activesupport (>= 4.2.0, < 5.0)
+      nokogiri (~> 1.6)
+      rails-deprecated_sanitizer (>= 1.0.1)
+    rails-html-sanitizer (1.0.4)
+      loofah (~> 2.2, >= 2.2.2)
+    railties (4.2.11.1)
+      actionpack (= 4.2.11.1)
+      activesupport (= 4.2.11.1)
       rake (>= 0.8.7)
-      rdoc (~> 3.4)
-      thor (>= 0.14.6, < 2.0)
-    rake (10.1.0)
-    rdoc (3.12.2)
-      json (~> 1.4)
-    rr (1.1.2)
-    shoulda (3.1.1)
-      shoulda-context (~> 1.0)
-      shoulda-matchers (~> 1.2)
-    shoulda-context (1.1.4)
-    shoulda-matchers (1.5.6)
-      activesupport (>= 3.0.0)
-      bourne (~> 1.3)
-    slop (3.6.0)
-    sprockets (2.2.2)
-      hike (~> 1.2)
-      multi_json (~> 1.0)
-      rack (~> 1.0)
-      tilt (~> 1.1, != 1.3.0)
-    thor (0.19.1)
-    tilt (1.4.1)
-    treetop (1.4.15)
-      polyglot
-      polyglot (>= 0.3.1)
-    tzinfo (0.3.42)
+      thor (>= 0.18.1, < 2.0)
+    rake (12.3.2)
+    rr (1.2.1)
+    shoulda (3.6.0)
+      shoulda-context (~> 1.0, >= 1.0.1)
+      shoulda-matchers (~> 3.0)
+    shoulda-context (1.2.2)
+    shoulda-matchers (3.1.3)
+      activesupport (>= 4.0.0)
+    sprockets (3.7.2)
+      concurrent-ruby (~> 1.0)
+      rack (> 1, < 3)
+    sprockets-rails (3.2.1)
+      actionpack (>= 4.0)
+      activesupport (>= 4.0)
+      sprockets (>= 3.0.0)
+    thor (0.20.3)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  actionmailer (>= 4.2.11.1)
+  actionpack (>= 4.2.11.1)
+  activesupport (>= 4.2.11.1)
   exception_handling!
+  hobo_support (= 2.0.1)!
+  honeybadger (= 3.3.1.pre.1)!
+  invoca-utils!
   pry
   rake (>= 0.9)
   rr
-  shoulda (= 3.1.1)
+  shoulda (> 3.1.1)
+
+BUNDLED WITH
+   1.16.1

data/README.md

@@ -84,12 +84,21 @@ Then tie this in using the `custom_data_hook`:
 
 There is another hook available intended for custom actions after an error email is sent.  This can be used to send information about errors to your alerting subsystem.  For example:
 
-    def log_error_metrics(exception_data, exception)
-      if exception.is_a?(ExceptionHandling::Warning)
+    def log_error_metrics(exception_data, exception, treat_like_warning, honeybadger_status)
+      if treat_like_warning
         Invoca::Metrics::Client.metrics.counter("exception_handling/warning")
       else
         Invoca::Metrics::Client.metrics.counter("exception_handling/exception")
       end
+      
+      case honeybadger_status
+      when :success
+        Invoca::Metrics::Client.metrics.counter("exception_handling.honeybadger.success")
+      when :failure 
+        Invoca::Metrics::Client.metrics.counter("exception_handling.honeybadger.failure")
+      when :skipped
+        Invoca::Metrics::Client.metrics.counter("exception_handling.honeybadger.skipped")
+      end  
     end
     ExceptionHandling.post_log_error_hook = method(:log_error_metrics)
 

data/config/exception_filters.yml

@@ -3,6 +3,7 @@ Test BS:
   error: "Some BS"
   send_email: true
   notes: "this is used by a test"
+  send_to_honeybadger: true
 
 All script kiddies:
   error: "ScriptKiddie suspected because of HTTP request without a referer"
@@ -48,6 +49,7 @@ InvalidAuth:
 
 NoRoute:
   error: "No route matches"
+  send_to_honeybadger: true
 
 SearchWebPlacementsJson:
   error: "search_web_placement Invalid JSON response from yahoo api"

data/exception_handling.gemspec

@@ -14,15 +14,11 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.version       = ExceptionHandling::VERSION
 
-  spec.add_dependency 'eventmachine', '>=0.12.10'
-  spec.add_dependency 'activesupport', '~> 3.2'
-  spec.add_dependency 'actionpack', '~> 3.2'
-  spec.add_dependency 'actionmailer', '~> 3.2'
-  spec.add_dependency 'invoca-utils', '~> 0.0.2'
+  spec.add_dependency 'eventmachine',  '~> 1.0'
+  spec.add_dependency 'activesupport', '~> 4.2'
+  spec.add_dependency 'actionpack',    '~> 4.2'
+  spec.add_dependency 'actionmailer',  '~> 4.2'
+  spec.add_dependency 'invoca-utils',  '~> 0.0'
   spec.add_dependency 'hobo_support'
-
-  spec.add_development_dependency 'rake', '>=0.9'
-  spec.add_development_dependency 'shoulda', '=3.1.1'
-  spec.add_development_dependency 'rr'
-  spec.add_development_dependency 'pry'
+  spec.add_dependency 'contextual_logger'
 end

data/lib/exception_handling.rb

@@ -1,6 +1,7 @@
 require 'timeout'
 require 'active_support'
 require 'active_support/core_ext/hash'
+require 'contextual_logger'
 
 require 'invoca/utils'
 
@@ -10,6 +11,8 @@ require "exception_handling/methods"
 require "exception_handling/log_stub_error"
 require "exception_handling/exception_description"
 require "exception_handling/exception_catalog"
+require "exception_handling/exception_info"
+require "exception_handling/honeybadger_callbacks.rb"
 
 _ = ActiveSupport::HashWithIndifferentAccess
 
@@ -22,64 +25,17 @@ module ExceptionHandling # never included
   SUMMARY_THRESHOLD = 5
   SUMMARY_PERIOD = 60*60 # 1.hour
 
-  SECTIONS = [:request, :session, :environment, :backtrace, :event_response]
-
-  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:
-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")
-
-  AUTHENTICATION_HEADERS = ['HTTP_AUTHORIZATION','X-HTTP_AUTHORIZATION','X_HTTP_AUTHORIZATION','REDIRECT_X_HTTP_AUTHORIZATION']
+  AUTHENTICATION_HEADERS = ['HTTP_AUTHORIZATION', 'X-HTTP_AUTHORIZATION', 'X_HTTP_AUTHORIZATION', 'REDIRECT_X_HTTP_AUTHORIZATION'].freeze
+  HONEYBADGER_STATUSES   = [:success, :failure, :skipped].freeze
 
   class << self
 
     #
     # required settings
     #
-    attr_accessor :server_name
-    attr_accessor :sender_address
-    attr_accessor :exception_recipients
-    attr_accessor :logger
+    attr_writer :server_name
+    attr_writer :sender_address
+    attr_writer :exception_recipients
 
     def server_name
       @server_name or raise ArgumentError, "You must assign a value to #{self.name}.server_name"
@@ -97,15 +53,41 @@ EOF
       @logger or raise ArgumentError, "You must assign a value to #{self.name}.logger"
     end
 
+    def logger=(logger)
+      @logger = logger.is_a?(ContextualLogger) ? logger : ContextualLogger.new(logger)
+    end
+
+    def default_metric_name(exception_data, exception, treat_like_warning)
+      metric_name = if exception_data['metric_name']
+                      exception_data['metric_name']
+                    elsif exception.is_a?(ExceptionHandling::Warning)
+                      "warning"
+                    elsif treat_like_warning
+                      exception_name = "_#{exception.class.name.split('::').last}" if exception.present?
+                      "unforwarded_exception#{exception_name}"
+                    else
+                      "exception"
+                    end
+
+      "exception_handling.#{metric_name}"
+    end
+
+    def default_honeybadger_metric_name(honeybadger_status)
+      metric_name = if honeybadger_status.in?(HONEYBADGER_STATUSES)
+                      honeybadger_status
+                    else
+                      :unknown_status
+                    end
+      "exception_handling.honeybadger.#{metric_name}"
+    end
+
     #
     # optional settings
     #
+    attr_accessor :production_support_recipients
     attr_accessor :escalation_recipients
     attr_accessor :email_environment
-    attr_accessor :filter_list_filename
     attr_accessor :mailer_send_enabled
-    attr_accessor :eventmachine_safe
-    attr_accessor :eventmachine_synchrony
     attr_accessor :custom_data_hook
     attr_accessor :post_log_error_hook
     attr_accessor :stub_handler
@@ -113,6 +95,10 @@ EOF
     attr_accessor :sensu_port
     attr_accessor :sensu_prefix
 
+    attr_reader :filter_list_filename
+    attr_reader :eventmachine_safe
+    attr_reader :eventmachine_synchrony
+
     @filter_list_filename = "./config/exception_filters.yml"
     @mailer_send_enabled  = true
     @email_environment = ""
@@ -142,6 +128,15 @@ EOF
       @eventmachine_synchrony = bool
     end
 
+    def filter_list_filename=(filename)
+      @filter_list_filename = filename
+      @exception_catalog = nil
+    end
+
+    def exception_catalog
+      @exception_catalog ||= ExceptionCatalog.new(@filter_list_filename)
+    end
+
     #
     # internal settings (don't set directly)
     #
@@ -159,10 +154,10 @@ EOF
     #
     def log_error_rack(exception, env, rack_filter)
       timestamp = set_log_error_timestamp
-      exception_data = exception_to_data(exception, env, timestamp)
+      exception_info = ExceptionInfo.new(exception, env, timestamp)
 
       if stub_handler
-        return stub_handler.handle_stub_log_error(exception_data)
+        return stub_handler.handle_stub_log_error(exception_info.data)
       end
 
       # TODO: add a more interesting custom description, like:
@@ -172,91 +167,94 @@ EOF
       write_exception_to_log(exception, custom_description, timestamp)
 
       if honeybadger?
-        send_exception_to_honeybadger(exception, nil, timestamp)
+        send_exception_to_honeybadger(exception_info)
       end
 
       if should_send_email?
-        controller = env['action_controller.instance']
         # controller may not exist in some cases (like most 404 errors)
-        if controller
-          extract_and_merge_controller_data(controller, exception_data)
-          controller.session["last_exception_timestamp"] = ExceptionHandling.last_exception_timestamp
+        if (controller = exception_info.controller)
+          controller.session["last_exception_timestamp"] = last_exception_timestamp
         end
-        log_error_email(exception_data, exception)
+        log_error_email(exception_info)
       end
     end
 
     #
     # Normal Operation:
     #   Called directly by our code, usually from rescue blocks.
-    #   Does two things: write to log file and send an email
+    #   Does three things: write to log file and send an email, may also send to honeybadger if defined
     #
     # Functional Test Operation:
     #   Calls into handle_stub_log_error and returns. no log file. no email.
     #
-    def log_error(exception_or_string, exception_context = '', controller = nil, treat_as_local = false)
+    def log_error(exception_or_string, exception_context = '', controller = nil, treat_like_warning: false, **log_context, &data_callback)
       begin
         ex = make_exception(exception_or_string)
         timestamp = set_log_error_timestamp
-        data = exception_to_data(ex, exception_context, timestamp)
+        exception_info = ExceptionInfo.new(ex, exception_context, timestamp, controller || current_controller, data_callback)
 
         if stub_handler
-          return stub_handler.handle_stub_log_error(data)
-        end
-
-        write_exception_to_log(ex, exception_context, timestamp)
-
-        if honeybadger?
-          send_exception_to_honeybadger(ex, exception_context, timestamp)
-        end
-
-        if treat_as_local
-          return
-        end
-
-        if should_send_email?
-          controller ||= current_controller
-
-          if block_given?
-            # the expectation is that if the caller passed a block then they will be
-            # doing their own merge of hash values into data
-            begin
-              yield data
-            rescue Exception => ex
-              data.merge!(:environment => "Exception in yield: #{ex.class}:#{ex}")
-            end
-          elsif controller
-          # most of the time though, this method will not get passed a block
-          # and additional hash data is extracted from the controller
-            extract_and_merge_controller_data(controller, data)
-          end
-
-          log_error_email(data, ex)
+          stub_handler.handle_stub_log_error(exception_info.data)
+        else
+          write_exception_to_log(ex, exception_context, timestamp, **log_context)
+          external_notification_results = unless treat_like_warning || ex.is_a?(Warning)
+                                            send_external_notifications(exception_info)
+                                          end || {}
+          execute_custom_log_error_callback(exception_info.enhanced_data, exception_info.exception, treat_like_warning, external_notification_results)
+          nil
         end
-
       rescue LogErrorStub::UnexpectedExceptionLogged, LogErrorStub::ExpectedExceptionNotLogged
         raise
       rescue Exception => ex
-        $stderr.puts("ExceptionHandling.log_error rescued exception while logging #{exception_context}: #{exception_or_string}:\n#{ex.class}: #{ex}\n#{ex.backtrace.join("\n")}")
-        write_exception_to_log(ex, "ExceptionHandling.log_error rescued exception while logging #{exception_context}: #{exception_or_string}", timestamp)
+        $stderr.puts("ExceptionHandlingError: log_error rescued exception while logging #{exception_context}: #{exception_or_string}:\n#{ex.class}: #{ex.message}\n#{ex.backtrace.join("\n")}")
+        write_exception_to_log(ex, "ExceptionHandlingError: log_error rescued exception while logging #{exception_context}: #{exception_or_string}", timestamp)
       end
     end
 
     #
     # Write an exception out to the log file using our own custom format.
     #
-    def write_exception_to_log(ex, exception_context, timestamp)
+    def write_exception_to_log(ex, exception_context, timestamp, **log_context)
       ActiveSupport::Deprecation.silence do
-        ExceptionHandling.logger.fatal("\n(Error:#{timestamp}) #{ex.class} #{exception_context} (#{encode_utf8(ex.message)}):\n  " + clean_backtrace(ex).join("\n  ") + "\n\n")
+        ExceptionHandling.logger.fatal("\nExceptionHandlingError (Error:#{timestamp}) #{ex.class} #{exception_context} (#{encode_utf8(ex.message.to_s)}):\n  " + clean_backtrace(ex).join("\n  ") + "\n\n", **log_context)
+      end
+    end
+
+    #
+    # Send notifications to configured external services
+    #
+    def send_external_notifications(exception_info)
+      results = {}
+      if honeybadger?
+        results[:honeybadger_status] = send_exception_to_honeybadger(exception_info)
+      end
+
+      if should_send_email?
+        log_error_email(exception_info)
       end
+      results
     end
 
     #
     # Log exception to honeybadger.io.
     #
-    def send_exception_to_honeybadger(ex, exception_context, timestamp)
-      custom_message = "(Error:#{timestamp}) #{ex.class} #{exception_context} (#{encode_utf8(ex.message)}): " + clean_backtrace(ex).join(" ")
-      Honeybadger.notify(ex, context: { custom_message: custom_message })
+    def send_exception_to_honeybadger(exception_info)
+      exception             = exception_info.exception
+      exception_description = exception_info.exception_description
+      if exception_info.send_to_honeybadger?
+        response = Honeybadger.notify(error_class:   exception_description ? exception_description.filter_name : exception.class.name,
+                                      error_message: exception.message.to_s,
+                                      exception:     exception,
+                                      context:       exception_info.honeybadger_context_data)
+        response ? :success : :failure
+      else
+        log_info("Filtered exception using '#{exception_description.filter_name}'; not sending notification to Honeybadger")
+        :skipped
+      end
+    rescue Exception => ex
+      $stderr.puts("ExceptionHandling.send_exception_to_honeybadger rescued exception while logging #{exception_info.exception_context}:\n#{exception.class}: #{exception.message}:\n#{ex.class}: #{ex.message}\n#{ex.backtrace.join("\n")}")
+      write_exception_to_log(ex, "ExceptionHandling.send_exception_to_honeybadger rescued exception while logging #{exception_info.exception_context}:\n#{exception.class}: #{exception.message}", exception_info.timestamp)
+      :failure
     end
 
     #
@@ -267,74 +265,77 @@ EOF
     end
 
     #
-    # Pull certain fields out of the controller and add to the data hash.
+    # Expects passed in hash to only include keys which be directly set on the Honeybadger config
     #
-    def extract_and_merge_controller_data(controller, data)
-      data[:request] = {
-        :params      => controller.request.parameters.to_hash,
-        :rails_root  => defined?(Rails) ? 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.dup
-      }
+    def enable_honeybadger(config = {})
+      Bundler.require(:honeybadger)
+      HoneybadgerCallbacks.register_callbacks
+      Honeybadger.configure do |config_klass|
+        config.each do |k, v|
+          config_klass.send(:"#{k}=", v)
+        end
+      end
     end
 
-    def log_warning( message )
-      log_error( Warning.new(message) )
+    def log_warning(message, **log_context)
+      warning = Warning.new(message)
+      warning.set_backtrace([])
+      log_error(warning, **log_context)
     end
 
-    def log_info( message )
-      ExceptionHandling.logger.info( message )
+    def log_info(message, **log_context)
+      ExceptionHandling.logger.info(message, **log_context)
     end
 
-    def log_debug( message )
-      ExceptionHandling.logger.debug( message )
+    def log_debug(message, **log_context)
+      ExceptionHandling.logger.debug(message, **log_context)
     end
 
-    def ensure_safe( exception_context = "" )
+    def ensure_safe(exception_context = "", **log_context)
       yield
     rescue => ex
-      log_error ex, exception_context
+      log_error ex, exception_context, **log_context
       return nil
     end
 
-    def ensure_completely_safe( exception_context = "" )
+    def ensure_completely_safe(exception_context = "", **log_context)
       yield
     rescue SystemExit, SystemStackError, NoMemoryError, SecurityError, SignalException
       raise
     rescue Exception => ex
-      log_error ex, exception_context
+      log_error ex, exception_context, log_context
     end
 
-    def escalate_error(exception_or_string, email_subject)
+    def escalate_to_production_support(exception_or_string, email_subject)
+      production_support_recipients or raise ArgumentError, "In order to escalate to production support, you must set #{self.name}.production_recipients"
       ex = make_exception(exception_or_string)
-      log_error(ex)
-      escalate(email_subject, ex, ExceptionHandling.last_exception_timestamp)
+      escalate_custom(email_subject, ex, last_exception_timestamp, production_support_recipients)
     end
 
-    def escalate_warning(message, email_subject)
+    def escalate_error(exception_or_string, email_subject, **log_context)
+      ex = make_exception(exception_or_string)
+      log_error(ex, **log_context)
+      escalate(email_subject, ex, last_exception_timestamp)
+    end
+
+    def escalate_warning(message, email_subject, **log_context)
       ex = Warning.new(message)
-      log_error(ex)
-      escalate(email_subject, ex, ExceptionHandling.last_exception_timestamp)
+      log_error(ex, **log_context)
+      escalate(email_subject, ex, last_exception_timestamp)
     end
 
-    def ensure_escalation(email_subject)
+    def ensure_escalation(email_subject, **log_context)
       begin
         yield
       rescue => ex
-        escalate_error(ex, email_subject)
+        escalate_error(ex, email_subject, **log_context)
         nil
       end
     end
 
-    def alert_warning(exception_or_string, alert_name, exception_context)
+    def alert_warning(exception_or_string, alert_name, exception_context, **log_context)
       ex = make_exception(exception_or_string)
-      log_error(ex, exception_context)
+      log_error(ex, exception_context, **log_context)
       begin
         ExceptionHandling::Sensu.generate_event(alert_name, exception_context.to_s + "\n" + encode_utf8(ex.message.to_s))
       rescue => send_ex
@@ -342,11 +343,11 @@ EOF
       end
     end
 
-    def ensure_alert(alert_name, exception_context)
+    def ensure_alert(alert_name, exception_context, **log_context)
       begin
         yield
       rescue => ex
-        alert_warning(ex, alert_name, exception_context)
+        alert_warning(ex, alert_name, exception_context, **log_context)
         nil
       end
     end
@@ -368,62 +369,82 @@ EOF
       result
     end
 
-    def log_periodically(exception_key, interval, message)
+    def log_periodically(exception_key, interval, message, **log_context)
       self.periodic_exception_intervals ||= {}
       last_logged = self.periodic_exception_intervals[exception_key]
-      if !last_logged || ( (last_logged + interval) < Time.now )
-        log_error( message )
+      if !last_logged || ((last_logged + interval) < Time.now)
+        log_error(message, **log_context)
         self.periodic_exception_intervals[exception_key] = Time.now
       end
     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
-        log_info( "Unable to execute custom custom_data_hook callback. #{encode_utf8(ex.message)} #{ex.backtrace.each {|l| "#{l}\n"}}" )
-      end
+    def encode_utf8(string)
+      string.encode('UTF-8',
+                    replace: '?',
+                    undef:   :replace,
+                    invalid: :replace)
     end
 
-    private
+    def clean_backtrace(exception)
+      backtrace = if exception.backtrace.nil?
+        ['<no backtrace>']
+      elsif exception.is_a?(ClientLoggingError)
+        exception.backtrace
+      elsif defined?(Rails) && defined?(Rails.backtrace_cleaner)
+        Rails.backtrace_cleaner.clean(exception.backtrace)
+      else
+        exception.backtrace
+      end
 
-    def log_error_email( data, exc )
-      enhance_exception_data( data )
-      normalize_exception_data( data )
-      clean_exception_data( data )
+      # The rails backtrace cleaner returns an empty array for a backtrace if the exception was raised outside the app (inside a gem for instance)
+      if backtrace.is_a?(Array) && backtrace.empty?
+        exception.backtrace
+      else
+        backtrace
+      end
+    end
 
-      SECTIONS.each { |section| add_to_s( data[section] ) if data[section].is_a? Hash }
+    private
 
-      exception_description = exception_catalog.find( data )
-      merged_data = exception_description ? ActiveSupport::HashWithIndifferentAccess.new(exception_description.exception_data.merge(data)) : data
+    def log_error_email(exception_info)
+      data = exception_info.enhanced_data
+      exception_description = exception_info.exception_description
 
       if exception_description && !exception_description.send_email
-        ExceptionHandling.logger.warn( "Filtered exception using '#{exception_description.filter_name}'; not sending email to notify" )
+        ExceptionHandling.logger.warn(
+          "Filtered exception using '#{exception_description.filter_name}'; not sending email to notify"
+        )
       else
-        if summarize_exception( merged_data ) != :Summarized
-          deliver(ExceptionHandling::Mailer.exception_notification(merged_data))
+        if summarize_exception(data) != :Summarized
+          deliver(ExceptionHandling::Mailer.exception_notification(data))
         end
       end
-
-      execute_custom_log_error_callback(merged_data, exc)
       nil
+    rescue Exception => ex
+      $stderr.puts("ExceptionHandling.log_error_email rescued exception while logging #{exception_info.exception_context}: #{exception_info.exception}:\n#{ex.class}: #{ex}\n#{ex.backtrace.join("\n")}")
+      write_exception_to_log(ex, "ExceptionHandling.log_error_email rescued exception while logging #{exception_info.exception_context}: #{exception_info.exception}", exception_info.timestamp)
     end
 
-    def execute_custom_log_error_callback(exception_data, exception)
-      return if ! ExceptionHandling.post_log_error_hook
-      begin
-        ExceptionHandling.post_log_error_hook.call(exception_data, exception)
-      rescue Exception => ex
-        # can't call log_error here or we will blow the call stack
-        log_info( "Unable to execute custom log_error callback. #{encode_utf8(ex.message)} #{ex.backtrace.each {|l| "#{l}\n"}}" )
+    def execute_custom_log_error_callback(exception_data, exception, treat_like_warning, external_notification_results)
+      if ExceptionHandling.post_log_error_hook
+        honeybadger_status = external_notification_results[:honeybadger_status] || :skipped
+        ExceptionHandling.post_log_error_hook.call(exception_data, exception, treat_like_warning, honeybadger_status)
       end
+    rescue Exception => ex
+      # can't call log_error here or we will blow the call stack
+      ex_message = encode_utf8(ex.message.to_s)
+      ex_backtrace = ex.backtrace.each { |l| "#{l}\n" }
+      log_info("Unable to execute custom log_error callback. #{ex_message} #{ex_backtrace}")
     end
 
-    def escalate( email_subject, ex, timestamp )
-      data = exception_to_data( ex, nil, timestamp )
-      deliver(ExceptionHandling::Mailer.escalation_notification(email_subject, data))
+    def escalate(email_subject, ex, timestamp)
+      exception_info = ExceptionInfo.new(ex, nil, timestamp)
+      deliver(ExceptionHandling::Mailer.escalation_notification(email_subject, exception_info.data))
+    end
+
+    def escalate_custom(email_subject, ex, timestamp, recipients)
+      exception_info = ExceptionInfo.new(ex, nil, timestamp)
+      deliver(ExceptionHandling::Mailer.escalate_custom(email_subject, exception_info.data, recipients))
     end
 
     def deliver(mail_object)
@@ -431,23 +452,27 @@ EOF
         EventMachine.schedule do # in case we're running outside the reactor
           async_send_method = ExceptionHandling.eventmachine_synchrony ? :asend : :send
           smtp_settings = ActionMailer::Base.smtp_settings
-          send_deferrable = EventMachine::Protocols::SmtpClient.__send__(
-              async_send_method,
-              {
-                :host     => smtp_settings[:address],
-                :port     => smtp_settings[:port],
-                :domain   => smtp_settings[:domain],
-                :auth     => {:type=>:plain, :username=>smtp_settings[:user_name], :password=>smtp_settings[:password]},
-                :from     => mail_object['from'].to_s,
-                :to       => mail_object['to'].to_s,
-                :content     => "#{mail_object}\r\n.\r\n"
-              }
-          )
-          send_deferrable.errback { |err| ExceptionHandling.logger.fatal("Failed to email by SMTP: #{err.inspect}") }
+          dns_deferrable = EventMachine::DNS::Resolver.resolve(smtp_settings[:address])
+          dns_deferrable.callback do |addrs|
+            send_deferrable = EventMachine::Protocols::SmtpClient.__send__(
+                async_send_method,
+                {
+                  :host     => addrs.first,
+                  :port     => smtp_settings[:port],
+                  :domain   => smtp_settings[:domain],
+                  :auth     => {:type=>:plain, :username=>smtp_settings[:user_name], :password=>smtp_settings[:password]},
+                  :from     => mail_object['from'].to_s,
+                  :to       => mail_object['to'].to_s,
+                  :content     => "#{mail_object}\r\n.\r\n"
+                }
+            )
+            send_deferrable.errback { |err| ExceptionHandling.logger.fatal("Failed to email by SMTP: #{err.inspect}") }
+          end
+          dns_deferrable.errback  { |err| ExceptionHandling.logger.fatal("Failed to resolv DNS for #{smtp_settings[:address]}: #{err.inspect}") }
         end
       else
         safe_email_deliver do
-          mail_object.deliver
+          mail_object.deliver_now
         end
       end
     end
@@ -458,80 +483,7 @@ EOF
       end
     rescue StandardError, MailerTimeout => ex
       #$stderr.puts("ExceptionHandling::safe_email_deliver rescued: #{ex.class}: #{ex}\n#{ex.backtrace.join("\n")}")
-      log_error( ex, "ExceptionHandling::safe_email_deliver", nil, true )
-    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] = clean_params(data[:request][:params])
-      end
-
-      if data[:environment].is_a?(Hash)
-        data[:environment] = clean_environment(data[:environment])
-      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_params params
-      params.each do |k, v|
-        params[k] = "[FILTERED]" if k =~ /password/
-      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 exception_catalog
-      @exception_catalog ||= ExceptionCatalog.new( ExceptionHandling.filter_list_filename )
-    end
-
-    def clean_backtrace(exception)
-      backtrace = if exception.backtrace.nil?
-        ['<no backtrace>']
-      elsif exception.is_a?(ClientLoggingError)
-        exception.backtrace
-      elsif defined?(Rails)
-        Rails.backtrace_cleaner.clean(exception.backtrace)
-      else
-        exception.backtrace
-      end
-
-      # The rails backtrace cleaner returns an empty array for a backtrace if the exception was raised outside the app (inside a gem for instance)
-      if backtrace.is_a?(Array) && backtrace.empty?
-        exception.backtrace
-      else
-        backtrace
-      end
+      log_error(ex, "ExceptionHandling::safe_email_deliver", nil, treat_like_warning: true)
     end
 
     def clear_exception_summary
@@ -539,8 +491,8 @@ EOF
     end
 
     # Returns :Summarized iff exception has been added to summary and therefore should not be sent.
-    def summarize_exception( data )
-      if @last_exception
+    def summarize_exception(data)
+      if defined?(@last_exception) && @last_exception
         same_signature = @last_exception[:backtrace] == data[:backtrace]
 
         case @last_exception[:state]
@@ -582,36 +534,15 @@ EOF
       nil
     end
 
-    def send_exception_summary( exception_data, first_seen, occurrences )
+    def send_exception_summary(exception_data, first_seen, occurrences)
       Timeout::timeout 30, MailerTimeout do
         deliver(ExceptionHandling::Mailer.exception_notification(exception_data, first_seen, occurrences))
       end
     rescue StandardError, MailerTimeout => ex
-      $stderr.puts("ExceptionHandling.log_error_email rescued exception while logging #{exception_context}: #{exception_or_string}:\n#{ex.class}: #{ex}\n#{ex.backtrace.join("\n")}")
-      log_error(ex, "ExceptionHandling::log_error_email rescued exception while logging #{exception_context}: #{exception_or_string}", nil, true)
-    end
-
-    def add_to_s( data_section )
-      data_section[:to_s] = dump_hash( data_section )
-    end
-
-    def exception_to_data( exception, exception_context, timestamp )
-      data = ActiveSupport::HashWithIndifferentAccess.new
-      data[:error_class] = exception.class.name
-      data[:error_string]= "#{data[:error_class]}: #{encode_utf8(exception.message)}"
-      data[:timestamp]   = timestamp
-      data[:backtrace]   = 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]}: #{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
+      original_error = exception_data[:error_string]
+      log_prefix = "ExceptionHandling.log_error_email rescued exception while logging #{original_error}"
+      $stderr.puts("#{log_prefix}:\n#{ex.class}: #{ex}\n#{ex.backtrace.join("\n")}")
+      log_info(log_prefix)
     end
 
     def make_exception(exception_or_string)
@@ -626,27 +557,5 @@ EOF
         end
       end
     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 encode_utf8(string)
-      string.encode('UTF-8',
-                    replace: '?',
-                    undef:   :replace,
-                    invalid: :replace)
-    end
   end
 end