exception_notification 4.2.1 → 4.4.3

data/lib/exception_notification/sidekiq.rb

@@ -1,18 +1,16 @@
+# frozen_string_literal: true
+
 require 'sidekiq'
 
 # Note: this class is only needed for Sidekiq version < 3.
 module ExceptionNotification
   class Sidekiq
-
-    def call(worker, msg, queue)
-      begin
-        yield
-      rescue Exception => exception
-        ExceptionNotifier.notify_exception(exception, :data => { :sidekiq => msg })
-        raise exception
-      end
+    def call(_worker, msg, _queue)
+      yield
+    rescue Exception => e
+      ExceptionNotifier.notify_exception(e, data: { sidekiq: msg })
+      raise e
     end
-
   end
 end
 
@@ -24,8 +22,8 @@ if ::Sidekiq::VERSION < '3'
   end
 else
   ::Sidekiq.configure_server do |config|
-    config.error_handlers << Proc.new { |ex, context|
-      ExceptionNotifier.notify_exception(ex, :data => { :sidekiq => context })
-    }
+    config.error_handlers << proc do |ex, context|
+      ExceptionNotifier.notify_exception(ex, data: { sidekiq: context })
+    end
   end
 end

data/lib/exception_notification/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ExceptionNotification
+  VERSION = '4.4.3'
+end

data/lib/exception_notifier.rb

@@ -1,11 +1,16 @@
+# frozen_string_literal: true
+
 require 'logger'
 require 'active_support/core_ext/string/inflections'
 require 'active_support/core_ext/module/attribute_accessors'
 require 'exception_notifier/base_notifier'
+require 'exception_notifier/modules/error_grouping'
 
 module ExceptionNotifier
+  include ErrorGrouping
 
   autoload :BacktraceCleaner, 'exception_notifier/modules/backtrace_cleaner'
+  autoload :Formatter, 'exception_notifier/modules/formatter'
 
   autoload :Notifier, 'exception_notifier/notifier'
   autoload :EmailNotifier, 'exception_notifier/email_notifier'
@@ -15,6 +20,10 @@ module ExceptionNotifier
   autoload :IrcNotifier, 'exception_notifier/irc_notifier'
   autoload :SlackNotifier, 'exception_notifier/slack_notifier'
   autoload :MattermostNotifier, 'exception_notifier/mattermost_notifier'
+  autoload :TeamsNotifier, 'exception_notifier/teams_notifier'
+  autoload :SnsNotifier, 'exception_notifier/sns_notifier'
+  autoload :GoogleChatNotifier, 'exception_notifier/google_chat_notifier'
+  autoload :DatadogNotifier, 'exception_notifier/datadog_notifier'
 
   class UndefinedNotifierError < StandardError; end
 
@@ -24,7 +33,10 @@ module ExceptionNotifier
 
   # Define a set of exceptions to be ignored, ie, dont send notifications when any of them are raised.
   mattr_accessor :ignored_exceptions
-  @@ignored_exceptions = %w{ActiveRecord::RecordNotFound Mongoid::Errors::DocumentNotFound AbstractController::ActionNotFound ActionController::RoutingError ActionController::UnknownFormat ActionController::UrlGenerationError}
+  @@ignored_exceptions = %w[
+    ActiveRecord::RecordNotFound Mongoid::Errors::DocumentNotFound AbstractController::ActionNotFound
+    ActionController::RoutingError ActionController::UnknownFormat ActionController::UrlGenerationError
+  ]
 
   mattr_accessor :testing_mode
   @@testing_mode = false
@@ -33,6 +45,9 @@ module ExceptionNotifier
     # Store conditions that decide when exceptions must be ignored or not.
     @@ignores = []
 
+    # Store by-notifier conditions that decide when exceptions must be ignored or not.
+    @@by_notifier_ignores = {}
+
     # Store notifiers that send notifications when exceptions are raised.
     @@notifiers = {}
 
@@ -40,14 +55,25 @@ module ExceptionNotifier
       self.testing_mode = true
     end
 
