exception_handling 3.0.pre.1 → 3.0.0.pre.2

data/gemfiles/rails_5.gemfile

@@ -0,0 +1,16 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activesupport", "~> 5.2"
+gem "appraisal", "~> 2.2"
+gem "honeybadger", "~> 4.11"
+gem "pry"
+gem "pry-byebug"
+gem "rake"
+gem "rspec"
+gem "rspec_junit_formatter"
+gem "rubocop"
+gem "test-unit"
+
+gemspec path: "../"

data/gemfiles/rails_6.gemfile

@@ -0,0 +1,16 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activesupport", "~> 6.0"
+gem "appraisal", "~> 2.2"
+gem "honeybadger", "~> 4.11"
+gem "pry"
+gem "pry-byebug"
+gem "rake"
+gem "rspec"
+gem "rspec_junit_formatter"
+gem "rubocop"
+gem "test-unit"
+
+gemspec path: "../"

data/gemfiles/rails_7.gemfile

@@ -0,0 +1,16 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activesupport", "~> 7.0"
+gem "appraisal", "~> 2.2"
+gem "honeybadger", "~> 4.11"
+gem "pry"
+gem "pry-byebug"
+gem "rake"
+gem "rspec"
+gem "rspec_junit_formatter"
+gem "rubocop"
+gem "test-unit"
+
+gemspec path: "../"

data/lib/exception_handling/escalate_callback.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'escalate'
+
+module ExceptionHandling
+  module EscalateCallback
+    class << self
+      def register_if_configured!
+        register! if ::ExceptionHandling.configured?
+      end
+
+      def register!
+        Escalate.on_escalate(log_first: false) do |exception, location_message, **context|
+          ::ExceptionHandling.log_error(exception, location_message, **context)
+        end
+      end
+    end
+  end
+end

data/lib/exception_handling/exception_info.rb

@@ -3,7 +3,7 @@
 module ExceptionHandling
   class ExceptionInfo
 
