exception_handling 2.17.0.pre.tstarck.1 → 3.0.pre.1

data/lib/exception_handling/exception_info.rb

@@ -3,7 +3,7 @@
 module ExceptionHandling
   class ExceptionInfo
 
-    ENVIRONMENT_ALLOWLIST = [
+    ENVIRONMENT_WHITELIST = [
       /^HTTP_/,
       /^QUERY_/,
       /^REQUEST_/,
@@ -46,20 +46,16 @@ 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, :log_context].freeze
+    HONEYBADGER_CONTEXT_SECTIONS = [:timestamp, :error_class, :exception_context, :server, :scm_revision, :notes, :user_details, :request, :session, :environment, :backtrace, :event_response].freeze
 
-    attr_reader :exception, :controller, :exception_context, :timestamp, :honeybadger_tags
+    attr_reader :exception, :controller, :exception_context, :timestamp
 
-    def initialize(exception, exception_context, timestamp, controller: nil, data_callback: nil, log_context: nil)
+    def initialize(exception, exception_context, timestamp, controller = nil, data_callback = 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
@@ -83,10 +79,9 @@ module ExceptionHandling
     end
 
     def controller_name
-      @controller_name ||= (
-        @merged_log_context[:honeybadger_grouping] ||
-          (@controller && @controller.request.parameters.with_indifferent_access[:controller])
-      ).to_s
+      @controller_name ||= if @controller
+                             @controller.request.parameters.with_indifferent_access[:controller]
+                           end.to_s
     end
 
     private
@@ -181,7 +176,7 @@ module ExceptionHandling
 
     def clean_environment(env)
       Hash[ env.map do |k, v|
-        [k, v] if !"#{k}: #{v}".in?(ENVIRONMENT_OMIT) && ENVIRONMENT_ALLOWLIST.any? { |regex| k =~ regex }
+        [k, v] if !"#{k}: #{v}".in?(ENVIRONMENT_OMIT) && ENVIRONMENT_WHITELIST.any? { |regex| k =~ regex }
       end.compact ]
     end
 
@@ -272,13 +267,14 @@ 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)
-      HONEYBADGER_CONTEXT_SECTIONS.each_with_object({}) do |section, context|
+      context_data = HONEYBADGER_CONTEXT_SECTIONS.reduce({}) do |context, section|
         if data[section].present?
           context[section] = data[section]
         end
+        context
       end
+      context_data
     end
   end
 end

data/lib/exception_handling/honeybadger_callbacks.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module ExceptionHandling
+  module HoneybadgerCallbacks
+    class << self
+      def register_callbacks
+        if ExceptionHandling.honeybadger_defined?
+          Honeybadger.local_variable_filter(&method(:local_variable_filter))
+        end
+      end
+
+      private
+
+      def inspect_object(object, filter_keys)
+        inspection_output = object.inspect
+
+        if contains_filter_key?(filter_keys, inspection_output)
+          filtered_object(object)
+        else
+          inspection_output
+        end
+      rescue => ex
+        details = if object.respond_to?(:to_pk)
+                    " @pk=#{object.to_pk}"
+                  elsif object.respond_to?(:id)
+                    " @id=#{object.id}"
+                  end
+
+        "#<#{object.class.name}#{details} [error '#{ex.class.name}: #{ex.message}' while calling #inspect]>"
+      end
+
+      def local_variable_filter(_symbol, object, filter_keys)
+        case object
+        # Honeybadger will filter these data types for us
+        when String, Hash, Array, Set, Numeric, TrueClass, FalseClass, NilClass
+          object
+        else # handle other Ruby objects, intended for POROs
+          inspect_object(object, filter_keys)
+        end
+      end
+
+      def contains_filter_key?(filter_keys, string)
+        filter_keys._?.any? { |key| string.include?(key) }
+      end
+
+      def filtered_object(object)
+        # make the output look similar to inspect
+        # use [FILTERED], just like honeybadger does
+        if object.respond_to?(:to_pk)
+          "#<#{object.class.name} @pk=#{object.to_pk}, [FILTERED]>"
+        elsif object.respond_to?(:id)
+          "#<#{object.class.name} @id=#{object.id}, [FILTERED]>"
+        else
+          "#<#{object.class.name} [FILTERED]>"
+        end
+      end
+    end
+  end
+end

data/lib/exception_handling/log_stub_error.rb

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

data/lib/exception_handling/methods.rb

@@ -1,15 +1,65 @@
 # frozen_string_literal: true
 
 require 'active_support/concern'
-require_relative 'logging_methods'
 
 module ExceptionHandling
   module Methods # included on models and controllers
     extend ActiveSupport::Concern
-    include ExceptionHandling::LoggingMethods
 
     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, rack_filter)