-    def notify_exception(exception, options={})
+    def notify_exception(exception, options = {}, &block)
       return false if ignored_exception?(options[:ignore_exceptions], exception)
       return false if ignored?(exception, options)
+
+      if error_grouping
+        errors_count = group_error!(exception, options)
+        return false unless send_notification?(exception, errors_count)
+      end
+
+      notification_fired = false
       selected_notifiers = options.delete(:notifiers) || notifiers
       [*selected_notifiers].each do |notifier|
-        fire_notification(notifier, exception, options.dup)
+        unless notifier_ignored?(exception, options, notifier: notifier)
+          fire_notification(notifier, exception, options.dup, &block)
+          notification_fired = true
+        end
       end
-      true
+
+      notification_fired
     end
 
     def register_exception_notifier(name, notifier_or_options)
@@ -82,31 +108,65 @@ module ExceptionNotifier
       @@ignores << block
     end
 
+    def ignore_notifier_if(notifier, &block)
+      @@by_notifier_ignores[notifier] = block
+    end
+
+    def ignore_crawlers(crawlers)
+      ignore_if do |_exception, opts|
+        opts.key?(:env) && from_crawler(opts[:env], crawlers)
+      end
+    end
+
     def clear_ignore_conditions!
       @@ignores.clear
+      @@by_notifier_ignores.clear
     end
 
     private
+
     def ignored?(exception, options)
-      @@ignores.any?{ |condition| condition.call(exception, options) }
+      @@ignores.any? { |condition| condition.call(exception, options) }
     rescue Exception => e
       raise e if @@testing_mode
 
-      logger.warn "An error occurred when evaluating an ignore condition. #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+      logger.warn(
+        "An error occurred when evaluating an ignore condition. #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+      )
+      false
+    end
+
+    def notifier_ignored?(exception, options, notifier:)
+      return false unless @@by_notifier_ignores.key?(notifier)
+
+      condition = @@by_notifier_ignores[notifier]
+      condition.call(exception, options)
+    rescue Exception => e
+      raise e if @@testing_mode
+
+      logger.warn(<<~"MESSAGE")
+        An error occurred when evaluating a by-notifier ignore condition. #{e.class}: #{e.message}
+        #{e.backtrace.join("\n")}
+      MESSAGE
       false
     end
 
     def ignored_exception?(ignore_array, exception)
-      (Array(ignored_exceptions) + Array(ignore_array)).map(&:to_s).include?(exception.class.name)
+      all_ignored_exceptions = (Array(ignored_exceptions) + Array(ignore_array)).map(&:to_s)
+      exception_ancestors = exception.singleton_class.ancestors.map(&:to_s)
+      !(all_ignored_exceptions & exception_ancestors).empty?
     end
 
-    def fire_notification(notifier_name, exception, options)
+    def fire_notification(notifier_name, exception, options, &block)
       notifier = registered_exception_notifier(notifier_name)
-      notifier.call(exception, options)
+      notifier.call(exception, options, &block)
     rescue Exception => e
       raise e if @@testing_mode
 
-      logger.warn "An error occurred when sending a notification using '#{notifier_name}' notifier. #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+      logger.warn(
+        "An error occurred when sending a notification using '#{notifier_name}' notifier." \
+        "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+      )
       false
     end
 
@@ -116,7 +176,15 @@ module ExceptionNotifier
       notifier = notifier_class.new(options)
       register_exception_notifier(name, notifier)
     rescue NameError => e
-      raise UndefinedNotifierError, "No notifier named '#{name}' was found. Please, revise your configuration options. Cause: #{e.message}"
+      raise UndefinedNotifierError,
+            "No notifier named '#{name}' was found. Please, revise your configuration options. Cause: #{e.message}"
+    end
+
+    def from_crawler(env, ignored_crawlers)
+      agent = env['HTTP_USER_AGENT']
+      Array(ignored_crawlers).any? do |crawler|
+        agent =~ Regexp.new(crawler)
+      end
     end
   end
 end

data/lib/exception_notifier/base_notifier.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module ExceptionNotifier
   class BaseNotifier
     attr_accessor :base_options
 