-    ENVIRONMENT_WHITELIST = [
+    ENVIRONMENT_ALLOWLIST = [
       /^HTTP_/,
       /^QUERY_/,
       /^REQUEST_/,
@@ -46,16 +46,20 @@ module ExceptionHandling
     EOS
 
     SECTIONS = [:request, :session, :environment, :backtrace, :event_response].freeze
-    HONEYBADGER_CONTEXT_SECTIONS = [:timestamp, :error_class, :exception_context, :server, :scm_revision, :notes, :user_details, :request, :session, :environment, :backtrace, :event_response].freeze
+    HONEYBADGER_CONTEXT_SECTIONS = [:timestamp, :error_class, :exception_context, :server, :scm_revision, :notes,
+                                    :user_details, :request, :session, :environment, :backtrace, :event_response, :log_context].freeze
 
-    attr_reader :exception, :controller, :exception_context, :timestamp
+    attr_reader :exception, :controller, :exception_context, :timestamp, :honeybadger_tags
 
-    def initialize(exception, exception_context, timestamp, controller = nil, data_callback = nil)
+    def initialize(exception, exception_context, timestamp, controller: nil, data_callback: nil, log_context: nil)
       @exception = exception
       @exception_context = exception_context
       @timestamp = timestamp
       @controller = controller || controller_from_context(exception_context)
       @data_callback = data_callback
+      # merge into the surrounding context just like ContextualLogger does when logging
+      @merged_log_context = ExceptionHandling.logger.current_context_for_thread.deep_merge(log_context || {})
+      @honeybadger_tags = Array(@merged_log_context[:honeybadger_tags] || [])
     end
 
     def data
@@ -79,9 +83,10 @@ module ExceptionHandling
     end
 
     def controller_name
-      @controller_name ||= if @controller
-                             @controller.request.parameters.with_indifferent_access[:controller]
-                           end.to_s
+      @controller_name ||= (
+        @merged_log_context[:honeybadger_grouping] ||
+          (@controller && @controller.request.parameters.with_indifferent_access[:controller])
+      ).to_s
     end
 
     private
@@ -176,7 +181,7 @@ module ExceptionHandling
 
     def clean_environment(env)
       Hash[ env.map do |k, v|
-        [k, v] if !"#{k}: #{v}".in?(ENVIRONMENT_OMIT) && ENVIRONMENT_WHITELIST.any? { |regex| k =~ regex }
+        [k, v] if !"#{k}: #{v}".in?(ENVIRONMENT_OMIT) && ENVIRONMENT_ALLOWLIST.any? { |regex| k =~ regex }
       end.compact ]
     end
 
@@ -267,14 +272,13 @@ module ExceptionHandling
       data = enhanced_data.dup
       data[:server] = ExceptionHandling.server_name
       data[:exception_context] = deep_clean_hash(@exception_context) if @exception_context.present?
+      data[:log_context] = @merged_log_context
       unstringify_sections(data)
-      context_data = HONEYBADGER_CONTEXT_SECTIONS.reduce({}) do |context, section|
+      HONEYBADGER_CONTEXT_SECTIONS.each_with_object({}) do |section, context|
         if data[section].present?
           context[section] = data[section]
         end
-        context
       end
-      context_data
     end
   end
 end

data/lib/exception_handling/log_stub_error.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 #
-# Used by functional tests to track exceptions.
+# Test Helper that supports Minitest::Test and Test::Unit
+# Used by tests in the consumers of this gem to track exceptions.
 #
 
 module LogErrorStub

data/lib/exception_handling/logging_methods.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'active_support/core_ext/module/delegation.rb'
+
+module ExceptionHandling
+  module LoggingMethods # included on models and controllers
+    extend ActiveSupport::Concern
+
+    protected
+
+    delegate :log_error_rack, :log_warning, :log_info, :log_debug, :log_error, to: ExceptionHandling
+
+    def ensure_safe(exception_context = "")
+      yield
+    rescue => ex
+      log_error ex, exception_context
+      nil
+    end
+  end
+end

data/lib/exception_handling/testing.rb

@@ -4,7 +4,7 @@
 
 module ExceptionHandling
   module Testing
-    class ControllerStub
+    class ControllerStubBase
 
       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)
-          ControllerStub.around_filter_method = method
+          self.around_filter_method = method
         end
       end
 
@@ -44,14 +44,6 @@ 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
@@ -59,9 +51,14 @@ module ExceptionHandling
       def complete_request_uri
         "#{@request.protocol}#{@request.host}#{@request.request_uri}"
       end
+    end
+
+    class LoggingMethodsControllerStub < ControllerStubBase
+      include ExceptionHandling::LoggingMethods
 
-      include ExceptionHandling::Methods
-      set_long_controller_action_timeout 2
+      def controller_name
+        "LoggingMethodsControllerStub"
+      end
     end
   end
 end

data/lib/exception_handling/version.rb

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

data/lib/exception_handling.rb

@@ -1,26 +1,25 @@
 # frozen_string_literal: true
 
+require 'digest'
 require 'timeout'
 require 'active_support'
-require 'active_support/core_ext/hash'
+require 'active_support/core_ext'
 require 'contextual_logger'
+require 'yaml'
 
 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/honeybadger_callbacks.rb"
+require 'exception_handling/logging_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'
 
 _ = ActiveSupport::HashWithIndifferentAccess
 
 module ExceptionHandling # never included
   class Warning < StandardError; end
-  class MailerTimeout < Timeout::Error; end
   class ClientLoggingError < StandardError; end
 
   SUMMARY_THRESHOLD = 5
@@ -35,19 +34,13 @@ module ExceptionHandling # never included
     # required settings
     #
     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 #{name}.server_name"
     end
 
-    def sender_address
-      @sender_address or raise ArgumentError, "You must assign a value to #{name}.sender_address"
-    end
-
-    def exception_recipients
-      @exception_recipients or raise ArgumentError, "You must assign a value to #{name}.exception_recipients"
+    def configured?
+      !@logger.nil?
     end
 
     def logger
@@ -55,79 +48,38 @@ module ExceptionHandling # never included
     end
 
     def logger=(logger)
-      @logger = logger.is_a?(ContextualLogger) ? logger : ContextualLogger.new(logger)
+      logger.nil? || logger.is_a?(ContextualLogger::LoggerMixin) or raise ArgumentError,
+                                                                          "The logger must be a ContextualLogger::LoggerMixin, not a #{logger.class}"
+      @logger = logger
+      EscalateCallback.register_if_configured!
     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}"
