exception_notification 4.3.0 → 4.4.0

data/lib/exception_notifier/modules/backtrace_cleaner.rb

@@ -1,6 +1,5 @@
 module ExceptionNotifier
   module BacktraceCleaner
-
     def clean_backtrace(exception)
       if defined?(Rails) && Rails.respond_to?(:backtrace_cleaner)
         Rails.backtrace_cleaner.send(:filter, exception.backtrace)
@@ -8,6 +7,5 @@ module ExceptionNotifier
         exception.backtrace
       end
     end
-
   end
 end

data/lib/exception_notifier/modules/error_grouping.rb

@@ -27,7 +27,7 @@ module ExceptionNotifier
       def error_count(error_key)
         count = begin
           error_grouping_cache.read(error_key)
-        rescue => e
+        rescue StandardError => e
           ExceptionNotifier.logger.warn("#{error_grouping_cache.inspect} failed to read, reason: #{e.message}. Falling back to memory cache store.")
           fallback_cache_store.read(error_key)
         end
@@ -37,7 +37,7 @@ module ExceptionNotifier
 
       def save_error_count(error_key, count)
         error_grouping_cache.write(error_key, count, expires_in: error_grouping_period)
-      rescue => e
+      rescue StandardError => e
         ExceptionNotifier.logger.warn("#{error_grouping_cache.inspect} failed to write, reason: #{e.message}. Falling back to memory cache store.")
         fallback_cache_store.write(error_key, count, expires_in: error_grouping_period)
       end
@@ -46,13 +46,13 @@ module ExceptionNotifier
         message_based_key = "exception:#{Zlib.crc32("#{exception.class.name}\nmessage:#{exception.message}")}"
         accumulated_errors_count = 1
 
-        if count = error_count(message_based_key)
+        if (count = error_count(message_based_key))
           accumulated_errors_count = count + 1
           save_error_count(message_based_key, accumulated_errors_count)
         else
           backtrace_based_key = "exception:#{Zlib.crc32("#{exception.class.name}\npath:#{exception.backtrace.try(:first)}")}"
 
-          if count = error_grouping_cache.read(backtrace_based_key)
+          if (count = error_grouping_cache.read(backtrace_based_key))
             accumulated_errors_count = count + 1
             save_error_count(backtrace_based_key, accumulated_errors_count)
           else
@@ -74,4 +74,4 @@ module ExceptionNotifier
       end
     end
   end
-end
+end

data/lib/exception_notifier/modules/formatter.rb

@@ -0,0 +1,118 @@
+require 'active_support/core_ext/time'
+require 'action_dispatch'
+
+module ExceptionNotifier
+  class Formatter
+    include ExceptionNotifier::BacktraceCleaner
+
+    attr_reader :app_name
+
+    def initialize(exception, opts = {})
+      @exception = exception
+
+      @env = opts[:env]
+      @errors_count = opts[:accumulated_errors_count].to_i
+      @app_name = opts[:app_name] || rails_app_name
+    end
+
+    #
+    # :warning: Error occurred in production :warning:
+    # :warning: Error occurred :warning:
+    #
+    def title
+      env = Rails.env if defined?(::Rails) && ::Rails.respond_to?(:env)
+
+      if env
+        "⚠️ Error occurred in #{env} ⚠️"
+      else
+        '⚠️ Error occurred ⚠️'
+      end
+    end
+
+    #
+    # A *NoMethodError* occurred.
+    # 3 *NoMethodError* occurred.
+    # A *NoMethodError* occurred in *home#index*.
+    #
+    def subtitle
+      errors_text = if errors_count > 1
+                      errors_count
+                    else
+                      exception.class.to_s =~ /^[aeiou]/i ? 'An' : 'A'
+                    end
+
+      in_action = " in *#{controller_and_action}*" if controller
+
+      "#{errors_text} *#{exception.class}* occurred#{in_action}."
+    end
+
+    #
+    #
+    # *Request:*
+    # ```
+    # * url : https://www.example.com/
+    # * http_method : GET
+    # * ip_address : 127.0.0.1
+    # * parameters : {"controller"=>"home", "action"=>"index"}
+    # * timestamp : 2019-01-01 00:00:00 UTC
+    # ```
+    #
+    def request_message
+      request = ActionDispatch::Request.new(env) if env
+      return unless request
+
+      [
+        '```',
+        "* url : #{request.original_url}",
+        "* http_method : #{request.method}",
+        "* ip_address : #{request.remote_ip}",
+        "* parameters : #{request.filtered_parameters}",
+        "* timestamp : #{Time.current}",
+        '```'
+      ].join("\n")
+    end
+
+    #
+    #
+    # *Backtrace:*
+    # ```
+    # * app/controllers/my_controller.rb:99:in `specific_function'
+    # * app/controllers/my_controller.rb:70:in `specific_param'
+    # * app/controllers/my_controller.rb:53:in `my_controller_params'
+    # ```
+    #
+    def backtrace_message
+      backtrace = exception.backtrace ? clean_backtrace(exception) : nil
+
+      return unless backtrace
+
+      text = []
+
+      text << '```'
+      backtrace.first(3).each { |line| text << "* #{line}" }
+      text << '```'
+
+      text.join("\n")
+    end
+
+    #
+    # home#index
+    #
+    def controller_and_action
+      "#{controller.controller_name}##{controller.action_name}" if controller
+    end
+
+    private
+
+    attr_reader :exception, :env, :errors_count
+
+    def rails_app_name
+      return unless defined?(::Rails) && ::Rails.respond_to?(:application)
+      Rails.application.class.parent_name.underscore
+    end
+
+    def controller
+      env['action_controller.instance'] if env
+    end
+  end
+end

