exception_handling 2.11.3 → 3.0.pre.1

data/lib/exception_handling/testing.rb

@@ -4,7 +4,7 @@
 
 module ExceptionHandling
   module Testing
-    class ControllerStubBase
+    class ControllerStub
 
       class Request
         attr_accessor :parameters, :protocol, :host, :request_uri, :env, :session_options
@@ -25,7 +25,7 @@ module ExceptionHandling
         attr_accessor :around_filter_method
 
         def around_filter(method)
-          self.around_filter_method = method
+          ControllerStub.around_filter_method = method
         end
       end
 
@@ -44,6 +44,14 @@ module ExceptionHandling
           end
       end
 
+      def simulate_around_filter(&block)
+        set_current_controller(&block)
+      end
+
+      def controller_name
+        "ControllerStub"
+      end
+
       def action_name
         "test_action"
       end
@@ -51,27 +59,9 @@ module ExceptionHandling
       def complete_request_uri
         "#{@request.protocol}#{@request.host}#{@request.request_uri}"
       end
-    end
-
-    class LoggingMethodsControllerStub < ControllerStubBase
-      include ExceptionHandling::LoggingMethods
-
-      def controller_name
-        "LoggingMethodsControllerStub"
-      end
-    end
 
-    class MethodsControllerStub < ControllerStubBase
       include ExceptionHandling::Methods
       set_long_controller_action_timeout 2
-
-      def simulate_around_filter(&block)
-        set_current_controller(&block)
-      end
-
-      def controller_name
-        "MethodsControllerStub"
-      end
     end
   end
 end

data/lib/exception_handling/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ExceptionHandling
-  VERSION = '2.11.3'
+  VERSION = '3.0.pre.1'
 end

data/lib/exception_handling.rb

@@ -1,21 +1,20 @@
 # frozen_string_literal: true
 
-require 'digest'
 require 'timeout'
 require 'active_support'
-require 'active_support/core_ext'
+require 'active_support/core_ext/hash'
 require 'contextual_logger'
 
 require 'invoca/utils'
 
-require 'exception_handling/mailer'
-require 'exception_handling/sensu'
-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/escalate_callback'
+require "exception_handling/mailer"
+require "exception_handling/sensu"
+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
 
@@ -30,8 +29,6 @@ module ExceptionHandling # never included
   AUTHENTICATION_HEADERS = ['HTTP_AUTHORIZATION', 'X-HTTP_AUTHORIZATION', 'X_HTTP_AUTHORIZATION', 'REDIRECT_X_HTTP_AUTHORIZATION'].freeze
   HONEYBADGER_STATUSES   = [:success, :failure, :skipped].freeze
 
-  Deprecation3_0 = ActiveSupport::Deprecation.new('3.0', 'exception_handling')
-
   class << self
 
     #
@@ -53,22 +50,12 @@ module ExceptionHandling # never included
       @exception_recipients or raise ArgumentError, "You must assign a value to #{name}.exception_recipients"
     end
 
-    def configured?
-      !@logger.nil?
-    end
-
     def logger
       @logger or raise ArgumentError, "You must assign a value to #{name}.logger"
     end
 
     def logger=(logger)
-      @logger = if logger.nil? || logger.is_a?(ContextualLogger::LoggerMixin)
-                  logger
-                else
-                  Deprecation3_0.deprecation_warning('implicit extend with ContextualLogger::LoggerMixin', 'extend your logger instance or include into your logger class first')
-                  logger.extend(ContextualLogger::LoggerMixin)
-                end
-      EscalateCallback.register_if_configured!
+      @logger = logger.is_a?(ContextualLogger) ? logger : ContextualLogger.new(logger)
     end
 
     def default_metric_name(exception_data, exception, treat_like_warning)
@@ -190,18 +177,13 @@ module ExceptionHandling # never included
     #   Called directly by our code, usually from rescue blocks.
     #   Writes to log file and may send to honeybadger
     #
-    # TODO: the **log_context means we can never have context named treat_like_warning. In general, keyword args will be conflated with log_context.
-    # Ideally we'd separate to log_context from the other keywords so they don't interfere in any way. Or have no keyword args.
-    #
     # Functional Test Operation:
     #   Calls into handle_stub_log_error and returns. no log file. no honeybadger
     #
-    def log_error(exception_or_string, exception_context = '', controller = nil, treat_like_warning: false, **log_context, &data_callback)
+    def log_error(exception_or_string, exception_context = '', treat_like_warning: false, **log_context, &data_callback)
       ex = make_exception(exception_or_string)
       timestamp = set_log_error_timestamp
