exception_notification 4.2.0 → 4.4.1

data/lib/exception_notifier/modules/formatter.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+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

@@ -1,15 +1,18 @@
+# frozen_string_literal: true
+
 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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ExceptionNotifier
   class SlackNotifier < BaseNotifier
     include ExceptionNotifier::BacktraceCleaner
@@ -8,43 +10,29 @@ module ExceptionNotifier
       super
       begin
         @ignore_data_if = options[:ignore_data_if]
+        @backtrace_lines = options.fetch(:backtrace_lines, 10)
+        @additional_fields = options[:additional_fields]
 
         webhook_url = options.fetch(:webhook_url)
         @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={})
-      env = options[:env] || {}
-      title = "#{env['REQUEST_METHOD']} <#{env['REQUEST_URI']}>"
-      data = (env['exception_notifier.exception_data'] || {}).merge(options[:data] || {})
-      text = "*An exception occurred while doing*: `#{title}`\n"
-
-      clean_message = exception.message.gsub("`", "'")
-      fields = [ { title: 'Exception', value: clean_message} ]
-
-      fields.push({ title: 'Hostname', value: Socket.gethostname })
-
-      if exception.backtrace
-        formatted_backtrace = "```#{exception.backtrace.join("\n")}```"
-        fields.push({ title: 'Backtrace', value: formatted_backtrace })
-      end
+    def call(exception, options = {})
+      clean_message = exception.message.tr('`', "'")
+      attchs = attchs(exception, clean_message, options)
 
-      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}```" })
-      end
+      return unless valid?
 
-      attchs = [color: 'danger', text: text, fields: fields, mrkdwn_in: %w(text fields)]
+      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)
 
-      if valid?
-        send_notice(exception, options, clean_message, @message_opts.merge(attachments: attchs)) do |msg, message_opts|
-          @notifier.ping '', message_opts
-        end
+        @notifier.ping '', message_opts
       end
     end
 
@@ -56,15 +44,70 @@ module ExceptionNotifier
 
     def deep_reject(hash, block)
       hash.each do |k, v|
-        if v.is_a?(Hash)
-          deep_reject(v, block)
-        end
+        deep_reject(v, block) if v.is_a?(Hash)
 
-        if block.call(k, v)
-          hash.delete(k)
-        end
+        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 = 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
+        data = (env['exception_notifier.exception_data'] || {}).merge(options[:data] || {})
+
+        kontroller = env['action_controller.instance']
+        request = "#{env['REQUEST_METHOD']} <#{env['REQUEST_URI']}>"
+        text = "#{exception_name} *occurred while* `#{request}`"
+        text += " *was processed by* `#{kontroller.controller_name}##{kontroller.action_name}`" if kontroller
+        text += "\n"
+      end
+
+      [text, data]
+    end
+
+    def fields(clean_message, backtrace, data)
+      fields = [
+        { title: 'Exception', value: clean_message },
+        { title: 'Hostname', value: Socket.gethostname }
+      ]
+
+      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 << { title: 'Data', value: "```#{data_string}```" }
+      end
+
+      fields.concat(@additional_fields) if @additional_fields
+
+      fields
+    end
   end
 end

data/lib/exception_notifier/sns_notifier.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module ExceptionNotifier
+  class SnsNotifier < BaseNotifier
+    def initialize(options)
+      super
+
+      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],
+        access_key_id: options[:access_key_id],
+        secret_access_key: options[:secret_access_key]
+      )
+      @options = default_options.merge(options)
+    end
+
+    def call(exception, custom_opts = {})
+      custom_options = options.merge(custom_opts)
+
+      subject = build_subject(exception, custom_options)
+      message = build_message(exception, custom_options)
+
+      notifier.publish(
+        topic_arn: custom_options[:topic_arn],
+        message: message,
+        subject: subject
+      )
+    end
+
+    private
+
+    attr_reader :notifier, :options
+
+    def build_subject(exception, options)
+      subject =
+        "#{options[:sns_prefix]} - #{accumulated_exception_name(exception, options)} occurred"
+      subject.length > 120 ? subject[0...120] + '...' : subject
+    end
+
+    def build_message(exception, options)
+      exception_name = accumulated_exception_name(exception, options)
+
+      if options[:env].nil?
+        text = "#{exception_name} occured in background\n"
+      else
+        env = options[:env]
+
+        kontroller = env['action_controller.instance']
+        request = "#{env['REQUEST_METHOD']} <#{env['REQUEST_URI']}>"
+
+        text = "#{exception_name} occurred while #{request}"
+        text += " was processed by #{kontroller.controller_name}##{kontroller.action_name}\n" if kontroller
+      end
+
+      text += "Exception: #{exception.message}\n"
+      text += "Hostname: #{Socket.gethostname}\n"
+
+      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 = if errors_count > 1
+                       errors_count
+                     else
+                       exception.class.to_s =~ /^[aeiou]/i ? 'An' : 'A'
+                     end
+
+      "#{measure_word} #{exception.class}"
+    end
+
+    def default_options
+      {
+        sns_prefix: '[ERROR]',
+        backtrace_lines: 10
+      }
+    end
+  end
+end