-    def initialize(options={})
+    def initialize(options = {})
       @base_options = options
     end
 
-    def send_notice(exception, options, message, message_opts=nil)
+    def send_notice(exception, options, message, message_opts = nil)
       _pre_callback(exception, options, message, message_opts)
       result = yield(message, message_opts)
       _post_callback(exception, options, message, message_opts)
@@ -14,12 +16,15 @@ module ExceptionNotifier
     end
 
     def _pre_callback(exception, options, message, message_opts)
-      @base_options[:pre_callback].call(options, self, exception.backtrace, message, message_opts) if @base_options[:pre_callback].respond_to?(:call)
+      return unless @base_options[:pre_callback].respond_to?(:call)
+
+      @base_options[:pre_callback].call(options, self, exception.backtrace, message, message_opts)
     end
 
     def _post_callback(exception, options, message, message_opts)
-      @base_options[:post_callback].call(options, self, exception.backtrace, message, message_opts) if @base_options[:post_callback].respond_to?(:call)
-    end
+      return unless @base_options[:post_callback].respond_to?(:call)
 
+      @base_options[:post_callback].call(options, self, exception.backtrace, message, message_opts)
+    end
   end
 end

data/lib/exception_notifier/campfire_notifier.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module ExceptionNotifier
   class CampfireNotifier < BaseNotifier
-
     attr_accessor :subdomain
     attr_accessor :token
     attr_accessor :room
@@ -12,18 +13,22 @@ module ExceptionNotifier
         room_name = options.delete(:room_name)
         @campfire = Tinder::Campfire.new subdomain, options
         @room     = @campfire.find_room_by_name room_name
-      rescue
+      rescue StandardError
         @campfire = @room = nil
       end
     end
 
-    def call(exception, options={})
-      if active?
-        message = "A new exception occurred: '#{exception.message}'"
-        message += " on '#{exception.backtrace.first}'" if exception.backtrace
-        send_notice(exception, options, message) do |msg, _|
-          @room.paste msg
-        end
+    def call(exception, options = {})
+      return unless active?
+
+      message = if options[:accumulated_errors_count].to_i > 1
+                  "The exception occurred #{options[:accumulated_errors_count]} times: '#{exception.message}'"
+                else
+                  "A new exception occurred: '#{exception.message}'"
+                end
+      message += " on '#{exception.backtrace.first}'" if exception.backtrace
+      send_notice(exception, options, message) do |msg, _|
+        @room.paste msg
       end
     end
 