data/lib/exception_notifier/notifier.rb

@@ -2,14 +2,13 @@ require 'active_support/deprecation'
 
 module ExceptionNotifier
   class Notifier
-
-    def self.exception_notification(env, exception, options={})
-      ActiveSupport::Deprecation.warn "Please use ExceptionNotifier.notify_exception(exception, options.merge(:env => env))."
-      ExceptionNotifier.registered_exception_notifier(:email).create_email(exception, options.merge(:env => env))
+    def self.exception_notification(env, exception, options = {})
+      ActiveSupport::Deprecation.warn 'Please use ExceptionNotifier.notify_exception(exception, options.merge(env: env)).'
+      ExceptionNotifier.registered_exception_notifier(:email).create_email(exception, options.merge(env: env))
     end
 
-    def self.background_exception_notification(exception, options={})
-      ActiveSupport::Deprecation.warn "Please use ExceptionNotifier.notify_exception(exception, options)."
+    def self.background_exception_notification(exception, options = {})
+      ActiveSupport::Deprecation.warn 'Please use ExceptionNotifier.notify_exception(exception, options).'
       ExceptionNotifier.registered_exception_notifier(:email).create_email(exception, options)
     end
   end

data/lib/exception_notifier/slack_notifier.rb

@@ -15,21 +15,65 @@ module ExceptionNotifier
         @message_opts = options.fetch(:additional_parameters, {})
         @color = @message_opts.delete(:color) { 'danger' }
         @notifier = Slack::Notifier.new webhook_url, options
-      rescue
+      rescue StandardError
         @notifier = nil
       end
     end
 
-    def call(exception, options={})
+    def call(exception, options = {})
+      clean_message = exception.message.tr('`', "'")
+      attchs = attchs(exception, clean_message, options)
+
+      return unless valid?
+
+      args = [exception, options, clean_message, @message_opts.merge(attachments: attchs)]
+      send_notice(*args) do |_msg, message_opts|
+        message_opts[:channel] = options[:channel] if options.key?(:channel)
+
+        @notifier.ping '', message_opts
+      end
+    end
+
+    protected
+
+    def valid?
+      !@notifier.nil?
+    end
+
+    def deep_reject(hash, block)
+      hash.each do |k, v|
+        deep_reject(v, block) if v.is_a?(Hash)
+
+        hash.delete(k) if block.call(k, v)
+      end
+    end
+
+    private
+
+    def attchs(exception, clean_message, options)
+      text, data = information_from_options(exception.class, options)
+      backtrace = clean_backtrace(exception) if exception.backtrace
+      fields = fields(clean_message, backtrace, data)
+
+      [color: @color, text: text, fields: fields, mrkdwn_in: %w[text fields]]
+    end
+
+    def information_from_options(exception_class, options)
       errors_count = options[:accumulated_errors_count].to_i