-      exception_info = ExceptionInfo.new(ex, exception_context, timestamp,
-                                         controller: controller || current_controller, data_callback: data_callback,
-                                         log_context: log_context)
+      exception_info = ExceptionInfo.new(ex, exception_context, timestamp, current_controller, data_callback)
 
       if stub_handler
         stub_handler.handle_stub_log_error(exception_info.data)
@@ -228,13 +210,7 @@ module ExceptionHandling # never included
     #
     def write_exception_to_log(ex, exception_context, timestamp, log_context = {})
       ActiveSupport::Deprecation.silence do
-        log_message = "#{exception_context}\n#{ex.class}: (#{encode_utf8(ex.message.to_s)}):\n  " + clean_backtrace(ex).join("\n  ") + "\n\n"
-
-        if ex.is_a?(Warning)
-          ExceptionHandling.logger.warn("\nExceptionHandlingWarning (Warning:#{timestamp}) #{log_message}", **log_context)
-        else
-          ExceptionHandling.logger.fatal("\nExceptionHandlingError (Error:#{timestamp}) #{log_message}", **log_context)
-        end
+        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
 
@@ -289,8 +265,9 @@ module ExceptionHandling # never included
     #
     # Expects passed in hash to only include keys which be directly set on the Honeybadger config
     #
-    def enable_honeybadger(**config)
+    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)
@@ -298,28 +275,28 @@ module ExceptionHandling # never included
       end
     end
 
-    def log_warning(message, **log_context)
+    def log_warning(message, log_context = {})
       warning = Warning.new(message)
       warning.set_backtrace([])
       log_error(warning, **log_context)
     end
 
-    def log_info(message, **log_context)
-      ExceptionHandling.logger.info(message, **log_context)
+    def log_info(message, log_context = {})
+      ExceptionHandling.logger.info(message, log_context)
     end
 
-    def log_debug(message, **log_context)
-      ExceptionHandling.logger.debug(message, **log_context)
+    def log_debug(message, log_context = {})
+      ExceptionHandling.logger.debug(message, log_context)
     end
 
-    def ensure_safe(exception_context = "", **log_context)
+    def ensure_safe(exception_context = "", log_context = {})
       yield
     rescue => ex
       log_error(ex, exception_context, **log_context)
       nil
     end
 
-    def ensure_completely_safe(exception_context = "", **log_context)
+    def ensure_completely_safe(exception_context = "", log_context = {})
       yield
     rescue SystemExit, SystemStackError, NoMemoryError, SecurityError, SignalException
       raise
@@ -334,29 +311,26 @@ module ExceptionHandling # never included
       escalate(email_subject, ex, last_exception_timestamp, production_support_recipients)
     end
 
-    def escalate_error(exception_or_string, email_subject, custom_recipients = nil, **log_context)
+    def escalate_error(exception_or_string, email_subject, custom_recipients = nil, log_context = {})
       ex = make_exception(exception_or_string)
       log_error(ex, **log_context)
       escalate(email_subject, ex, last_exception_timestamp, custom_recipients)
     end
 
-    def escalate_warning(message, email_subject, custom_recipients = nil, **log_context)
+    def escalate_warning(message, email_subject, custom_recipients = nil, log_context = {})
       ex = Warning.new(message)
       log_error(ex, **log_context)
       escalate(email_subject, ex, last_exception_timestamp, custom_recipients)
     end
 
-    def ensure_escalation(email_subject, custom_recipients = nil, **log_context)
+    def ensure_escalation(email_subject, custom_recipients = nil, log_context = {})
       yield
     rescue => ex
-      escalate_error(ex, email_subject, custom_recipients, **log_context)
+      escalate_error(ex, email_subject, custom_recipients, log_context)
       nil
     end
 
-    deprecate :escalate_to_production_support, :escalate_error, :escalate_warning, :ensure_escalation,
-      deprecator: ActiveSupport::Deprecation.new('3.0', 'ExceptionHandling')
-
-    def alert_warning(exception_or_string, alert_name, exception_context, **log_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_context)
       begin
@@ -366,10 +340,10 @@ module ExceptionHandling # never included
       end
     end
 
-    def ensure_alert(alert_name, exception_context, **log_context)
+    def ensure_alert(alert_name, exception_context, log_context = {})
       yield
     rescue => ex
-      alert_warning(ex, alert_name, exception_context, **log_context)
+      alert_warning(ex, alert_name, exception_context, log_context)
       nil
     end
 
@@ -386,7 +360,7 @@ module ExceptionHandling # never included
       result
     end
 
