exception_handling 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 455910720fe5a8b91de548665df5c639c97dcf22
-  data.tar.gz: 866669be2cb461553af17b502307e19a1af3b880
+  metadata.gz: 07258fd3838c1f4ad88afcc407b5a48c515cc1bb
+  data.tar.gz: 6bc4a796d301b5739a71b6436a9a3c348f03f2f3
 SHA512:
-  metadata.gz: c9d3e9e02a983357bbec9211b096a6904447b1669ef12db296b1d9a277394b7d713e9fab8fa0fa9f21e4603c18e16a1b71b20fce64b7cf4335ba46fd0e7e19fe
-  data.tar.gz: e0cc1d06e1aa28ffe22b9add5ef2c0ce4dd48fa9fa7d9894460cd50a756b4661c48a3a1ab2a6bd09a9c118250e87f8cbfc9f72dd1b98ff7e01b8a226acbdfc7c
+  metadata.gz: 866f948f04a3ac4c2abf81d221c148a6c236692242dbc318743344dc4f8bc5fb14b39ece122895438ba4c7e48305baef130a489c1b5d712399822b9ff5bad448
+  data.tar.gz: 82e94f9f3eb8030a852a93f341cc7b7694070267edc3773fa74aa3e7e3ac66fbe145a5be242816b20202912016836ebfef6898ea31433b02295920c6e2c35f90

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    exception_handling (1.0.3)
+    exception_handling (1.0.4)
       actionmailer (~> 3.2)
       actionpack (~> 3.2)
       activesupport (~> 3.2)

data/config/exception_filters.yml

@@ -1,4 +1,9 @@
 --- !map:HashWithIndifferentAccess
+Test BS:
+  error: "Some BS"
+  send_email: true
+  notes: "this is used by a test"
+
 All script kiddies:
   error: "ScriptKiddie suspected because of HTTP request without a referer"
 

data/lib/exception_handling/exception_catalog.rb

@@ -0,0 +1,40 @@
+module ExceptionHandling
+  class ExceptionCatalog
+
+    def initialize(filter_path)
+      @filter_path = filter_path
+      @filters = { }
+      @filters_last_modified_time = nil
+    end
+
+    def find(exception_data)
+      refresh_filters
+      @filters.values.find { |filter|  filter.match?(exception_data) }
+    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}")
+        load_file
+      end
+
+    rescue => ex # any exceptions
+      ExceptionHandling::log_error(ex, "ExceptionRegexes::refresh_filters: #{@filter_path}", nil, true)
+    end
+
+    def load_file
+      @filters_last_modified_time = last_modified_time # make race condition fall on the side of reloading unnecessarily next time rather than missing a set of changes
+
+      filters = YAML::load_file(@filter_path)
+      filter_hash_values = filters.map { |filter_name, regexes|  [filter_name.to_sym, ExceptionDescription.new(filter_name.to_sym, regexes.symbolize_keys)] }
+      @filters = Hash[ filter_hash_values ]
+    end
+
+    def last_modified_time
+      File.mtime(@filter_path)
+    end
+  end
+end

data/lib/exception_handling/exception_description.rb

@@ -0,0 +1,58 @@
+module ExceptionHandling
+  class ExceptionDescription
+    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
+    }
+
+    attr_reader :filter_name, :send_email, :send_metric, :metric_name, :notes
+
+    def initialize(filter_name, configuration)
+      @filter_name = filter_name
+
+      invalid_sections = configuration.except(*(CONFIGURATION_SECTIONS.keys + MATCH_SECTIONS))
+      invalid_sections.empty? or raise ArgumentError, "Unknown section: #{invalid_sections.keys.join(",")}"
+
+      @configuration = CONFIGURATION_SECTIONS.merge(configuration)
+      @send_email  = @configuration[:send_email]
+      @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.empty? or raise ArgumentError, "Filter #{filter_name} has all blank regexes: #{configuration.inspect}"
+    end
+
+    def exception_data
+      {
+          "send_metric" => send_metric,
+          "metric_name" => metric_name,
+          "notes"       => notes
+      }
+    end
+
+    def match?(exception_data)
+      @regexes.all? do |section, regex|
+          case target = exception_data[section.to_s] || exception_data[section]
+          when String
+            regex =~ target
+          when Array
+            target.any? { |row| row =~ regex }
+          when Hash
+            target[:to_s] =~ regex
+          when NilClass
+            false
+          else
+            raise "Unexpected class #{exception_data[section].class.name}"
+          end
+      end
+    end
+  end
+end

data/lib/exception_handling/version.rb

@@ -1,3 +1,3 @@
 module ExceptionHandling
-  VERSION = "1.0.3"
+  VERSION = "1.0.4"
 end

data/lib/exception_handling.rb