data/lib/exception_notifier/datadog_notifier.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require 'action_dispatch'
+
+module ExceptionNotifier
+  class DatadogNotifier < BaseNotifier
+    attr_reader :client,
+                :default_options
+
+    def initialize(options)
+      super
+      @client = options.fetch(:client)
+      @default_options = options
+    end
+
+    def call(exception, options = {})
+      client.emit_event(
+        datadog_event(exception, options)
+      )
+    end
+
+    def datadog_event(exception, options = {})
+      DatadogExceptionEvent.new(
+        exception,
+        options.reverse_merge(default_options)
+      ).event
+    end
+
+    class DatadogExceptionEvent
+      include ExceptionNotifier::BacktraceCleaner
+
+      MAX_TITLE_LENGTH = 120
+      MAX_VALUE_LENGTH = 300
+      MAX_BACKTRACE_SIZE = 3
+      ALERT_TYPE = 'error'
+
+      attr_reader :exception,
+                  :options
+
+      def initialize(exception, options)
+        @exception = exception
+        @options = options
+      end
+
+      def request
+        @request ||= ActionDispatch::Request.new(options[:env]) if options[:env]
+      end
+
+      def controller
+        @controller ||= options[:env] && options[:env]['action_controller.instance']
+      end
+
+      def backtrace
+        @backtrace ||= exception.backtrace ? clean_backtrace(exception) : []
+      end
+
+      def tags
+        options[:tags] || []
+      end
+
+      def title_prefix
+        options[:title_prefix] || ''
+      end
+
+      def event
+        title = formatted_title
+        body = formatted_body
+
+        Dogapi::Event.new(
+          body,
+          msg_title: title,
+          alert_type: ALERT_TYPE,
+          tags: tags,
+          aggregation_key: [title]
+        )
+      end
+
+      def formatted_title
+        title =
+          "#{title_prefix}#{controller_subtitle} (#{exception.class}) #{exception.message.inspect}"
+
+        truncate(title, MAX_TITLE_LENGTH)
+      end
+
+      def formatted_body
+        text = []
+
+        text << '%%%'
+        text << formatted_request if request
+        text << formatted_session if request
+        text << formatted_backtrace
+        text << '%%%'
+
+        text.join("\n")
+      end
+
+      def formatted_key_value(key, value)
+        "**#{key}:** #{value}"
+      end
+
+      def formatted_request
+        text = []
+        text << '### **Request**'
+        text << formatted_key_value('URL', request.url)
+        text << formatted_key_value('HTTP Method', request.request_method)
+        text << formatted_key_value('IP Address', request.remote_ip)
+        text << formatted_key_value('Parameters', request.filtered_parameters.inspect)
+        text << formatted_key_value('Timestamp', Time.current)
+        text << formatted_key_value('Server', Socket.gethostname)
+        text << formatted_key_value('Rails root', Rails.root) if defined?(Rails) && Rails.respond_to?(:root)
+        text << formatted_key_value('Process', $PROCESS_ID)
+        text << '___'
+        text.join("\n")
+      end
+
+      def formatted_session
+        text = []
+        text << '### **Session**'
+        text << formatted_key_value('Data', request.session.to_hash)
+        text << '___'
+        text.join("\n")
+      end
+
+      def formatted_backtrace
+        size = [backtrace.size, MAX_BACKTRACE_SIZE].min
+
+        text = []
+        text << '### **Backtrace**'
+        text << '````'
+        size.times { |i| text << backtrace[i] }
+        text << '````'
+        text << '___'
+        text.join("\n")
+      end
+
+      def truncate(string, max)
+        string.length > max ? "#{string[0...max]}..." : string
+      end
+
+      def inspect_object(object)
+        case object
+        when Hash, Array
+          truncate(object.inspect, MAX_VALUE_LENGTH)
+        else
+          object.to_s
+        end
+      end
+
+      private
+
+      def controller_subtitle
+        "#{controller.controller_name} #{controller.action_name}" if controller
+      end
+    end
+  end
+end

data/lib/exception_notifier/email_notifier.rb

@@ -1,4 +1,5 @@
-require "active_support/core_ext/hash/reverse_merge"
+# frozen_string_literal: true
+
 require 'active_support/core_ext/time'
 require 'action_mailer'
 require 'action_dispatch'
@@ -6,47 +7,61 @@ require 'pp'
 
 module ExceptionNotifier
   class EmailNotifier < BaseNotifier
-    attr_accessor(:sender_address, :exception_recipients,
-    :pre_callback, :post_callback,
-    :email_prefix, :email_format, :sections, :background_sections,
-    :verbose_subject, :normalize_subject, :delivery_method, :mailer_settings,
-    :email_headers, :mailer_parent, :template_path, :deliver_with)
+    DEFAULT_OPTIONS = {
+      sender_address: %("Exception Notifier" <exception.notifier@example.com>),
+      exception_recipients: [],
+      email_prefix: '[ERROR] ',
+      email_format: :text,
+      sections: %w[request session environment backtrace],
+      background_sections: %w[backtrace data],
+      verbose_subject: true,
+      normalize_subject: false,
+      include_controller_and_action_names_in_subject: true,
+      delivery_method: nil,
+      mailer_settings: nil,
+      email_headers: {},
+      mailer_parent: 'ActionMailer::Base',
+      template_path: 'exception_notifier',
+      deliver_with: nil
+    }.freeze
 
     module Mailer
       class MissingController
-        def method_missing(*args, &block)
-        end
+        def method_missing(*args, &block); end
       end
 
       def self.extended(base)
         base.class_eval do
