exception_handling 2.2.1 → 2.3.0.pre.1

data/lib/exception_handling/honeybadger_callbacks.rb

@@ -1,41 +1,58 @@
+# frozen_string_literal: true
+
 module ExceptionHandling
   module HoneybadgerCallbacks
-    def self.register_callbacks
-      if ExceptionHandling.honeybadger?
-        Honeybadger.local_variable_filter(&method(:local_variable_filter))
+    class << self
+      def register_callbacks
+        if ExceptionHandling.honeybadger_defined?
+          Honeybadger.local_variable_filter(&method(:local_variable_filter))
+        end
       end
-    end
 
-    private
+      private
 
-    def self.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
+      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
-    end
 
-    def self.contains_filter_key?(filter_keys, string)
-      filter_keys._?.any? { |key| string.include?(key) }
-    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 self.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]>"
+      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

data/lib/exception_handling/log_stub_error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 # Used by functional tests to track exceptions.
 #
@@ -22,7 +24,7 @@ module LogErrorStub
         message = "log_error expected #{match[:expected]} times with pattern: '#{pattern.is_a?(Regexp) ? pattern.source : pattern}' found #{match[:found]}"
 
         if is_mini_test?
-         flunk(message)
+          flunk(message)
         else
           add_failure(message)
         end
@@ -34,8 +36,9 @@ module LogErrorStub
 
   # for overriding when testing this module
   def is_mini_test?
-    defined?(Minitest::Test) && self.is_a?(Minitest::Test)
+    defined?(Minitest::Test) && is_a?(Minitest::Test)
   end
+
   #
   # Call this function in your functional tests - usually first line after a "should" statement
   # once called, you can then call expects_exception
@@ -60,7 +63,7 @@ module LogErrorStub
   # Did the calling code call expects_exception on this exception?
   #
   def exception_filtered?(exception_data)
-    @exception_whitelist && @exception_whitelist.any? do |expectation|
+    @exception_whitelist&.any? do |expectation|
       if expectation[0] === exception_data[:error]
         expectation[1][:found] += 1
         true
@@ -74,8 +77,8 @@ module LogErrorStub
   def expects_exception(pattern, options = {})
     @exception_whitelist ||= []
     expected_count = options[:count] || 1
-    options = {:expected => expected_count, :found => 0}
-    if to_increment = @exception_whitelist.find {|ex| ex[0] == pattern}
+    options = { expected: expected_count, found: 0 }
+    if to_increment = @exception_whitelist.find { |ex| ex[0] == pattern }
       to_increment[1][:expected] += expected_count
     else
       @exception_whitelist << [pattern, options]
@@ -90,10 +93,9 @@ module LogErrorStub
 
   def raise_unexpected_exception(exception_data)
     raise(UnexpectedExceptionLogged,
-          exception_data[:error] + "\n" +
+          exception_data[:error] + "\n" \
           "---original backtrace---\n" +
-          exception_data[:backtrace].join("\n") + "\n" +
+          exception_data[:backtrace].join("\n") + "\n" \
           "------")
   end
-
 end

data/lib/exception_handling/mailer.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'action_mailer'
 
 module ExceptionHandling
   class Mailer < ActionMailer::Base
-    default :content_type => "text/html"
+    default content_type: "text/html"
 
-    self.append_view_path "#{File.dirname(__FILE__)}/../../views"
+    append_view_path "#{File.dirname(__FILE__)}/../../views"
 
     [:email_environment, :server_name, :sender_address, :exception_recipients, :escalation_recipients].each do |method|
       define_method method do
@@ -16,76 +18,53 @@ module ExceptionHandling
       "#{email_environment} exception: "
     end
 
-    def self.reloadable?() false end
-
-    def exception_notification( cleaned_data, first_seen_at = nil, occurrences = 0 )
-      if cleaned_data.is_a?(Hash)
-        cleaned_data.merge!({:occurrences => occurrences, :first_seen_at => first_seen_at}) if first_seen_at
-        cleaned_data.merge!({:server => server_name })
+    class << self
+      def reloadable?
+        false
       end
 