@@ -7,6 +7,8 @@ require 'invoca/utils'
 require "exception_handling/mailer"
 require "exception_handling/methods"
 require "exception_handling/log_stub_error"
+require "exception_handling/exception_description"
+require "exception_handling/exception_catalog"
 
 _ = ActiveSupport::HashWithIndifferentAccess
 
@@ -351,22 +353,18 @@ EOF
 
       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
+      exception_description = exception_catalog.find( data )
+      merged_data = exception_description ? ActiveSupport::HashWithIndifferentAccess.new(exception_description.exception_data.merge(data)) : data
 
-      deliver(ExceptionHandling::Mailer.exception_notification(data))
-
-      if defined?(Errplane)
-        Errplane.transmit(exc, :custom_data => data) unless exc.is_a?(Warning)
+      if exception_description && !exception_description.send_email
+        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))
+        end
       end
 
-      execute_custom_log_error_callback(data, exc)
-
+      execute_custom_log_error_callback(merged_data, exc)
       nil
     end
 
@@ -470,8 +468,8 @@ EOF
       end.compact ]
     end
 
-    def exception_filters
-      @exception_filters ||= ExceptionFilters.new( ExceptionHandling.filter_list_filename )
+    def exception_catalog
+      @exception_catalog ||= ExceptionCatalog.new( ExceptionHandling.filter_list_filename )
     end
 
     def clean_backtrace(exception)
@@ -594,81 +592,4 @@ EOF
       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.to_s]
-            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
 end

data/test/unit/exception_handling/exception_catalog_test.rb

@@ -0,0 +1,65 @@
+require File.expand_path('../../../test_helper',  __FILE__)
+
+module ExceptionHandling
+  class ExceptionCatalogTest < ActiveSupport::TestCase
+
+    context "With stubbed yaml content" do
+      setup do
+        filter_list = { :exception1 => { error: "my error message" },
+                        :exception2 => { error: "some other message", session: "misc data" } }
+        stub(YAML).load_file { filter_list }
+
+        # bump modified time up to get the above filter loaded
+        stub(File).mtime { incrementing_mtime }
+      end
+
+      context "with loaded data" do
+        setup do
+          stub(File).mtime { incrementing_mtime }
+          @exception_catalog = ExceptionCatalog.new( ExceptionHandling.filter_list_filename )
+          @exception_catalog.send :load_file
+        end
+
+        should "have loaded filters" do
+          assert_equal 2, @exception_catalog.instance_eval("@filters").size
+        end
+
+        should "find messages in the catalog" do
+          assert !@exception_catalog.find( error: "Scott says unlikely to ever match" )
+        end
+
+        should "find matching data" do
+          exception_description = @exception_catalog.find(error: "this is my error message, which should match something")
+          assert exception_description
+          assert_equal :exception1, exception_description.filter_name
+        end
+      end
+
+    end
+
+    context "with live yaml content" do
+      setup do
+        @filename = File.expand_path('../../../../config/exception_filters.yml',  __FILE__)
+        @exception_catalog = ExceptionCatalog.new( @filename )
+        assert_nothing_raised "Loading the exception filter should not raise" do
+          @exception_catalog.send :load_file
+        end
+      end
+
+      should "load the filter data" do
+        assert !@exception_catalog.find( error: "Scott says unlikely to ever match" )
+        assert !@exception_catalog.find( error: "Scott says unlikely to ever match" )
+      end
+
+
+    end
+
+    private
+
+    def incrementing_mtime
+      @mtime ||= Time.now
+      @mtime += 1.day
+    end
+
+  end
+end

data/test/unit/exception_handling/exception_description_test.rb