data/lib/exception_notifier/teams_notifier.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+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
+    end
+
+    attr_accessor :httparty
+
+    def initialize(options = {})
+      super
+      @default_options = options
+      @httparty = HTTParty
+    end
+
+    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_app_name
+      @gitlab_url = @options.delete(:git_url)
+      @jira_url = @options.delete(:jira_url)
+
+      @webhook_url = @options.delete(:webhook_url)
+      raise ArgumentError, "You must provide 'webhook_url' parameter." unless @webhook_url
+
+      if @env.nil?
+        @controller = @request_items = nil
+      else
+        @controller = @env['action_controller.instance'] || MissingController.new
+
+        request = ActionDispatch::Request.new(@env)
+
+        @request_items = { url: request.original_url,
+                           http_method: request.method,
+                           ip_address: request.remote_ip,
+                           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[:current_user] = { id: current_user.id, email: current_user.email }
+        end
+      end
+
+      payload = message_text
+
+      @options[:body] = payload.to_json
+      @options[:headers] ||= {}
+      @options[:headers]['Content-Type'] = 'application/json'
+      @options[:debug_output] = $stdout
+
+      @httparty.post(@webhook_url, @options)
+    end
+
+    private
+
+    def message_text
+      text = {
+        '@type' => 'MessageCard',
+        '@context' => 'http://schema.org/extensions',
+        'summary' => "#{@application_name} Exception Alert",
+        'title' => "⚠️ Exception Occurred in #{env_name} ⚠️",
+        'sections' => [
+          {
+            'activityTitle' => activity_title,
+            'activitySubtitle' => @exception.message.to_s
+          }
+        ],
+        'potentialAction' => []
+      }
+
+      text['sections'].push details
+      text['potentialAction'].push gitlab_view_link unless @gitlab_url.nil?
+      text['potentialAction'].push gitlab_issue_link unless @gitlab_url.nil?
+      text['potentialAction'].push jira_issue_link unless @jira_url.nil?
+
+      text
+    end
+
+    def details
+      details = {
+        'title' => 'Details',
+        'facts' => []
+      }
+
+      details['facts'].push message_request unless @request_items.nil?
+      details['facts'].push message_backtrace unless @backtrace.nil?
+
+      details
+    end
+
+    def activity_title
+      errors_count = @options[:accumulated_errors_count].to_i
+
+      "#{errors_count > 1 ? errors_count : 'A'} *#{@exception.class}* occurred" +
+        (@controller ? " in *#{controller_and_method}*." : '.')
+    end
+
+    def message_request
+      {
+        '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 << '```'
+
+      {
+        'name' => 'Backtrace',
+        'value' => text.join("  \n").to_s
+      }
+    end
+
+    def gitlab_view_link
+      {
+        '@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('/')
+      params = {
+        'issue[title]' => ['[BUG] Error 500 :',
+                           controller_and_method,
+                           "(#{@exception.class})",
+                           @exception.message].compact.join(' ')
+      }.to_query
+
+      {
+        '@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' => [
+          "#{@jira_url}/secure/CreateIssue!default.jspa"
+        ]
+      }
+    end
+
+    def controller_and_method
+      if @controller
+        "#{@controller.controller_name}##{@controller.action_name}"
+      else
+        ''
+      end
+    end
+
+    def hash_presentation(hash)
+      text = []
+
+      hash.each do |key, value|
+        text << "* **#{key}** : `#{value}`"
+      end
+
+      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