-    def log_periodically(exception_key, interval, message, **log_context)
+    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)
@@ -489,6 +463,4 @@ module ExceptionHandling # never included
       end
     end
   end
-
-  EscalateCallback.register_if_configured!
 end

data/semaphore_ci/setup.sh

@@ -0,0 +1,3 @@
+#!/bin/sh -x
+
+bundle install --path vendor/bundle

data/{spec → test}/helpers/exception_helpers.rb

@@ -7,7 +7,7 @@ module ExceptionHelpers
 
   def exception_with_nil_message
     exception_with_nil_message = RuntimeError.new(nil)
-    allow(exception_with_nil_message).to receive(:message).and_return(nil)
+    stub(exception_with_nil_message).message { nil }
     exception_with_nil_message
   end
 
@@ -15,6 +15,6 @@ module ExceptionHelpers
 
   def capture_notifications
     @sent_notifications = []
-    allow(ExceptionHandling).to receive(:send_exception_to_honeybadger).with(any_args) { |exception_info| @sent_notifications << exception_info }
+    stub(ExceptionHandling).send_exception_to_honeybadger(anything) { |exception_info| @sent_notifications << exception_info }
   end
 end

data/{spec/spec_helper.rb → test/test_helper.rb}

@@ -1,9 +1,15 @@
 # frozen_string_literal: true
 
-require 'rspec'
-require 'rspec/mocks'
-require 'rspec_junit_formatter'
-
+require 'active_support'
+require 'active_support/time'
+require 'active_support/test_case'
+require 'active_model'
+require 'action_mailer'
+require 'action_dispatch'
+require 'hobo_support'
+require 'shoulda'
+require 'rr'
+require 'minitest/autorun'
 require 'pry'
 require 'honeybadger'
 require 'contextual_logger'
@@ -11,31 +17,26 @@ require 'contextual_logger'
 require 'exception_handling'
 require 'exception_handling/testing'
 
+ActiveSupport::TestCase.test_order = :sorted
+
 class LoggerStub
-  include ContextualLogger::LoggerMixin
-  attr_accessor :logged, :level
+  include ContextualLogger
+  attr_accessor :logged
 
   def initialize
-    @level = Logger::Severity::DEBUG
-    @progname = nil
-    @logdev = nil
     clear
   end
 
-  def debug(message, log_context = {})
-    logged << { message: message, context: log_context, severity: 'DEBUG' }
-  end
-
   def info(message, log_context = {})
-    logged << { message: message, context: log_context, severity: 'INFO' }
+    logged << { message: message, context: log_context }
   end
 
   def warn(message, log_context = {})
-    logged << { message: message, context: log_context, severity: 'WARN' }
+    logged << { message: message, context: log_context }
   end
 
   def fatal(message, log_context = {})
-    logged << { message: message, context: log_context, severity: 'FATAL' }
+    logged << { message: message, context: log_context }
   end
 
   def clear
@@ -76,17 +77,27 @@ end
 
 ActionMailer::Base.delivery_method = :test
 
+_ = ActiveSupport
+_ = ActiveSupport::TestCase
 
-module TestHelper
-  @constant_overrides = []
-  class << self
-    attr_accessor :constant_overrides
-  end
+class ActiveSupport::TestCase
+  @@constant_overrides = []
+
+  setup do
+    unless @@constant_overrides.nil? || @@constant_overrides.empty?
+      raise "Uh-oh! constant_overrides left over: #{@@constant_overrides.inspect}"
+    end
 
+    unless defined?(Rails) && defined?(Rails.env)
+      module ::Rails
+        class << self
+          attr_writer :env
 
-  def setup_constant_overrides
-    unless TestHelper.constant_overrides.nil? || TestHelper.constant_overrides.empty?
-      raise "Uh-oh! constant_overrides left over: #{TestHelper.constant_overrides.inspect}"
+          def env
+            @env ||= 'test'
+          end
+        end
+      end
     end
 
     Time.now_override = nil
@@ -106,8 +117,8 @@ module TestHelper
     ExceptionHandling.sensu_prefix            = ""
   end
 
-  def teardown_constant_overrides
-    TestHelper.constant_overrides&.reverse&.each do |parent_module, k, v|
+  teardown do
+    @@constant_overrides&.reverse&.each do |parent_module, k, v|
       ExceptionHandling.ensure_safe "constant cleanup #{k.inspect}, #{parent_module}(#{parent_module.class})::#{v.inspect}(#{v.class})" do
         silence_warnings do
           if v == :never_defined
@@ -118,7 +129,7 @@ module TestHelper
         end
       end
     end