+      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
     end
 
     #
     # optional settings
     #
     attr_accessor :production_support_recipients
-    attr_accessor :escalation_recipients
-    attr_accessor :email_environment
+    attr_accessor :environment
     attr_accessor :custom_data_hook
     attr_accessor :post_log_error_hook
     attr_accessor :stub_handler
-    attr_accessor :sensu_host
-    attr_accessor :sensu_port
-    attr_accessor :sensu_prefix
 
     attr_reader :filter_list_filename
-    attr_reader :eventmachine_safe
-    attr_reader :eventmachine_synchrony
+    attr_reader :honeybadger_auto_tagger
 
     @filter_list_filename = "./config/exception_filters.yml"
-    @email_environment = ""
-    @eventmachine_safe = false
-    @eventmachine_synchrony = false
-    @sensu_host = "127.0.0.1"
-    @sensu_port = 3030
-    @sensu_prefix = ""
-
-    # set this for operation within an eventmachine reactor
-    def eventmachine_safe=(bool)
-      if bool != true && bool != false
-        raise ArgumentError, "#{name}.eventmachine_safe must be a boolean."
-      end
-
-      if bool
-        require 'eventmachine'
-        require 'em/protocols/smtpclient'
-      end
-      @eventmachine_safe = bool
-    end
-
-    # set this for EM::Synchrony async operation
-    def eventmachine_synchrony=(bool)
-      if bool != true && bool != false
-        raise ArgumentError, "#{name}.eventmachine_synchrony must be a boolean."
-      end
-
-      @eventmachine_synchrony = bool
-    end
 
     def filter_list_filename=(filename)
       @filter_list_filename = filename
@@ -138,6 +90,14 @@ module ExceptionHandling # never included
       @exception_catalog ||= ExceptionCatalog.new(@filter_list_filename)
     end
 
+    # rubocop:disable Style/TrivialAccessors
+    # @param value [Proc|nil] Proc that accepts 1 parameter that will be the exception object or nil to disable the auto-tagger.
+    #                         The proc is always expected to return an array of strings. The array can be empty.
+    def honeybadger_auto_tagger=(value)
+      @honeybadger_auto_tagger = value
+    end
+    # rubocop:enable Style/TrivialAccessors
+
     #
     # internal settings (don't set directly)
     #
@@ -177,13 +137,18 @@ 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 = '', treat_like_warning: false, **log_context, &data_callback)
+    def log_error(exception_or_string, exception_context = '', controller = nil, 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, current_controller, data_callback)
+      exception_info = ExceptionInfo.new(ex, exception_context, timestamp,
+                                         controller: controller || current_controller, data_callback: data_callback,
+                                         log_context: log_context)
 
       if stub_handler
         stub_handler.handle_stub_log_error(exception_info.data)
@@ -210,7 +175,13 @@ module ExceptionHandling # never included
     #
     def write_exception_to_log(ex, exception_context, timestamp, log_context = {})
       ActiveSupport::Deprecation.silence do
-        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)
+        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
       end
     end
 
@@ -243,11 +214,16 @@ module ExceptionHandling # never included
     def send_exception_to_honeybadger(exception_info)
       exception             = exception_info.exception
       exception_description = exception_info.exception_description
+
+      # Note: Both commas and spaces are treated as delimiters for the :tags string. Space-delimiters are not officially documented.
+      # https://github.com/honeybadger-io/honeybadger-ruby/pull/422
+      tags = (honeybadger_auto_tags(exception) + exception_info.honeybadger_tags).join(' ')
       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,