-          self.send(:include, ExceptionNotifier::BacktraceCleaner)
+          send(:include, ExceptionNotifier::BacktraceCleaner)
 
           # Append application view path to the ExceptionNotifier lookup context.
-          self.append_view_path "#{File.dirname(__FILE__)}/views"
+          append_view_path "#{File.dirname(__FILE__)}/views"
 
-          def exception_notification(env, exception, options={}, default_options={})
+          def exception_notification(env, exception, options = {}, default_options = {})
             load_custom_views
 
             @env        = env
             @exception  = exception
-            @options    = options.reverse_merge(env['exception_notifier.options'] || {}).reverse_merge(default_options)
+
+            env_options = env['exception_notifier.options'] || {}
+            @options    = default_options.merge(env_options).merge(options)
+
             @kontroller = env['action_controller.instance'] || MissingController.new
             @request    = ActionDispatch::Request.new(env)
             @backtrace  = exception.backtrace ? clean_backtrace(exception) : []
             @timestamp  = Time.current
             @sections   = @options[:sections]
             @data       = (env['exception_notifier.exception_data'] || {}).merge(options[:data] || {})
-            @sections   = @sections + %w(data) unless @data.empty?
+            @sections += %w[data] unless @data.empty?
 
             compose_email
           end
 
-          def background_exception_notification(exception, options={}, default_options={})
+          def background_exception_notification(exception, options = {}, default_options = {})
             load_custom_views
 
             @exception = exception
-            @options   = options.reverse_merge(default_options)
+            @options   = default_options.merge(options).symbolize_keys
             @backtrace = exception.backtrace || []
             @timestamp = Time.current
             @sections  = @options[:background_sections]
@@ -59,12 +74,17 @@ module ExceptionNotifier
           private
 
           def compose_subject
-            subject = "#{@options[:email_prefix]}"
-            subject << "#{@kontroller.controller_name}##{@kontroller.action_name}" if @kontroller
+            subject = @options[:email_prefix].to_s.dup
+            subject << "(#{@options[:accumulated_errors_count]} times)" if @options[:accumulated_errors_count].to_i > 1
+            subject << "#{@kontroller.controller_name} #{@kontroller.action_name}" if include_controller?
             subject << " (#{@exception.class})"
             subject << " #{@exception.message.inspect}" if @options[:verbose_subject]
             subject = EmailNotifier.normalize_digits(subject) if @options[:normalize_subject]
-            subject.length > 120 ? subject[0...120] + "..." : subject
+            subject.length > 120 ? subject[0...120] + '...' : subject
+          end
+
+          def include_controller?
+            @kontroller && @options[:include_controller_and_action_names_in_subject]
           end
 
           def set_data_variables
@@ -75,19 +95,23 @@ module ExceptionNotifier
 
           helper_method :inspect_object
 
+          def truncate(string, max)
+            string.length > max ? "#{string[0...max]}..." : string
+          end
+
           def inspect_object(object)
             case object
-              when Hash, Array
-                object.inspect
-              else
-                object.to_s
+            when Hash, Array
+              truncate(object.inspect, 300)
+            else
+              object.to_s
             end
           end
 
           helper_method :safe_encode
 
           def safe_encode(value)
-            value.encode("utf-8", invalid: :replace, undef: :replace, replace: "_")
+            value.encode('utf-8', invalid: :replace, undef: :replace, replace: '_')
           end
 
           def html_mail?
@@ -101,11 +125,11 @@ module ExceptionNotifier
             exception_recipients = maybe_call(@options[:exception_recipients])
 
             headers = {
-              :delivery_method => @options[:delivery_method],
-              :to => exception_recipients,
-              :from => @options[:sender_address],
-              :subject => subject,
-              :template_name => name
+              delivery_method: @options[:delivery_method],
+              to: exception_recipients,
+              from: @options[:sender_address],
+              subject: subject,
+              template_name: name
             }.merge(@options[:email_headers])
 
             mail = mail(headers) do |format|
@@ -119,9 +143,9 @@ module ExceptionNotifier
           end
 
           def load_custom_views