-      subject       = "#{email_prefix}#{"[#{occurrences} SUMMARIZED]" if first_seen_at}#{cleaned_data[:error]}"[0,300]
-      recipients    = exception_recipients
-      from          = sender_address
-      @cleaned_data = cleaned_data
-
-      mail(:from    => from,
-           :to      => recipients,
-           :subject => subject)
-    end
-
-    def escalation_notification( summary, data)
-      subject       = "#{email_environment} Escalation: #{summary}"
-      from          = sender_address.gsub('xception', 'scalation')
-      recipients    = escalation_recipients rescue exception_recipients
-
-      @summary      = summary
-      @server       = ExceptionHandling.server_name
-      @cleaned_data = data
-
-      mail(:from    => from,
-           :to      => recipients,
-           :subject => subject)
+      def mailer_method_category
+        {
+          log_parser_exception_notification: :NetworkOptout
+        }
+      end
     end
 
-    def escalate_custom(summary, data, recipients)
+    def escalation_notification(summary, data, custom_recipients = nil)
       subject       = "#{email_environment} Escalation: #{summary}"
       from          = sender_address.gsub('xception', 'scalation')
-      recipients    = recipients
+      recipients    = begin
+                        custom_recipients || escalation_recipients
+                      rescue
+                        exception_recipients
+                      end
 
       @summary      = summary
       @server       = ExceptionHandling.server_name
       @cleaned_data = data
 
-      mail(:from    => from,
-           :to      => recipients,
-           :subject => subject)
+      mail(from: from,
+           to: recipients,
+           subject: subject)
     end
 
-    def log_parser_exception_notification( cleaned_data, key )
+    def log_parser_exception_notification(cleaned_data, key)
       if cleaned_data.is_a?(Hash)
         cleaned_data = cleaned_data.symbolize_keys
         local_subject = cleaned_data[:error]
       else
         local_subject = "#{key}: #{cleaned_data}"
-        cleaned_data  = { :error => cleaned_data.to_s }
+        cleaned_data  = { error: cleaned_data.to_s }
       end
 
-      @subject       = "#{email_prefix}#{local_subject}"[0,300]
+      @subject       = "#{email_prefix}#{local_subject}"[0, 300]
       @recipients    = exception_recipients
       from           = sender_address
       @cleaned_data  = cleaned_data
 
-      mail(:from    => from,
-           :to      => @recipients,
-           :subject => @subject)
-    end
-
-    def self.mailer_method_category
-      {
-        :exception_notification            => :NetworkOptout,
-        :log_parser_exception_notification => :NetworkOptout
-      }
+      mail(from: from,
+           to: @recipients,
+           subject: @subject)
     end
   end
 end

data/lib/exception_handling/methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/concern'
 
 module ExceptionHandling
@@ -20,20 +22,18 @@ module ExceptionHandling
     end
 
     def log_info(message)
-      ExceptionHandling.logger.info( message )
+      ExceptionHandling.logger.info(message)
     end
 
     def log_debug(message)
-      ExceptionHandling.logger.debug( message )
+      ExceptionHandling.logger.debug(message)
     end
 
     def ensure_safe(exception_context = "")
-      begin
-        yield
-      rescue => ex
-        log_error ex, exception_context
-        nil
-      end
+      yield
+    rescue => ex
+      log_error ex, exception_context
+      nil
     end
 
     def escalate_error(exception_or_string, email_subject)
@@ -74,9 +74,13 @@ module ExceptionHandling
       time = Benchmark.measure do
         result = yield
       end
-      if time.real > self.long_controller_action_timeout && !['development', 'test'].include?(ExceptionHandling.email_environment)
-        name = " in #{controller_name}::#{action_name}" rescue " "
-        log_error( "Long controller action detected#{name} %.4fs  " % time.real )
+      if time.real > long_controller_action_timeout && !['development', 'test'].include?(ExceptionHandling.email_environment)
+        name = begin
+                 " in #{controller_name}::#{action_name}"
+               rescue
+                 " "
+               end
+        log_error("Long controller action detected#{name} %.4fs  " % time.real)
       end
       result
     ensure

data/lib/exception_handling/sensu.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 require "socket"
 
 module ExceptionHandling
   module Sensu
     LEVELS = {
-        warning:  1,
-        critical: 2
-    }
+      warning: 1,
+      critical: 2
+    }.freeze
 
     class << self
       def generate_event(name, message, level = :warning)
         status = LEVELS[level] or raise "Invalid alert level #{level}"
 
-        event = {name: ExceptionHandling.sensu_prefix.to_s + name, output: message, status: status}
+        event = { name: ExceptionHandling.sensu_prefix.to_s + name, output: message, status: status }
 
         send_event(event)
       end
@@ -23,4 +25,4 @@ module ExceptionHandling
       end
     end
   end
-end
+end

data/lib/exception_handling/testing.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 # some useful test objects
 
@@ -7,38 +8,44 @@ module ExceptionHandling
 
       class Request
         attr_accessor :parameters, :protocol, :host, :request_uri, :env, :session_options
+
         def initialize
-          @parameters  = {:id => "1"}
+          @parameters  = { id: "1" }
           @protocol    = 'http'
           @host        = 'localhost'
           @request_uri = "/fun/testing.html?foo=bar"
-          @env         = {:HOST => "local"}
-          @session_options = { :id => '93951506217301' }
+          @env         = { HOST: "local" }
+          @session_options = { id: '93951506217301' }
         end
       end
 
       attr_accessor :request, :session
+
       class << self
         attr_accessor :around_filter_method
+
+        def around_filter(method)
+          ControllerStub.around_filter_method = method
+        end
       end
 
       def initialize
         @request = Request.new
         @session_id = "ZKL95"
         @session =
-            if defined?(Username)
-              {
-                :login_count => 22,
-                :username_id => Username.first.id,
-                :user_id     => User.first.id,
-              }
-            else
-              { }
-            end
+          if defined?(Username)
+            {
+              login_count: 22,
+              username_id: Username.first.id,
+              user_id: User.first.id,
+            }
+          else
+            {}
+          end
       end
 
-      def simulate_around_filter( &block )
-        set_current_controller( &block )
+      def simulate_around_filter(&block)
+        set_current_controller(&block)
       end
 
       def controller_name
@@ -49,10 +56,6 @@ module ExceptionHandling
         "test_action"
       end
 
-      def self.around_filter( method )
-        ControllerStub.around_filter_method = method
-      end
-
       def complete_request_uri
         "#{@request.protocol}#{@request.host}#{@request.request_uri}"
       end
@@ -60,6 +63,5 @@ module ExceptionHandling
       include ExceptionHandling::Methods
       set_long_controller_action_timeout 2
     end
-
   end
 end

data/lib/exception_handling/version.rb

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