exception_handling 0.1.1

data/.gitignore

@@ -0,0 +1 @@
+.idea

data/Gemfile

@@ -0,0 +1,6 @@
+# ruby '1.8.7'
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in attr_default.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,79 @@
+PATH
+  remote: .
+  specs:
+    exception_handling (0.1.1)
+      actionmailer (= 3.2.13)
+      actionpack (= 3.2.13)
+      activesupport (= 3.2.13)
+      eventmachine (>= 0.12.10)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionmailer (3.2.13)
+      actionpack (= 3.2.13)
+      mail (~> 2.5.3)
+    actionpack (3.2.13)
+      activemodel (= 3.2.13)
+      activesupport (= 3.2.13)
+      builder (~> 3.0.0)
+      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.13)
+      activesupport (= 3.2.13)
+      builder (~> 3.0.0)
+    activesupport (3.2.13)
+      i18n (= 0.6.1)
+      multi_json (~> 1.0)
+    bourne (1.3.0)
+      mocha (= 0.13.0)
+    builder (3.0.4)
+    erubis (2.7.0)
+    eventmachine (1.0.3)
+    hike (1.2.3)
+    i18n (0.6.1)
+    journey (1.0.4)
+    mail (2.5.4)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    metaclass (0.0.1)
+    mime-types (1.24)
+    mocha (0.13.0)
+      metaclass (~> 0.0.1)
+    multi_json (1.7.8)
+    polyglot (0.3.3)
+    rack (1.4.5)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rake (10.1.0)
+    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)
+    sprockets (2.2.2)
+      hike (~> 1.2)
+      multi_json (~> 1.0)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    tilt (1.4.1)
+    treetop (1.4.15)
+      polyglot
+      polyglot (>= 0.3.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  exception_handling!
+  mocha (= 0.13.0)
+  rake (>= 0.9)
+  shoulda (= 3.1.1)

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Colin Kelley, RingRevenue
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1 @@
+exception_handling gem

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+task :default => :test
+
+desc "Run unit tests."
+task :test do
+  ruby "test/exception_handling_test.rb"
+end

data/config/exception_filters.yml

@@ -0,0 +1,138 @@
+--- !map:HashWithIndifferentAccess
+All script kiddies:
+  error: "ScriptKiddie suspected because of HTTP request without a referer"
+
+Tony Robbins:
+  request: "  url: https?\:\/\/www\.tonyrobbins\.com"
+
+Soulful Beauty:
+  request: "HTTP_REFERER: http://.*soulfulbeauty\.com"
+
+The Credit Exchange:
+  error: "VirtualLine.find_by_external_ids - No promo number found.*Affiliate id from network (1389811|3079560|3366822|3179522|3375281|3375756|3362634|550151) not found"
+  request: "av_id: 178$"
+
+Spiders:
+  environment: "Microsoft-WebDAV|COMODOspider|Baiduspider|YandexBot|TurnitinBot"
+
+Googlebot:
+  environment: "googlebot"
+  error: "ReferenceError: Can't find variable: RingRevenue"
+
+Options Request:
+  environment: "REQUEST_METHOD: OPTIONS"
+
+Click Request Rejected:
+  error: "Request to click domain rejected"
+  request: "controller: corporate"
+
+Staging Full Started:
+  error: "Mysql::Error: Can't connect to MySQL server on 'stagingmaster.ringrevenue.com'"
+
+Google Analytics:
+  error: "ActionController.*RoutingError*google-analytics.*"
+
+TermsLinksBroken:
+  error: "Logged in user experienced broken link on.*advertiser_campaign_terms"
+
+NoRouteOnTerms:
+  error: "ActionController.*RoutingError.*No route matches.*campaign_terms"
+
+InvalidAuth:
+  error: "Invalid authenticity token received from.*new\?"
+
+NoRoute:
+  error: "No route matches"
+
+SearchWebPlacementsJson:
+  error: "search_web_placement Invalid JSON response from yahoo api"
+
+Rss 404s from Java:
+  request: "controller: articles"
+  error: "ActionController.*UnknownAction"
+  environment: "HTTP_USER_AGENT: Java"
+
+Archiver mangling caused missing template:
+  error: "Missing template corporate/platform.erb"
+  environment: "(aihit|archive)"
+
+Number Loader 404s from invalid url concatenation:
+  request: "url: https?:\/\/js\d{0,2}\.ringrevenue.com\/"
+  error: "Broken link.*ActiveRecord::RecordNotFound"
+
+collegequest bad TLD:
+  error: "Hostname 'me.cq' does not have a known public suffix"
+
+Ignite calls API:
+  request: "calls\/10\.xml"
+
+BrokenLinkAfterLogin:
+  error: "Found broken link after user logged in from"
+
+Link Trust Pixel Firing:
+  error: "Errno::ECONNREFUSED.*(linktrust\.com|mobitracking\.com|xy7track\.com|mbltrack\.com)"
+
+# JAVASCRIPT exceptions
+# http://www.roslindesign.com/2010/10/12/avg-antivirus-2011-corrupting-web-pages-with-injection-of-script-avg_ls_dom-js/
+AVG Anti Virus:
+  request: "avg_ls_dom\.js"
+
+Firefox Framework Bug:
+  error: "Javascript: window.onerror: Permission denied to access property 'nodeType' from a non-chrome context"
+  request: "action: javascript_error"
+
+Javascript Error Loading Script:
+  error: "Javascript: window.onerror: Error loading script"
+  request: "filename: .*hubspot\.com.*"
+
+Javascript Plugin Errors:
+  error: "Javascript: window.onerror: Script error"
+  request: "filename: chrome://leapfrog.*"
+
+Javascript users with browser plugin issues:
+  error: "Javascript: .*"
+  session: "user_id: (42595|58296|61276|74059)"
+
+Calls API Errors:
+  error: "calls_api returning status not_found"
+
+Duplicate Sales Reported:
+  error: "Call.update_order called with duplicate sales"
+
+Sale for the same reason and sku:
+  error: "Sale for the same reason and sku"
+
+Found Inconsistent Caller Id Settings:
+  error: "CampaignIds:CampaignTerms_7542,CampaignTerms_7544,CampaignTerms_8242,CampaignTerms_8478,CampaignTerms_9244"
+
+Invalid tacked_action referrer:
+  error: "StandardError: process_click_from_network_id - saving click failed.: Mysql::Error: Incorrect string value:.*for column 'referrer'.*INSERT INTO `tracked_actions`"
+
+invalid click domain rdparking:
+  error: "Request to click domain rejected"
+  request: ".*rdparking.*"
+
+update order with duplicate sales:
+  error: "update_order called with duplicate sales information"
+
+failsafe on vxml because readonly:
+  error: "The MySQL server is running with the --read-only option so it cannot execute this statement.*INSERT INTO simple_sessions"
+
+failsafe on propfind:
+  error: "UnknownHttpMethod: PROPFIND"
+
+pixel_misconfigured:
+  error: "PixelUrlTemplate substitution"
+
+buffered_sale:
+  error: "Couldn't apply BufferedSale"
+
+SQL Injection Attempts:
+  request: "controller: virtual_lines"
+  request: "av_id: \D\d*\D\d*\D\d*\D"
+
+Opera Browser:
+  environment: "HTTP_USER_AGENT: Opera"
+
+Affiliate Map Number invalid requests:
+  error: "Publisher Map Number returning with invalid campaign"

data/exception_handling.gemspec

@@ -0,0 +1,24 @@
+require File.expand_path('../lib/exception_handling/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.add_dependency 'eventmachine', '>=0.12.10'
+  gem.add_dependency 'activesupport', '3.2.13'
+  gem.add_dependency 'actionpack', '3.2.13'
+  gem.add_dependency 'actionmailer', '3.2.13'
+  gem.add_development_dependency 'rake', '>=0.9'
+  gem.add_development_dependency 'shoulda', '=3.1.1'
+  gem.add_development_dependency 'mocha', '=0.13.0'
+
+  gem.authors       = ["Colin Kelley"]
+  gem.email         = ["colindkelley@gmail.com"]
+  gem.description   = %q{Exception handling logger/emailer}
+  gem.summary       = %q{RingRevenue's exception handling logger/emailer layer, based on exception_notifier. Works with Rails or EventMachine or EventMachine+Synchrony.}
+  gem.homepage      = "https://github.com/RingRevenue/exception_handling"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/.*\.rb})
+  gem.name          = "exception_handling"
+  gem.require_paths = ["lib"]
+  gem.version       = ExceptionHandling::VERSION
+end

data/lib/exception_handling/version.rb

@@ -0,0 +1,3 @@
+module ExceptionHandling
+  VERSION = "0.1.1"
+end

data/lib/exception_handling.rb

@@ -0,0 +1,630 @@
+require 'timeout'
+require 'active_support'
+require 'active_support/core_ext/hash'
+require "#{File.dirname(__FILE__)}/exception_handling_mailer"
+
+EXCEPTION_HANDLING_MAILER_SEND_MAIL = true unless defined?(EXCEPTION_HANDLING_MAILER_SEND_MAIL)
+
+_ = ActiveSupport::HashWithIndifferentAccess
+
+if defined?(EVENTMACHINE_EXCEPTION_HANDLING) && EVENTMACHINE_EXCEPTION_HANDLING
+  require 'em/protocols/smtpclient'
+end
+
+module ExceptionHandling # never included
+
+  class Warning < StandardError; end
+  class MailerTimeout < Timeout::Error; end
+  class ClientLoggingError < StandardError; end
+
+  SUMMARY_THRESHOLD = 5
+  SUMMARY_PERIOD = 60*60 # 1.hour
+
+
+  SECTIONS = [:request, :session, :environment, :backtrace, :event_response]
+  EXCEPTION_FILTER_LIST_PATH = "#{defined?(Rails) ? Rails.root : '.'}/config/exception_filters.yml"
+
+  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.ringrevenue.com
+HTTP_MAX_FORWARDS: 10
+HTTP_UA_CPU: x86
+HTTP_VERSION: HTTP/1.1
+HTTP_X_FORWARDED_HOST: www.ringrevenue.com
+HTTP_X_FORWARDED_SERVER: www2.ringrevenue.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.ringrevenue.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']
+
+  @logger = Rails.logger if defined?(Rails)
+
+
+  class << self
+    attr_accessor :email_environment
+    attr_accessor :server_name
+    attr_accessor :sender_address
+    attr_accessor :exception_recipients
+
+    attr_accessor :current_controller
+    attr_accessor :last_exception_timestamp
+    attr_accessor :periodic_exception_intervals
+    attr_accessor :logger
+
+    #
+    # Gets called by Rack Middleware: DebugExceptions or ShowExceptions
+    # it does 2 things:
+    #   log the error
+    #   email the error
+    #
+    # but not during functional tests, when rack middleware is not used
+    #
+    def log_error_rack(exception, env, rack_filter)
+      timestamp = set_log_error_timestamp
+      exception_data = exception_to_data(exception, env, timestamp)
+
+      # TODO: add a more interesting custom description, like:
+      # custom_description = ": caught and processed by Rack middleware filter #{rack_filter}"
+      # which would be nice, but would also require changing quite a few tests
+      custom_description = ""
+      write_exception_to_log(exception, custom_description, timestamp)
+
+      if should_send_email?
+        controller = env['action_controller.instance']
+        # controller may not exist in some cases (like most 404 errors)
+        extract_and_merge_controller_data(controller, exception_data) if controller
+        log_error_email(exception_data, exception)
+      end
+    end
+
+    #
+    # Normal Operation:
+    #   Called directly by our code, usually from rescue blocks.
+    #   Does two things: write to log file and send an email
+    #
+    # 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)
+      begin
+        ex = make_exception(exception_or_string)
+        timestamp = set_log_error_timestamp
+        data = exception_to_data(ex, exception_context, timestamp)
+
+        write_exception_to_log(ex, exception_context, timestamp)
+
+        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)
+        end
+
+      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)
+      end
+    end
+
+    #
+    # Write an exception out to the log file using our own custom format.
+    #
+    def write_exception_to_log(ex, exception_context, timestamp)
+      ActiveSupport::Deprecation.silence do
+        ExceptionHandling.logger.fatal(
+          if ActionView::TemplateError === ex
+            "#{ex} Error:#{timestamp}"
+          else
+            "\n(Error:#{timestamp}) #{ex.class} #{exception_context} (#{ex.message}):\n  " + clean_backtrace(ex).join("\n  ") + "\n\n"
+          end
+        )
+      end
+    end
+
+    #
+    # Pull certain fields out of the controller and add to the data hash.
+    #
+    def extract_and_merge_controller_data(controller, data)
+      data[:request] = {
+        :params      => controller.request.parameters.to_hash,
+        :rails_root  => Rails.root,
+        :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
+      }
+    end
+
+    def log_warning( message )
+      log_error( Warning.new(message) )
+    end
+
+    def log_info( message )
+      ExceptionHandling.logger.info( message )
+    end
+
+    def log_debug( message )
+      ExceptionHandling.logger.debug( message )
+    end
+
+    def ensure_safe( exception_context = "" )
+      yield
+    rescue => ex
+      log_error ex, exception_context
+      return nil
+    end
+
+    def ensure_escalation( email_subject )
+      begin
+        yield
+      rescue => ex
+        log_error ex
+        escalate(email_subject, ex, ExceptionHandling.last_exception_timestamp)
+        nil
+      end
+    end
+
+    def set_log_error_timestamp
+      ExceptionHandling.last_exception_timestamp = Time.now.to_i
+    end
+
+    def should_send_email?
+      defined?( EXCEPTION_HANDLING_MAILER_SEND_MAIL ) && EXCEPTION_HANDLING_MAILER_SEND_MAIL
+    end
+
+    def trace_timing(description)
+      result = nil
+      time = Benchmark.measure do
+        result = yield
+      end
+      log_info "#{description} %.4fs  " % time.real
+      result
+    end
+
+    def log_periodically(exception_key, interval, message)
+      self.periodic_exception_intervals ||= {}
+      last_logged = self.periodic_exception_intervals[exception_key]
+      if !last_logged || ( (last_logged + interval) < Time.now )
+        log_error( message )
+        self.periodic_exception_intervals[exception_key] = Time.now
+      end
+    end
+
+    # TODO: fix test to not use this.
+    def enhance_exception_data(data)
+
+    end
+
+    private
+
+    def log_error_email( data, exc )
+      enhance_exception_data( data )
+      normalize_exception_data( data )
+      clean_exception_data( data )
+
+      SECTIONS.each { |section| add_to_s( data[section] ) if data[section].is_a? Hash }
+
+      if exception_filters.filtered?( data )
+        return
+      end
+
+      if summarize_exception( data ) == :Summarized
+        return
+      end
+
+      deliver(ExceptionHandling::Mailer.exception_notification(data))
+
+      if defined?(Errplane)
+        Errplane.transmit(exc, :custom_data => data) unless exc.is_a?(Warning)
+      end
+
+      nil
+    end
+
+    def escalate( email_subject, ex, timestamp )
+      data = exception_to_data( ex, nil, timestamp )
+      deliver(ExceptionHandling::Mailer.escalation_notification(email_subject, data))
+    end
+
+    def deliver(mail_object)
+      if defined?(EVENTMACHINE_EXCEPTION_HANDLING) && EVENTMACHINE_EXCEPTION_HANDLING
+        EventMachine.schedule do # in case we're running outside the reactor
+          async_send_method = EVENTMACHINE_EXCEPTION_HANDLING == :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,
+                :body     => mail_object.body.to_s
+              }
+          )
+          send_deferrable.errback { |err| ExceptionHandling.logger.fatal("Failed to email by SMTP: #{err.inspect}") }
+        end
+      else
+        safe_email_deliver do
+          mail_object.deliver
+        end
+      end
+    end
+
+    def safe_email_deliver
+      Timeout::timeout 30, MailerTimeout do
+        yield
+      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]     = "fake 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_filters
+      @exception_filters ||= ExceptionFilters.new( EXCEPTION_FILTER_LIST_PATH )
+    end
+
+    def clean_backtrace(exception)
+      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
+    end
+
+    def clear_exception_summary
+      @last_exception = nil
+    end
+
+    # Returns :Summarized iff exception has been added to summary and therefore should not be sent.
+    def summarize_exception( data )
+      if @last_exception
+        same_signature = @last_exception[:backtrace] == data[:backtrace]
+
+        case @last_exception[:state]
+
+        when :NotSummarized
+          if same_signature
+            @last_exception[:count] += 1
+            if @last_exception[:count] >= SUMMARY_THRESHOLD
+              @last_exception.merge! :state => :Summarized, :first_seen => Time.now, :count => 0
+            end
+            return nil
+          end
+
+        when :Summarized
+          if same_signature
+            @last_exception[:count] += 1
+            if Time.now - @last_exception[:first_seen] > SUMMARY_PERIOD
+              send_exception_summary(data, @last_exception[:first_seen], @last_exception[:count])
+              @last_exception.merge! :first_seen => Time.now, :count => 0
+            end
+            return :Summarized
+          elsif @last_exception[:count] > 0 # send the left-over, if any
+            send_exception_summary(@last_exception[:data], @last_exception[:first_seen], @last_exception[:count])
+          end
+
+        else
+          raise "Unknown state #{@last_exception[:state]}"
+        end
+      end
+
+      # New signature we haven't seen before.  Not summarized yet--we're just starting the count.
+      @last_exception = {
+        :data       => data,
+        :count      => 1,
+        :first_seen => Time.now,
+        :backtrace  => data[:backtrace],
+        :state      => :NotSummarized
+      }
+      nil
+    end
+
+    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]}: #{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]}: #{exception.message}"
+        data[:session] = exception_context['rack.session']
+        data[:environment] = exception_context
+      else
+        data[:error]       = "#{data[:error_string]}#{': ' + exception_context unless exception_context.blank?}"
+        data[:environment] = { :message => exception_context }
+      end
+      data
+    end
+
+    def make_exception(exception_or_string)
+      if exception_or_string.is_a?(Exception)
+        exception_or_string
+      else
+        begin
+          # raise to capture a backtrace
+          raise StandardError, exception_or_string
+        rescue => ex
+          ex
+        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
+  end
+
+  class ExceptionFilters
+    class Filter
+      def initialize filter_name, regexes
+        @regexes = Hash[ regexes.map do |section, regex|
+          section = section.to_sym
+          raise "Unknown section: #{section}" unless section == :error || section.in?( ExceptionHandling::SECTIONS )
+          [section, (Regexp.new(regex, 'i') unless regex.blank?)]
+        end ]
+
+        raise "Filter #{filter_name} has all blank regexes: #{regexes.inspect}" if @regexes.all? { |section, regex| regex.nil? }
+      end
+
+      def match?(exception_data)
+        @regexes.all? do |section, regex|
+          regex.nil? ||
+            case exception_data[section]
+            when String
+              regex =~ exception_data[section]
+            when Array
+              exception_data[section].any? { |row| row =~ regex }
+            when Hash
+              exception_data[section] && exception_data[section][:to_s] =~ regex
+            when NilClass
+              false
+            else
+              raise "Unexpected class #{exception_data[section].class.name}"
+            end
+        end
+      end
+    end
+
+    def initialize( filter_path )
+      @filter_path = filter_path
+      @filters = { }
+      @filters_last_modified_time = nil
+    end
+
+    def filtered?( exception_data )
+      refresh_filters
+
+      @filters.any? do |name, filter|
+        if ( match = filter.match?( exception_data ) )
+          ExceptionHandling.logger.warn( "Filtered exception using '#{name}'; not sending email to notify" )
+        end
+        match
+      end
+    end
+
+    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}" )
+        @filters_last_modified_time = mtime # make race condition fall on the side of reloading unnecessarily next time rather than missing a set of changes
+
+        @filters = load_file
+      end
+
+    rescue => ex # any exceptions
+      ExceptionHandling::log_error( ex, "ExceptionRegexes::refresh_filters: #{@filter_path}", nil, true)
+    end
+
+    def load_file
+      # store all strings from YAML file into regex's on initial load, instead of converting to regex on every exception that is logged
+      filters = YAML::load_file( @filter_path )
+      Hash[ filters.map do |filter_name, regexes|
+        [filter_name, Filter.new( filter_name, regexes )]
+      end ]
+    end
+
+    def last_modified_time
+      File.mtime( @filter_path )
+    end
+  end
+
+
+public
+
+  module Methods # included on models and controllers
+    protected
+    def log_error(exception_or_string, exception_context = '')
+      controller = self if respond_to?(:request) && respond_to?(:session)
+      ExceptionHandling.log_error(exception_or_string, exception_context, controller)
+    end
+
+    def log_error_rack(exception_or_string, exception_context = '', rack_filter = '')
+      ExceptionHandling.log_error_rack(exception_or_string, exception_context, controller)
+    end
+
+    def log_warning(message)
+      log_error(Warning.new(message))
+    end
+
+    def log_info(message)
+      ExceptionHandling.logger.info( message )
+    end
+
+    def log_debug(message)
+      ExceptionHandling.logger.debug( message )
+    end
+
+    def ensure_safe(exception_context = "")
+      begin
+        yield
+      rescue => ex
+        log_error ex, exception_context
+        nil
+      end
+    end
+
+    def ensure_escalation(*args)
+      ExceptionHandling.ensure_escalation(*args) do
+        yield
+      end
+    end
+
+    # Store aside the current controller when included
+    LONG_REQUEST_SECONDS = (defined?(Rails) && Rails.env == 'test' ? 300 : 30)
+    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?(Rails.env)
+      result
+    ensure
+      ExceptionHandling.current_controller = nil
+    end
+
+    def self.included( controller )
+      controller.around_filter :set_current_controller if controller.respond_to? :around_filter
+    end
+  end
+end