exception_handling 2.17.0.pre.tstarck.1 → 3.0.0.pre.2

data/lib/exception_handling.rb

@@ -5,12 +5,11 @@ require 'timeout'
 require 'active_support'
 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/logging_methods'
 require 'exception_handling/log_stub_error'
 require 'exception_handling/exception_description'
 require 'exception_handling/exception_catalog'
@@ -21,7 +20,6 @@ _ = ActiveSupport::HashWithIndifferentAccess
 
 module ExceptionHandling # never included
   class Warning < StandardError; end
-  class MailerTimeout < Timeout::Error; end
   class ClientLoggingError < StandardError; end
 
   SUMMARY_THRESHOLD = 5
@@ -30,29 +28,17 @@ 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
 
     #
     # 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"
-    end
-
     def configured?
       !@logger.nil?
     end
@@ -62,90 +48,38 @@ module ExceptionHandling # never included
     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
+      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, 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.")
-
-      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.' if include_prefix}#{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}"
+    def default_metric_name(exception_data, exception, treat_like_warning)
+      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   :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 = ""
-    @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
@@ -164,22 +98,6 @@ module ExceptionHandling # never included
     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)
     #
@@ -299,7 +217,7 @@ module ExceptionHandling # never included
 
       # 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(' ')
+      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,
@@ -313,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.
     #
@@ -366,51 +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
-
-    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)
-      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
@@ -461,41 +346,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
@@ -508,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

data/spec/spec_helper.rb

@@ -5,7 +5,6 @@ require 'rspec/mocks'
 require 'rspec_junit_formatter'
 
 require 'pry'
-require 'pry-byebug'
 require 'honeybadger'
 require 'contextual_logger'
 
@@ -23,28 +22,20 @@ class LoggerStub
     clear
   end
 
-  def debug(message, **log_context)
-    super.tap do
-      logged << { message: message, context: log_context, severity: 'DEBUG' }
-    end
+  def debug(message, log_context = {})
+    logged << { message: message, context: log_context, severity: 'DEBUG' }
   end
 
-  def info(message, **log_context)
-    super.tap do
-      logged << { message: message, context: log_context, severity: 'INFO' }
-    end
+  def info(message, log_context = {})
+    logged << { message: message, context: log_context, severity: 'INFO' }
   end
 
-  def warn(message, **log_context)
-    super.tap do
-      logged << { message: message, context: log_context, severity: 'WARN' }
-    end
+  def warn(message, log_context = {})
+    logged << { message: message, context: log_context, severity: 'WARN' }
   end
 
-  def fatal(message, **log_context)
-    super.tap do
-      logged << { message: message, context: log_context, severity: 'FATAL' }
-    end
+  def fatal(message, log_context = {})
+    logged << { message: message, context: log_context, severity: 'FATAL' }
   end
 
   def clear
@@ -83,16 +74,12 @@ def dont_stub_log_error
   true
 end
 
-ActionMailer::Base.delivery_method = :test
-
-
 module TestHelper
   @constant_overrides = []
   class << self
     attr_accessor :constant_overrides
   end
 
-
   def setup_constant_overrides
     unless TestHelper.constant_overrides.nil? || TestHelper.constant_overrides.empty?
       raise "Uh-oh! constant_overrides left over: #{TestHelper.constant_overrides.inspect}"
@@ -100,19 +87,9 @@ module TestHelper
 
     Time.now_override = nil
 
-    ActionMailer::Base.deliveries.clear
-
-    ExceptionHandling.email_environment     = 'Test'
-    ExceptionHandling.sender_address        = 'server@example.com'
-    ExceptionHandling.exception_recipients  = 'exceptions@example.com'
-    ExceptionHandling.escalation_recipients = 'escalation@example.com'
+    ExceptionHandling.environment           = 'not_test'
     ExceptionHandling.server_name           = 'server'
     ExceptionHandling.filter_list_filename    = "./config/exception_filters.yml"
-    ExceptionHandling.eventmachine_safe       = false
-    ExceptionHandling.eventmachine_synchrony  = false
-    ExceptionHandling.sensu_host              = "127.0.0.1"
-    ExceptionHandling.sensu_port              = 3030
-    ExceptionHandling.sensu_prefix            = ""
   end
 
   def teardown_constant_overrides
@@ -151,16 +128,6 @@ module TestHelper
 
     silence_warnings { final_parent_module.const_set(final_const_name, value) }
   end
-
-  def assert_emails(expected, message = nil)
-    if block_given?
-      original_count = ActionMailer::Base.deliveries.size
-      yield
-    else
-      original_count = 0
-    end
-    expect(ActionMailer::Base.deliveries.size - original_count).to eq(expected), "wrong number of emails#{': ' + message.to_s if message}"
-  end
 end
 
 def assert_equal_with_diff(arg1, arg2, msg = '')

data/spec/unit/exception_handling/escalate_callback_spec.rb

@@ -33,7 +33,7 @@ module ExceptionHandling
       context 'when already configured' do
         before do
           @original_logger = ExceptionHandling.logger
-          ExceptionHandling.logger = ::Logger.new('/dev/null')
+          ExceptionHandling.logger = ::Logger.new('/dev/null').extend(ContextualLogger::LoggerMixin)
         end
 
         after do
@@ -66,7 +66,7 @@ module ExceptionHandling
 
           expect(Escalate.on_escalate_callbacks).to be_empty
 
-          ExceptionHandling.logger = ::Logger.new('/dev/null')
+          ExceptionHandling.logger = ::Logger.new('/dev/null').extend(ContextualLogger::LoggerMixin)
           expect(Escalate.on_escalate_callbacks).to_not be_empty
 
           expect(logger).to_not receive(:error)