exception_notification 4.3.0 → 4.4.0

data/lib/exception_notification/version.rb

@@ -0,0 +1,3 @@
+module ExceptionNotification
+  VERSION = '4.4.0'.freeze
+end

data/lib/exception_notifier.rb

@@ -8,6 +8,7 @@ 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'
@@ -20,6 +21,7 @@ module ExceptionNotifier
   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
 
@@ -29,7 +31,7 @@ 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
@@ -45,9 +47,10 @@ module ExceptionNotifier
       self.testing_mode = true
     end
 
-    def notify_exception(exception, options={}, &block)
+    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)
@@ -92,13 +95,20 @@ module ExceptionNotifier
       @@ignores << 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
     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
 
@@ -130,5 +140,12 @@ module ExceptionNotifier
     rescue NameError => e
       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

@@ -2,11 +2,11 @@ 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)
@@ -20,6 +20,5 @@ module ExceptionNotifier
     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
-
   end
 end

data/lib/exception_notifier/campfire_notifier.rb

@@ -1,6 +1,5 @@
 module ExceptionNotifier
   class CampfireNotifier < BaseNotifier
-
     attr_accessor :subdomain
     attr_accessor :token
     attr_accessor :room
@@ -12,22 +11,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 = 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
+    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,153 @@
+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'.freeze
+
+      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 << title_prefix
+        title << "#{controller.controller_name} #{controller.action_name}" if controller
+        title << " (#{exception.class})"
+        title << " #{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)
+        if defined?(Rails) && Rails.respond_to?(:root)
+          text << formatted_key_value('Rails root', Rails.root)
+        end
+        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
+    end
+  end
+end

data/lib/exception_notifier/email_notifier.rb

@@ -1,4 +1,3 @@
-require "active_support/core_ext/hash/reverse_merge"
 require 'active_support/core_ext/time'
 require 'action_mailer'
 require 'action_dispatch'
@@ -6,47 +5,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, :include_controller_and_action_names_in_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).symbolize_keys
+            @options   = default_options.merge(options).symbolize_keys
             @backtrace = exception.backtrace || []
             @timestamp = Time.current
             @sections  = @options[:background_sections]
@@ -59,13 +72,13 @@ module ExceptionNotifier
           private
 
           def compose_subject
-            subject = "#{@options[:email_prefix]}"
+            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 @kontroller && @options[:include_controller_and_action_names_in_subject]
             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 set_data_variables
@@ -82,17 +95,17 @@ module ExceptionNotifier
 
           def inspect_object(object)
             case object
-              when Hash, Array
-                truncate(object.inspect, 300)
-              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?
@@ -106,11 +119,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|
@@ -124,9 +137,7 @@ 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
+            prepend_view_path Rails.root.nil? ? 'app/views' : "#{Rails.root}/app/views" if defined?(Rails) && Rails.respond_to?(:root)
           end
 
           def maybe_call(maybe_proc)
@@ -138,82 +149,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,
-        :include_controller_and_action_names_in_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,
-        :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 => :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