-    TestHelper.constant_overrides = []
+    @@constant_overrides = []
   end
 
   def set_test_const(const_name, value)
@@ -138,7 +149,7 @@ module TestHelper
         end
       end
 
-    TestHelper.constant_overrides << [final_parent_module, final_const_name, original_value]
+    @@constant_overrides << [final_parent_module, final_const_name, original_value]
 
     silence_warnings { final_parent_module.const_set(final_const_name, value) }
   end
@@ -150,15 +161,15 @@ module TestHelper
     else
       original_count = 0
     end
-    expect(ActionMailer::Base.deliveries.size - original_count).to eq(expected), "wrong number of emails#{': ' + message.to_s if message}"
+    assert_equal expected, ActionMailer::Base.deliveries.size - original_count, "wrong number of emails#{': ' + message.to_s if message}"
   end
 end
 
 def assert_equal_with_diff(arg1, arg2, msg = '')
   if arg1 == arg2
-    expect(true).to be_truthy # To keep the assertion count accurate
+    assert true # To keep the assertion count accurate
   else
-    expect(arg1).to eq(arg2), "#{msg}\n#{Diff.compare(arg1, arg2)}"
+    assert_equal arg1, arg2, "#{msg}\n#{Diff.compare(arg1, arg2)}"
   end
 end
 
@@ -189,35 +200,3 @@ class Time
     end
   end
 end
-
-RSpec.configure do |config|
-  config.add_formatter(RspecJunitFormatter, 'spec/reports/rspec.xml')
-  config.include TestHelper
-
-  config.before(:each) do
-    setup_constant_overrides
-    unless defined?(Rails) && defined?(Rails.env)
-      module Rails
-        class << self
-          attr_writer :env
-
-          def env
-            @env ||= 'test'
-          end
-        end
-      end
-    end
-  end
-
-  config.after(:each) do
-    teardown_constant_overrides
-  end
-
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
-
-  config.expect_with(:rspec, :test_unit)
-
-  RSpec::Support::ObjectFormatter.default_instance.max_formatted_output_length = 2_000
-end

data/test/unit/exception_handling/exception_catalog_test.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require File.expand_path('../../test_helper',  __dir__)
+
+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
+
+      should "write errors loading the yaml file directly to the log file" do
+        @exception_catalog = ExceptionCatalog.new(ExceptionHandling.filter_list_filename)
+
+        mock(ExceptionHandling).log_error.never
+        mock(ExceptionHandling).write_exception_to_log(anything, "ExceptionCatalog#refresh_filters: ./config/exception_filters.yml", anything)
+        mock(@exception_catalog).load_file { raise "noooooo" }
+
+        @exception_catalog.find({})
+      end
+    end
+
+    context "with live yaml content" do
+      setup do
+        @filename = File.expand_path('../../../config/exception_filters.yml',  __dir__)
+        @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
+
+    context "with no yaml content" do
+      setup do
+        @exception_catalog = ExceptionCatalog.new(nil)
+      end
+
+      should "not load filter data" do
+        mock(ExceptionHandling).write_exception_to_log.with_any_args.never
+        @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,82 @@
+# frozen_string_literal: true
+
+require File.expand_path('../../test_helper',  __dir__)
+
+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 "allow wildcards to cross line boundries" do
+        @f = ExceptionDescription.new(:filter1, error: "my error message.*with multiple lines")
+        assert @f.match?(error: "my error message\nwith more than one, with multiple lines")
+      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_to_honeybadger to be specified and have it disabled by default" do
+        assert !ExceptionDescription.new(:filter1, error: "my error message", send_to_honeybadger: false).send_to_honeybadger
+        assert ExceptionDescription.new(:filter1, error: "my error message", send_to_honeybadger: true).send_to_honeybadger
+        assert !ExceptionDescription.new(:filter1, error: "my error message").send_to_honeybadger
+      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_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_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_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
+
+      should "match multiple email addresses" do
+        mobi = "ExceptionHandling::Warning: LoginAttempt::IPAddressLocked: failed login for 'mcc@mobistreak.com'"
+        credit = "ExceptionHandling::Warning: LoginAttempt::IPAddressLocked: failed login for 'damon@thecreditpros.com'"
+
+        exception_description = ExceptionDescription.new(:filter1, error: "ExceptionHandling::Warning: LoginAttempt::IPAddressLocked: failed login for '(mcc\@mobistreak|damon\@thecreditpros).com'")
+        assert exception_description.match?(error: mobi), "does not match mobi"
+        assert exception_description.match?(error: credit), "does not match credit"
+      end
+    end
+  end
+end