@@ -0,0 +1,71 @@
+require File.expand_path('../../../test_helper',  __FILE__)
+
+module ExceptionHandling
+  class ExceptionDescriptionTest < ActiveSupport::TestCase
+
+    context "Filter" do
+
+      should "allow direct matching of strings" do
+        @f = ExceptionDescription.new(:filter1, :error => "my error message" )
+        assert @f.match?( 'error' => "my error message")
+      end
+
+      should "allow direct matching of strings on with symbol keys" do
+        @f = ExceptionDescription.new(:filter1, :error => "my error message" )
+        assert @f.match?( :error => "my error message")
+      end
+
+      should "complain when no regexps have a value" do
+        assert_raise(ArgumentError, "has all blank regexe") { ExceptionDescription.new(:filter1, error: nil) }
+      end
+
+      should "report when an invalid key is passed" do
+        assert_raise(ArgumentError, "Unknown section: not_a_parameter") { ExceptionDescription.new(:filter1, error: "my error message", not_a_parameter: false) }
+      end
+
+      should "allow send email to be specified" do
+        assert !ExceptionDescription.new(:filter1, error: "my error message", send_email: false ).send_email
+        assert ExceptionDescription.new(:filter1, error: "my error message", send_email: true ).send_email
+        assert !ExceptionDescription.new(:filter1, error: "my error message" ).send_email
+      end
+
+      should "allow send_metric to be configured" do
+        assert !ExceptionDescription.new(:filter1, error: "my error message", send_metric: false ).send_metric
+        assert ExceptionDescription.new(:filter1, error: "my error message", send_email: true ).send_metric
+        assert ExceptionDescription.new(:filter1, error: "my error message" ).send_metric
+      end
+
+      should "provide metric name" do
+        assert_equal "filter1", ExceptionDescription.new(:filter1, error: "my error message" ).metric_name
+        assert_equal "some_other_metric_name", ExceptionDescription.new(:filter1, error: "my error message", metric_name: :some_other_metric_name ).metric_name
+      end
+
+      should "replace spaces in metric name" do
+        @f = ExceptionDescription.new(:"filter has spaces", :error => "my error message" )
+        assert_equal "filter_has_spaces", @f.metric_name
+      end
+
+      should "allow notes to be recorded" do
+        assert_equal nil, ExceptionDescription.new(:filter1, error: "my error message" ).notes
+        assert_equal "a long string", ExceptionDescription.new(:filter1, error: "my error message", notes: "a long string" ).notes
+      end
+
+      should "not consider config options in the filter set" do
+        assert ExceptionDescription.new(:filter1, error: "my error message", send_email: false ).match?( :error => "my error message")
+        assert ExceptionDescription.new(:filter1, error: "my error message", send_metric: false ).match?( :error => "my error message")
+        assert ExceptionDescription.new(:filter1, error: "my error message", metric_name: "false" ).match?( :error => "my error message")
+        assert ExceptionDescription.new(:filter1, error: "my error message", notes: "hey" ).match?( :error => "my error message")
+      end
+
+      should "provide exception details" do
+        exception_description = ExceptionDescription.new(:filter1, error: "my error message", notes: "hey" )
+
+        expected = {"send_metric" => true, "metric_name" => "filter1", "notes" => "hey"}
+
+        assert_equal expected, exception_description.exception_data
+      end
+
+    end
+
+  end
+end

data/test/unit/exception_handling_test.rb

@@ -48,7 +48,7 @@ class ExceptionHandlingTest < ActiveSupport::TestCase
   end
 
   context "configuration" do
-    def append_organization_info(data)
+    def append_organization_info_config(data)
       begin
         data[:user_details]                = {}
         data[:user_details][:username]     = "CaryP"
@@ -58,7 +58,8 @@ class ExceptionHandlingTest < ActiveSupport::TestCase
       end
     end
 
-    def log_error_callback(data, ex)
+    def log_error_callback_config(data, ex)
+      @callback_data = data
       @fail_count += 1
     end
 
@@ -71,17 +72,23 @@ class ExceptionHandlingTest < ActiveSupport::TestCase
     end
 
     should "support a custom_data_hook" do
-      ExceptionHandling.custom_data_hook = method(:append_organization_info)
+      ExceptionHandling.custom_data_hook = method(:append_organization_info_config)
       ExceptionHandling.ensure_safe("mooo") { raise "Some BS" }
       assert_match(/Invoca Engineering Dept./, ActionMailer::Base.deliveries[-1].body.to_s)
       ExceptionHandling.custom_data_hook = nil
     end
 
-    should "support a log_error hook" do
-      ExceptionHandling.post_log_error_hook = method(:log_error_callback)
-      ExceptionHandling.ensure_safe("mooo") { raise "Some BS" }
-      assert_equal 1, @fail_count
-      ExceptionHandling.post_log_error_hook = nil
+    should "support a log_error hook and pass exception data to it" do
+      begin
+        ExceptionHandling.post_log_error_hook = method(:log_error_callback_config)
+        ExceptionHandling.ensure_safe("mooo") { raise "Some BS" }
+        assert_equal 1, @fail_count
+      ensure
+        ExceptionHandling.post_log_error_hook = nil
+      end
+
+      assert_equal "this is used by a test", @callback_data["notes"]
+      assert_match(/this is used by a test/, ActionMailer::Base.deliveries[-1].body.to_s)
     end
 
     should "support rescue exceptions from a log_error hook" do
@@ -90,6 +97,7 @@ class ExceptionHandlingTest < ActiveSupport::TestCase
       assert_equal 0, @fail_count
       ExceptionHandling.post_log_error_hook = nil
     end
+
   end
 
   context "Exception Handling" do
@@ -98,18 +106,6 @@ class ExceptionHandlingTest < ActiveSupport::TestCase
       ExceptionHandling.send(:clear_exception_summary)
     end
 