-      measure_word = errors_count > 1 ? errors_count : (exception.class.to_s =~ /^[aeiou]/i ? 'An' : 'A')
-      exception_name = "*#{measure_word}* `#{exception.class.to_s}`"
 
-      if options[:env].nil?
+      measure_word = if errors_count > 1
+                       errors_count
+                     else
+                       exception_class.to_s =~ /^[aeiou]/i ? 'An' : 'A'
+                     end
+
+      exception_name = "*#{measure_word}* `#{exception_class}`"
+      env = options[:env]
+
+      if env.nil?
         data = options[:data] || {}
         text = "#{exception_name} *occured in background*\n"
       else
-        env = options[:env]
         data = (env['exception_notifier.exception_data'] || {}).merge(options[:data] || {})
 
         kontroller = env['action_controller.instance']
@@ -39,50 +83,29 @@ module ExceptionNotifier
         text += "\n"
       end
 
-      clean_message = exception.message.gsub("`", "'")
-      fields = [ { title: 'Exception', value: clean_message } ]
+      [text, data]
+    end
 
-      fields.push({ title: 'Hostname', value: Socket.gethostname })
+    def fields(clean_message, backtrace, data)
+      fields = [
+        { title: 'Exception', value: clean_message },
+        { title: 'Hostname', value: Socket.gethostname }
+      ]
 
-      if exception.backtrace
-        formatted_backtrace = "```#{exception.backtrace.first(@backtrace_lines).join("\n")}```"
-        fields.push({ title: 'Backtrace', value: formatted_backtrace })
+      if backtrace
+        formatted_backtrace = "```#{backtrace.first(@backtrace_lines).join("\n")}```"
+        fields << { title: 'Backtrace', value: formatted_backtrace }
       end
 
       unless data.empty?
         deep_reject(data, @ignore_data_if) if @ignore_data_if.is_a?(Proc)
-        data_string = data.map{|k,v| "#{k}: #{v}"}.join("\n")
-        fields.push({ title: 'Data', value: "```#{data_string}```" })
+        data_string = data.map { |k, v| "#{k}: #{v}" }.join("\n")
+        fields << { title: 'Data', value: "```#{data_string}```" }
       end
 
       fields.concat(@additional_fields) if @additional_fields
 
-      attchs = [color: @color, text: text, fields: fields, mrkdwn_in: %w(text fields)]
-
-      if valid?
-        send_notice(exception, options, clean_message, @message_opts.merge(attachments: attchs)) do |msg, message_opts|
-          @notifier.ping '', message_opts
-        end
-      end
-    end
-
-    protected
-
-    def valid?
-      !@notifier.nil?
-    end
-
-    def deep_reject(hash, block)
-      hash.each do |k, v|
-        if v.is_a?(Hash)
-          deep_reject(v, block)
-        end
-
-        if block.call(k, v)
-          hash.delete(k)
-        end
-      end
+      fields
     end
-
   end
 end

data/lib/exception_notifier/sns_notifier.rb

@@ -3,9 +3,9 @@ module ExceptionNotifier
     def initialize(options)
       super
 