-                                    controller:    exception_info.controller_name)
+                                    controller:    exception_info.controller_name,
+                                    tags:          tags)
       response ? :success : :failure
     rescue Exception => ex
       warn("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")}")
@@ -255,6 +231,18 @@ module ExceptionHandling # never included
       :failure
     end
 
+    # @param exception [Exception]
+    #
+    # @return [Array<String>]
+    def honeybadger_auto_tags(exception)
+      @honeybadger_auto_tagger&.call(exception) || []
+    rescue => ex
+      traces = ex.backtrace.join("\n")
+      message = "Unable to execute honeybadger_auto_tags callback. #{ExceptionHandling.encode_utf8(ex.message.to_s)} #{traces}\n"
+      ExceptionHandling.log_info(message)
+      []
+    end
+
     #
     # Check if Honeybadger defined.
     #
@@ -265,38 +253,41 @@ 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)
+          if k == :before_notify
+            config_klass.send(k, v)
+          else
+            config_klass.send(:"#{k}=", v)
+          end
         end
       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
@@ -305,48 +296,6 @@ module ExceptionHandling # never included
       nil
     end
 
-    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 #{name}.production_recipients"
-      ex = make_exception(exception_or_string)
-      escalate(email_subject, ex, last_exception_timestamp, production_support_recipients)
-    end
-
-    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 = {})
-      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 = {})
-      yield
-    rescue => ex
-      escalate_error(ex, email_subject, custom_recipients, log_context)
-      nil
-    end
-
-    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
-        ExceptionHandling::Sensu.generate_event(alert_name, exception_context.to_s + "\n" + encode_utf8(ex.message.to_s))
-      rescue => ex
-        log_error(ex, 'ExceptionHandling.alert_warning')
-      end
-    end
-
-    def ensure_alert(alert_name, exception_context, log_context = {})
-      yield
-    rescue => ex
-      alert_warning(ex, alert_name, exception_context, log_context)
-      nil
-    end
-
     def set_log_error_timestamp
       ExceptionHandling.last_exception_timestamp = Time.now.to_i
     end
@@ -360,7 +309,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)
@@ -409,47 +358,6 @@ module ExceptionHandling # never included
       log_info("Unable to execute custom log_error callback. #{ex_message} #{ex_backtrace}")
     end
 
-    def escalate(email_subject, ex, timestamp, custom_recipients = nil)
-      exception_info = ExceptionInfo.new(ex, nil, timestamp)
-      deliver(ExceptionHandling::Mailer.escalation_notification(email_subject, exception_info.data, custom_recipients))
-    end
-
-    def deliver(mail_object)
-      if ExceptionHandling.eventmachine_safe
-        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
-          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_now
-        end
-      end
-    end
-
-    def safe_email_deliver
-      Timeout.timeout 30, MailerTimeout do
-        yield
-      end
-    rescue StandardError, MailerTimeout => ex
-      log_error(ex, "ExceptionHandling::safe_email_deliver", treat_like_warning: true)
-    end
-
     def make_exception(exception_or_string)
       if exception_or_string.is_a?(Exception)
         exception_or_string
@@ -463,4 +371,6 @@ module ExceptionHandling # never included
       end
     end
   end
+
+  EscalateCallback.register_if_configured!
 end

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

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

data/spec/rake_test_warning_false.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Rake 11+ has a misfeature where @warning = true by default
+# See https://github.com/ruby/rake/pull/97/files
+# This causes all tests to be run with `ruby -w`, causing a huge number of warnings
+# from gems we don't control and overwhelming our test output.
+# This patch reverts that.
+
+_ = Rake::TestTask
+
+class Rake::TestTask
+  module SetWarningFalseMixin
+    def initialize(*args)
+      super
+      self.warning = false
+    end
+  end
+
+  prepend SetWarningFalseMixin
+end