-    context "exception filter parsing and loading" do
-      should "happen without an error" do
-        stub(File).mtime { incrementing_mtime }
-        exception_filters = ExceptionHandling.send( :exception_filters )
-        assert( exception_filters.is_a?( ExceptionHandling::ExceptionFilters ) )
-        assert_nothing_raised "Loading the exception filter should not raise" do
-          exception_filters.send :load_file
-        end
-        assert !exception_filters.filtered?( "Scott says unlikely to ever match" )
-      end
-    end
-
     context "ExceptionHandling.ensure_safe" do
       should "log an exception if an exception is raised." do
         mock(ExceptionHandling.logger).fatal(/\(blah\):\n.*exception_handling_test\.rb/)
@@ -232,6 +228,11 @@ class ExceptionHandlingTest < ActiveSupport::TestCase
         Time.now_override = Time.parse( '1986-5-21 4:17 am UTC' )
       end
 
+      def log_error_callback(data, ex)
+        @fail_count += 1
+      end
+
+
       should "include the timestamp when the exception is logged" do
         mock(ExceptionHandling.logger).fatal(/\(Error:517033020\) ArgumentError mooo \(blah\):\n.*exception_handling_test\.rb/)
         b = ExceptionHandling.ensure_safe("mooo") { raise ArgumentError.new("blah") }
@@ -252,12 +253,15 @@ class ExceptionHandlingTest < ActiveSupport::TestCase
       assert_match(/Exception 2/, ActionMailer::Base.deliveries[-1].subject)
     end
 
-    should "only send 5 of a repeated error" do
+    should "only send 5 of a repeated error, but call post hook for every exception" do
+      @fail_count = 0
+      ExceptionHandling.post_log_error_hook = method(:log_error_callback)
       assert_emails 5 do
         10.times do
           ExceptionHandling.log_error(exception_1)
         end
       end
+      assert_equal 10, @fail_count
     end
 
     should "only send 5 of a repeated error but don't send summary if 6th is different" do
@@ -671,25 +675,6 @@ class ExceptionHandlingTest < ActiveSupport::TestCase
     end
   end
 
-  context "Errplane" do
-    module ErrplaneStub
-    end
-
-    setup do
-      set_test_const('Errplane', ErrplaneStub)
-    end
-
-    should "forward exceptions" do
-      mock(Errplane).transmit(exception_1, anything)
-      ExceptionHandling.log_error(exception_1, "context")
-    end
-
-    should "not forward warnings" do
-      stub(Errplane).transmit.times(0)
-      ExceptionHandling.log_warning("warning message")
-    end
-  end
-
   private
 
   def incrementing_mtime

data/views/exception_handling/mailer/exception_notification.html.erb

@@ -27,6 +27,14 @@
     <br />
     <br />
 
+    <% if @cleaned_data[:notes] %>
+      <b>Exception Notes:</b> (from config/exception.yml)<br />
+        <%= @cleaned_data[:notes].gsub("\n","<br/>\n").gsub(/ {2,}/) { |spaces| '&nbsp;'*spaces.size }.html_safe %>
+      <br />
+      <br />
+    <% end %>
+
+
     <b>User summary:</b><br />
     <% if (user_details = @cleaned_data[:user_details]) && ( user_details[:user] || user_details[:organization] ) %>
       User: <%= user_details[:user] %> (<%= user_details[:username] %>)<br />

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: exception_handling
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Colin Kelley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-28 00:00:00.000000000 Z
+date: 2014-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
@@ -167,12 +167,16 @@ files:
 - config/exception_filters.yml
 - exception_handling.gemspec
 - lib/exception_handling.rb
+- lib/exception_handling/exception_catalog.rb
+- lib/exception_handling/exception_description.rb
 - lib/exception_handling/log_stub_error.rb
 - lib/exception_handling/mailer.rb
 - lib/exception_handling/methods.rb
 - lib/exception_handling/testing.rb
 - lib/exception_handling/version.rb
 - test/test_helper.rb
+- test/unit/exception_handling/exception_catalog_test.rb
+- test/unit/exception_handling/exception_description_test.rb
 - test/unit/exception_handling/log_error_stub_test.rb
 - test/unit/exception_handling/mailer_test.rb
 - test/unit/exception_handling/methods_test.rb
@@ -206,6 +210,8 @@ summary: Invoca's exception handling logger/emailer layer, based on exception_no
   Works with Rails or EventMachine or EventMachine+Synchrony.
 test_files:
 - test/test_helper.rb
+- test/unit/exception_handling/exception_catalog_test.rb
+- test/unit/exception_handling/exception_description_test.rb
 - test/unit/exception_handling/log_error_stub_test.rb
 - test/unit/exception_handling/mailer_test.rb
 - test/unit/exception_handling/methods_test.rb