-      raise ArgumentError.new "You must provide 'region' option" unless options[:region]
-      raise ArgumentError.new "You must provide 'access_key_id' option" unless options[:access_key_id]
-      raise ArgumentError.new "You must provide 'secret_access_key' option" unless options[:secret_access_key]
+      raise ArgumentError, "You must provide 'region' option" unless options[:region]
+      raise ArgumentError, "You must provide 'access_key_id' option" unless options[:access_key_id]
+      raise ArgumentError, "You must provide 'secret_access_key' option" unless options[:secret_access_key]
 
       @notifier = Aws::SNS::Client.new(
         region: options[:region],
@@ -35,8 +35,8 @@ module ExceptionNotifier
     def build_subject(exception, options)
       subject = "#{options[:sns_prefix]} - "
       subject << accumulated_exception_name(exception, options)
-      subject << " occurred"
-      subject.length > 120 ? subject[0...120] + "..." : subject
+      subject << ' occurred'
+      subject.length > 120 ? subject[0...120] + '...' : subject
     end
 
     def build_message(exception, options)
@@ -57,16 +57,22 @@ module ExceptionNotifier
       text += "Exception: #{exception.message}\n"
       text += "Hostname: #{Socket.gethostname}\n"
 
-      if exception.backtrace
-        formatted_backtrace = "#{exception.backtrace.first(options[:backtrace_lines]).join("\n")}"
-        text += "Backtrace:\n#{formatted_backtrace}\n"
-      end
+      return unless exception.backtrace
+
+      formatted_backtrace = exception.backtrace.first(options[:backtrace_lines]).join("\n").to_s
+      text + "Backtrace:\n#{formatted_backtrace}\n"
     end
 
     def accumulated_exception_name(exception, options)
       errors_count = options[:accumulated_errors_count].to_i
-      measure_word = errors_count > 1 ? errors_count : (exception.class.to_s =~ /^[aeiou]/i ? 'An' : 'A')
-      "#{measure_word} #{exception.class.to_s}"
+
+      measure_word = if errors_count > 1
+                       errors_count
+                     else
+                       exception.class.to_s =~ /^[aeiou]/i ? 'An' : 'A'
+                     end
+
+      "#{measure_word} #{exception.class}"
     end
 
     def default_options

data/lib/exception_notifier/teams_notifier.rb

@@ -1,13 +1,13 @@
 require 'action_dispatch'
 require 'active_support/core_ext/time'
+require 'json'
 
 module ExceptionNotifier
   class TeamsNotifier < BaseNotifier
     include ExceptionNotifier::BacktraceCleaner
 
     class MissingController
-      def method_missing(*args, &block)
-      end
+      def method_missing(*args, &block); end
     end
 
     attr_accessor :httparty
@@ -18,21 +18,23 @@ module ExceptionNotifier
       @httparty = HTTParty
     end
 
-    def call(exception, options={})
+    def call(exception, options = {})
       @options = options.merge(@default_options)
       @exception = exception
       @backtrace = exception.backtrace ? clean_backtrace(exception) : nil
 
       @env = @options.delete(:env)
 
-      @application_name = @options.delete(:app_name) || Rails.application.class.parent_name.underscore
+      @application_name = @options.delete(:app_name) || rails_app_name
       @gitlab_url = @options.delete(:git_url)
       @jira_url = @options.delete(:jira_url)
 
       @webhook_url = @options.delete(:webhook_url)
-      raise ArgumentError.new "You must provide 'webhook_url' parameter." unless @webhook_url
+      raise ArgumentError, "You must provide 'webhook_url' parameter." unless @webhook_url
 
-      unless @env.nil?
+      if @env.nil?
+        @controller = @request_items = nil
+      else
         @controller = @env['action_controller.instance'] || MissingController.new
 
         request = ActionDispatch::Request.new(@env)
@@ -43,19 +45,17 @@ module ExceptionNotifier
                            parameters: request.filtered_parameters,
                            timestamp: Time.current }
 
-        if request.session["warden.user.user.key"]
-          current_user = User.find(request.session["warden.user.user.key"][0][0])
-          @request_items.merge!({ current_user: { id: current_user.id, email: current_user.email  } })
+        if request.session['warden.user.user.key']
+          current_user = User.find(request.session['warden.user.user.key'][0][0])
+          @request_items[:current_user] = { id: current_user.id, email: current_user.email }
         end
-      else
-        @controller = @request_items = nil
       end
 
       payload = message_text
 
       @options[:body] = payload.to_json
       @options[:headers] ||= {}
-      @options[:headers].merge!({ 'Content-Type' => 'application/json' })
+      @options[:headers]['Content-Type'] = 'application/json'
       @options[:debug_output] = $stdout
 
       @httparty.post(@webhook_url, @options)