+    end
+
+    def log_warning(message)
+      ExceptionHandling.log_warning(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
+      nil
+    end
+
+    def escalate_error(exception_or_string, email_subject)
+      ExceptionHandling.escalate_error(exception_or_string, email_subject)
+    end
+
+    def escalate_warning(message, email_subject)
+      ExceptionHandling.escalate_warning(message, email_subject)
+    end
+
+    def ensure_escalation(*args)
+      ExceptionHandling.ensure_escalation(*args) do
+        yield
+      end
+    end
+
+    def alert_warning(*args)
+      ExceptionHandling.alert_warning(*args)
+    end
+
+    def ensure_alert(*args)
+      ExceptionHandling.ensure_alert(*args) do
+        yield
+      end
+    end
+
     def long_controller_action_timeout
       if defined?(Rails) && Rails.respond_to?(:env) && Rails.env == 'test'
         300
@@ -38,10 +88,7 @@ module ExceptionHandling
     end
 
     included do
-      Deprecation3_0.deprecation_warning('ExceptionHandling::Methods', 'include LoggingMethods; in controllers, set your own around_filter to set logging context')
-      if respond_to? :around_filter
-        around_filter :set_current_controller
-      end
+      around_filter :set_current_controller if respond_to? :around_filter
     end
 
     class_methods do

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.17.0.pre.tstarck.1'
+  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,28 +50,15 @@ 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, include_prefix: true)
-      include_prefix and Deprecation3_0.deprecation_warning("the 'expection_handling.' prefix in ExceptionHandling::default_metric_name",
-                                                            "do not rely on metric names including the 'exception_handling.' prefix.")
-
+    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)
@@ -86,7 +70,7 @@ module ExceptionHandling # never included
                       "exception"
                     end
 
-      "#{'exception_handling.' if include_prefix}#{metric_name}"
+      "exception_handling.#{metric_name}"
     end
 
     def default_honeybadger_metric_name(honeybadger_status)
@@ -110,12 +94,10 @@ module ExceptionHandling # never included
     attr_accessor :sensu_host
     attr_accessor :sensu_port
     attr_accessor :sensu_prefix
-    attr_reader   :honeybadger_log_context_tags
 
     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 = ""
@@ -156,30 +138,6 @@ 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
-
-    # @param tag_name [String]
-    # @param path [Array]
-    def add_honeybadger_tag_from_log_context(tag_name, path:)
-      tag_name.is_a?(String) or raise ArgumentError, "tag_name must be a String, #{tag_name.inspect}"
-      path.is_a?(Array) or raise ArgumentError, "path must be an Array, #{path.inspect}"
-      @honeybadger_log_context_tags ||= {}
-      if @honeybadger_log_context_tags.key?(tag_name)
-        log_warning("Overwriting existing tag path for '#{tag_name}' from #{@honeybadger_log_context_tags[tag_name]} to #{path}")
-      end
-      @honeybadger_log_context_tags[tag_name] = path
-    end
-
-    def clear_honeybadger_tags_from_log_context
-      @honeybadger_log_context_tags = nil
-    end
-
     #
     # internal settings (don't set directly)
     #
@@ -219,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)
@@ -257,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
 
@@ -296,16 +243,11 @@ 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 = tags_for_honeybadger(exception_info).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,
-                                    tags:          tags)
+                                    controller:    exception_info.controller_name)
       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")}")
@@ -323,41 +265,38 @@ 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|
-          if k == :before_notify
-            config_klass.send(k, v)
-          else
-            config_klass.send(:"#{k}=", v)
-          end
+          config_klass.send(:"#{k}=", v)
         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
@@ -372,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
@@ -404,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
 
@@ -424,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)
@@ -461,41 +397,6 @@ module ExceptionHandling # never included
 
     private
 
-    # @param exception_info [ExceptionInfo]
-    #
-    # @return [Array<String>]
-    def tags_for_honeybadger(exception_info)
-      (
-        honeybadger_auto_tags(exception_info.exception) +
-        exception_info.honeybadger_tags +
-        honeybadger_tags_from_log_context(exception_info.honeybadger_context_data)
-      ).uniq
-    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
-
-    def honeybadger_tags_from_log_context(honeybadger_context_data)
-      if @honeybadger_log_context_tags
-        @honeybadger_log_context_tags.map do |tag_name, tag_path|
-          if (value_from_log_context = honeybadger_context_data.dig(:log_context, *tag_path))
-            "#{tag_name}:#{value_from_log_context}"
-          end
-        end.compact
-      else
-        []
-      end
-    end
-
     def execute_custom_log_error_callback(exception_data, exception, treat_like_warning, external_notification_results)
       if ExceptionHandling.post_log_error_hook
         honeybadger_status = external_notification_results[:honeybadger_status] || :skipped
@@ -562,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