-            if defined?(Rails) && Rails.respond_to?(:root)
-              self.prepend_view_path Rails.root.nil? ? "app/views" : "#{Rails.root}/app/views"
-            end
+            return unless defined?(Rails) && Rails.respond_to?(:root)
+
+            prepend_view_path Rails.root.nil? ? 'app/views' : "#{Rails.root}/app/views"
           end
 
           def maybe_call(maybe_proc)
@@ -133,81 +157,48 @@ module ExceptionNotifier
 
     def initialize(options)
       super
+
       delivery_method = (options[:delivery_method] || :smtp)
       mailer_settings_key = "#{delivery_method}_settings".to_sym
       options[:mailer_settings] = options.delete(mailer_settings_key)
 
-      options.reverse_merge(EmailNotifier.default_options).select{|k,v|[
-        :sender_address, :exception_recipients,
-        :pre_callback, :post_callback,
-        :email_prefix, :email_format, :sections, :background_sections,
-        :verbose_subject, :normalize_subject, :delivery_method, :mailer_settings,
-        :email_headers, :mailer_parent, :template_path, :deliver_with].include?(k)}.each{|k,v| send("#{k}=", v)}
-    end
-
-    def options
-      @options ||= {}.tap do |opts|
-        self.instance_variables.each { |var| opts[var[1..-1].to_sym] = self.instance_variable_get(var) }
-      end
-    end
-
-    def mailer
-      @mailer ||= Class.new(mailer_parent.constantize).tap do |mailer|
-        mailer.extend(EmailNotifier::Mailer)
-        mailer.mailer_name = template_path
-      end
+      @base_options = DEFAULT_OPTIONS.merge(options)
     end
 
-    def call(exception, options={})
+    def call(exception, options = {})
       message = create_email(exception, options)
 
-      # FIXME: use `if Gem::Version.new(ActionMailer::VERSION::STRING) < Gem::Version.new('4.1')`
-      if deliver_with == :default
-        if message.respond_to?(:deliver_now)
-          message.deliver_now
-        else
-          message.deliver
-        end
-      else
-        message.send(deliver_with)
-      end
+      message.send(base_options[:deliver_with] || default_deliver_with(message))
     end
 
-    def create_email(exception, options={})
+    def create_email(exception, options = {})
       env = options[:env]
-      default_options = self.options
-      if env.nil?
-        send_notice(exception, options, nil, default_options) do |_, default_opts|
+
+      send_notice(exception, options, nil, base_options) do |_, default_opts|
+        if env.nil?
           mailer.background_exception_notification(exception, options, default_opts)
-        end
-      else
-        send_notice(exception, options, nil, default_options) do |_, default_opts|
+        else
           mailer.exception_notification(env, exception, options, default_opts)
         end
       end
     end
 
-    def self.default_options
-      {
-        :sender_address => %("Exception Notifier" <exception.notifier@example.com>),
-        :exception_recipients => [],
-        :email_prefix => "[ERROR] ",
-        :email_format => :text,
-        :sections => %w(request session environment backtrace),
-        :background_sections => %w(backtrace data),
-        :verbose_subject => true,
-        :normalize_subject => false,
-        :delivery_method => nil,
-        :mailer_settings => nil,
-        :email_headers => {},
-        :mailer_parent => 'ActionMailer::Base',
-        :template_path => 'exception_notifier',
-        :deliver_with => :default
-      }
-    end
-
     def self.normalize_digits(string)
       string.gsub(/[0-9]+/, 'N')
     end
+
+    private
+
+    def mailer
+      @mailer ||= Class.new(base_options[:mailer_parent].constantize).tap do |mailer|
+        mailer.extend(EmailNotifier::Mailer)
+        mailer.mailer_name = base_options[:template_path]
+      end
+    end
+
+    def default_deliver_with(message)
+      # FIXME: use `if Gem::Version.new(ActionMailer::VERSION::STRING) < Gem::Version.new('4.1')`
+      message.respond_to?(:deliver_now) ? :deliver_now : :deliver
+    end
   end
 end