@@ -67,17 +67,17 @@ module ExceptionNotifier
       errors_count = @options[:accumulated_errors_count].to_i
 
       text = {
-        "@type" => "MessageCard",
-        "@context" => "http://schema.org/extensions",
-        "summary" => "#{@application_name} Exception Alert",
-        "title" => "⚠️ Exception Occurred in #{Rails.env} ⚠️",
-        "sections" => [
+        '@type' => 'MessageCard',
+        '@context' => 'http://schema.org/extensions',
+        'summary' => "#{@application_name} Exception Alert",
+        'title' => "⚠️ Exception Occurred in #{env_name} ⚠️",
+        'sections' => [
           {
-            "activityTitle" => "#{errors_count > 1 ? errors_count : 'A'} *#{@exception.class}* occurred" + if @controller then " in *#{controller_and_method}*." else "." end,
-            "activitySubtitle" => "#{@exception.message}"
+            'activityTitle' => "#{errors_count > 1 ? errors_count : 'A'} *#{@exception.class}* occurred" + (@controller ? " in *#{controller_and_method}*." : '.'),
+            'activitySubtitle' => @exception.message.to_s
           }
         ],
-        "potentialAction" => []
+        'potentialAction' => []
       }
 
       text['sections'].push details
@@ -90,8 +90,8 @@ module ExceptionNotifier
 
     def details
       details = {
-        "title" => "Details",
-        "facts" => []
+        'title' => 'Details',
+        'facts' => []
       }
 
       details['facts'].push message_request unless @request_items.nil?
@@ -102,59 +102,59 @@ module ExceptionNotifier
 
     def message_request
       {
-        "name" => "Request",
-        "value" => "#{hash_presentation(@request_items)}\n  "
+        'name' => 'Request',
+        'value' => "#{hash_presentation(@request_items)}\n  "
       }
     end
 
     def message_backtrace(size = 3)
       text = []
       size = @backtrace.size < size ? @backtrace.size : size
-      text << "```"
-      size.times { |i| text << "* " + @backtrace[i] }
-      text << "```"
+      text << '```'
+      size.times { |i| text << '* ' + @backtrace[i] }
+      text << '```'
 
       {
-        "name" => "Backtrace",
-        "value" => "#{text.join("  \n")}"
+        'name' => 'Backtrace',
+        'value' => text.join("  \n").to_s
       }
     end
 
     def gitlab_view_link
       {
-        "@type" => "ViewAction",
-        "name" => "🦊 View in GitLab",
-        "target" => [
+        '@type' => 'ViewAction',
+        'name' => "\u{1F98A} View in GitLab",
+        'target' => [
           "#{@gitlab_url}/#{@application_name}"
         ]
       }
     end
 
     def gitlab_issue_link
-      link = [@gitlab_url, @application_name, "issues", "new"].join("/")
+      link = [@gitlab_url, @application_name, 'issues', 'new'].join('/')
       params = {
-        "issue[title]" => ["[BUG] Error 500 :",
+        'issue[title]' => ['[BUG] Error 500 :',
                            controller_and_method,
                            "(#{@exception.class})",
-                           @exception.message].compact.join(" ")
+                           @exception.message].compact.join(' ')
       }.to_query
 
       {
-        "@type" => "ViewAction",
-        "name" => "🦊 Create Issue in GitLab",
-        "target" => [
+        '@type' => 'ViewAction',
+        'name' => "\u{1F98A} Create Issue in GitLab",
+        'target' => [
           "#{link}/?#{params}"
-      ]
+        ]
       }
     end
 
     def jira_issue_link
       {
-        "@type" => "ViewAction",
-        "name" => "🐞 Create Issue in Jira",
-        "target" => [
+        '@type' => 'ViewAction',
+        'name' => '🐞 Create Issue in Jira',
+        'target' => [
           "#{@jira_url}/secure/CreateIssue!default.jspa"
-      ]
+        ]
       }
     end
 
@@ -162,7 +162,7 @@ module ExceptionNotifier
       if @controller
         "#{@controller.controller_name}##{@controller.action_name}"
       else
-        ""
+        ''
       end
     end
 
@@ -175,5 +175,19 @@ module ExceptionNotifier
 
       text.join("  \n")
     end
+
+    def rails_app_name
+      return unless defined?(Rails) && Rails.respond_to?(:application)
+
+      if ::Gem::Version.new(Rails.version) >= ::Gem::Version.new('6.0')
+        Rails.application.class.module_parent_name.underscore
+      else
+        Rails.application.class.parent_name.underscore
+      end
+    end
+
+    def env_name
+      Rails.env if defined?(Rails) && Rails.respond_to?(:env)
+    end
   end
 end