exception_notification 3.0.1 → 4.4.0

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

@@ -1,185 +1,15 @@
-require 'action_mailer'
-require 'pp'
+require 'active_support/deprecation'
 
-class ExceptionNotifier
-  class Notifier < ActionMailer::Base
-    self.mailer_name = 'exception_notifier'
-
-    #Append application view path to the ExceptionNotifier lookup context.
-    self.append_view_path "#{File.dirname(__FILE__)}/views"
-
-    class << self
-      attr_writer :default_sender_address
-      attr_writer :default_exception_recipients
-      attr_writer :default_email_prefix
-      attr_writer :default_email_format
-      attr_writer :default_sections
-      attr_writer :default_background_sections
-      attr_writer :default_verbose_subject
-      attr_writer :default_normalize_subject
-      attr_writer :default_smtp_settings
-      attr_writer :default_email_headers
-
-      def default_sender_address
-        @default_sender_address || %("Exception Notifier" <exception.notifier@default.com>)
-      end
-
-      def default_exception_recipients
-        @default_exception_recipients || []
-      end
-
-      def default_email_prefix
-        @default_email_prefix || "[ERROR] "
-      end
-
-      def default_email_format
-        @default_email_format || :text
-      end
-
-      def default_sections
-        @default_sections || %w(request session environment backtrace)
-      end
-
-      def default_background_sections
-        @default_background_sections || %w(backtrace data)
-      end
-
-      def default_verbose_subject
-        @default_verbose_subject.nil? || @default_verbose_subject
-      end
-
-      def default_normalize_subject
-        @default_normalize_prefix || false
-      end
-
-      def default_smtp_settings
-        @default_smtp_settings || nil
-      end
-
-      def default_email_headers
-        @default_email_headers || {}
-      end
-
-      def default_options
-        { :sender_address => default_sender_address,
-          :exception_recipients => default_exception_recipients,
-          :email_prefix => default_email_prefix,
-          :email_format => default_email_format,
-          :sections => default_sections,
-          :background_sections => default_background_sections,
-          :verbose_subject => default_verbose_subject,
-          :normalize_subject => default_normalize_subject,
-          :template_path => mailer_name,
-          :smtp_settings => default_smtp_settings,
-          :email_headers => default_email_headers }
-      end
-
-      def normalize_digits(string)
-        string.gsub(/[0-9]+/, 'N')
-      end
-    end
-
-    class MissingController
-      def method_missing(*args, &block)
-      end
-    end
-
-    def exception_notification(env, exception, options={})
-      load_custom_views
-
-      @env        = env
-      @exception  = exception
-      @options    = options.reverse_merge(env['exception_notifier.options'] || {}).reverse_merge(self.class.default_options)
-      @kontroller = env['action_controller.instance'] || MissingController.new
-      @request    = ActionDispatch::Request.new(env)
-      @backtrace  = exception.backtrace ? clean_backtrace(exception) : []
-      @sections   = @options[:sections]
-      @data       = (env['exception_notifier.exception_data'] || {}).merge(options[:data] || {})
-      @sections   = @sections + %w(data) unless @data.empty?
-      
-      compose_email
-    end
-
-    def background_exception_notification(exception, options={})
-      load_custom_views
-
-      if @notifier = Rails.application.config.middleware.detect{ |x| x.klass == ExceptionNotifier }
-        @options   = options.reverse_merge(@notifier.args.first || {}).reverse_merge(self.class.default_options)
-        @exception = exception
-        @backtrace = exception.backtrace || []
-        @sections  = @options[:background_sections]
-        @data      = options[:data] || {}
-
-        compose_email
-      end
-    end
-
-    private
-
-    def compose_subject
-      subject = "#{@options[:email_prefix]}"
-      subject << "#{@kontroller.controller_name}##{@kontroller.action_name}" if @kontroller
-      subject << " (#{@exception.class})"
-      subject << " #{@exception.message.inspect}" if @options[:verbose_subject]
-      subject = normalize_digits(subject) if @options[:normalize_subject]
-      subject.length > 120 ? subject[0...120] + "..." : subject
-    end
-
-    def set_data_variables
-      @data.each do |name, value|
-        instance_variable_set("@#{name}", value)
-      end
-    end
-
-    def clean_backtrace(exception)
-      if Rails.respond_to?(:backtrace_cleaner)
-       Rails.backtrace_cleaner.send(:filter, exception.backtrace)
-      else
-       exception.backtrace
-      end
-    end
-
-    helper_method :inspect_object
-
-    def inspect_object(object)
-      case object
-      when Hash, Array
-        object.inspect
-      when ActionController::Base
-        "#{object.controller_name}##{object.action_name}"
-      else
-        object.to_s
-      end
-    end
-
-    def html_mail?
-      @options[:email_format] == :html
-    end
-
-    def compose_email
-      set_data_variables
-      subject = compose_subject
-      name = @env.nil? ? 'background_exception_notification' : 'exception_notification'
-
-      headers = {
-        :to => @options[:exception_recipients], 
-        :from => @options[:sender_address],
-        :subject => subject, 
-        :template_name => name
-      }.merge(@options[:email_headers])
-
-      mail = mail(headers) do |format|
-        format.text
-        format.html if html_mail?
-      end
-      
-      mail.delivery_method.settings.merge!(@options[:smtp_settings]) if @options[:smtp_settings]
-      
-      mail
+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))
     end
 
-    def load_custom_views
-      self.prepend_view_path Rails.root.nil? ? "app/views" : "#{Rails.root}/app/views" if defined?(Rails)
+    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
 end

data/lib/exception_notifier/slack_notifier.rb

@@ -0,0 +1,111 @@
+module ExceptionNotifier
+  class SlackNotifier < BaseNotifier
+    include ExceptionNotifier::BacktraceCleaner
+
+    attr_accessor :notifier
+
+    def initialize(options)
+      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 StandardError
+        @notifier = nil
+      end
+    end
+
+    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 = 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,85 @@
+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]} - "
+      subject << accumulated_exception_name(exception, options)
+      subject << ' 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