exception_notification 4.3.0 → 4.5.0

data/lib/exception_notifier/webhook_notifier.rb

@@ -1,15 +1,16 @@
+# frozen_string_literal: true
+
 require 'action_dispatch'
 require 'active_support/core_ext/time'
 
 module ExceptionNotifier
   class WebhookNotifier < BaseNotifier
-
     def initialize(options)
       super
       @default_options = options
     end
 
-    def call(exception, options={})
+    def call(exception, options = {})
       env = options[:env]
 
       options = options.reverse_merge(@default_options)
@@ -18,23 +19,25 @@ module ExceptionNotifier
 
       options[:body] ||= {}
       options[:body][:server] = Socket.gethostname
-      options[:body][:process] = $$
-      if defined?(Rails) && Rails.respond_to?(:root)
-        options[:body][:rails_root] = Rails.root
-      end
-      options[:body][:exception] = {:error_class => exception.class.to_s,
-                                    :message => exception.message.inspect,
-                                    :backtrace => exception.backtrace}
+      options[:body][:process] = $PROCESS_ID
+      options[:body][:rails_root] = Rails.root if defined?(Rails) && Rails.respond_to?(:root)
+      options[:body][:exception] = {
+        error_class: exception.class.to_s,
+        message: exception.message.inspect,
+        backtrace: exception.backtrace
+      }
       options[:body][:data] = (env && env['exception_notifier.exception_data'] || {}).merge(options[:data] || {})
 
       unless env.nil?
         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 }
+        request_items = {
+          url: request.original_url,
+          http_method: request.method,
+          ip_address: request.remote_ip,
+          parameters: request.filtered_parameters,
+          timestamp: Time.current
+        }
 
         options[:body][:request] = request_items
         options[:body][:session] = request.session

data/lib/exception_notifier.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'logger'
 require 'active_support/core_ext/string/inflections'
 require 'active_support/core_ext/module/attribute_accessors'
@@ -8,10 +10,10 @@ 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'
-  autoload :CampfireNotifier, 'exception_notifier/campfire_notifier'
   autoload :HipchatNotifier, 'exception_notifier/hipchat_notifier'
   autoload :WebhookNotifier, 'exception_notifier/webhook_notifier'
   autoload :IrcNotifier, 'exception_notifier/irc_notifier'
@@ -20,6 +22,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 +32,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
@@ -38,6 +44,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 = {}
 
@@ -45,19 +54,25 @@ 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)
       end
 
+      notification_fired = false
       selected_notifiers = options.delete(:notifiers) || notifiers
       [*selected_notifiers].each do |notifier|
-        fire_notification(notifier, exception, options.dup, &block)
+        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)
@@ -92,23 +107,52 @@ 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)
       all_ignored_exceptions = (Array(ignored_exceptions) + Array(ignore_array)).map(&:to_s)
-      exception_ancestors = exception.class.ancestors.map(&:to_s)
+      exception_ancestors = exception.singleton_class.ancestors.map(&:to_s)
       !(all_ignored_exceptions & exception_ancestors).empty?
     end
 
@@ -118,7 +162,10 @@ module ExceptionNotifier
     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
 
@@ -128,7 +175,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/generators/exception_notification/install_generator.rb

@@ -1,14 +1,20 @@
+# frozen_string_literal: true
+
 module ExceptionNotification
   module Generators
     class InstallGenerator < Rails::Generators::Base
-      desc "Creates a ExceptionNotification initializer."
+      desc 'Creates a ExceptionNotification initializer.'
 
-      source_root File.expand_path('../templates', __FILE__)
-      class_option :resque, :type => :boolean, :desc => 'Add support for sending notifications when errors occur in Resque jobs.'
-      class_option :sidekiq, :type => :boolean, :desc => 'Add support for sending notifications when errors occur in Sidekiq jobs.'
+      source_root File.expand_path('templates', __dir__)
+      class_option :resque,
+                   type: :boolean,
+                   desc: 'Add support for sending notifications when errors occur in Resque jobs.'
+      class_option :sidekiq,
+                   type: :boolean,
+                   desc: 'Add support for sending notifications when errors occur in Sidekiq jobs.'
 
       def copy_initializer
-        template 'exception_notification.rb', 'config/initializers/exception_notification.rb'
+        template 'exception_notification.rb.erb', 'config/initializers/exception_notification.rb'
       end
     end
   end

data/lib/generators/exception_notification/templates/{exception_notification.rb → exception_notification.rb.erb}

@@ -22,32 +22,34 @@ ExceptionNotification.configure do |config|
   #   not Rails.env.production?
   # end
 
+  # Ignore exceptions generated by crawlers
+  # config.ignore_crawlers %w{Googlebot bingbot}
+
   # Notifiers =================================================================
 
   # Email notifier sends notifications by email.
   config.add_notifier :email, {
-    :email_prefix         => "[ERROR] ",
-    :sender_address       => %{"Notifier" <notifier@example.com>},
-    :exception_recipients => %w{exceptions@example.com}
+    email_prefix: '[ERROR] ',
+    sender_address: %{"Notifier" <notifier@example.com>},
+    exception_recipients: %w{exceptions@example.com}
   }
 
   # Campfire notifier sends notifications to your Campfire room. Requires 'tinder' gem.
   # config.add_notifier :campfire, {
-  #   :subdomain => 'my_subdomain',
-  #   :token => 'my_token',
-  #   :room_name => 'my_room'
+  #   subdomain: 'my_subdomain',
+  #   token: 'my_token',
+  #   room_name: 'my_room'
   # }
 
   # HipChat notifier sends notifications to your HipChat room. Requires 'hipchat' gem.
   # config.add_notifier :hipchat, {
-  #   :api_token => 'my_token',
-  #   :room_name => 'my_room'
+  #   api_token: 'my_token',
+  #   room_name: 'my_room'
   # }
 
   # Webhook notifier sends notifications over HTTP protocol. Requires 'httparty' gem.
   # config.add_notifier :webhook, {
-  #   :url => 'http://example.com:5555/hubot/path',
-  #   :http_method => :post
+  #   url: 'http://example.com:5555/hubot/path',
+  #   http_method: :post
   # }
-
 end

data/test/exception_notification/rack_test.rb

@@ -1,44 +1,106 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class RackTest < ActiveSupport::TestCase
-
   setup do
     @pass_app = Object.new
     @pass_app.stubs(:call).returns([nil, { 'X-Cascade' => 'pass' }, nil])
 
     @normal_app = Object.new
-    @normal_app.stubs(:call).returns([nil, { }, nil])
+    @normal_app.stubs(:call).returns([nil, {}, nil])
   end
 
   teardown do
-    ExceptionNotifier.error_grouping = false
-    ExceptionNotifier.notification_trigger = nil
+    ExceptionNotifier.reset_notifiers!
   end
 
-  test "should ignore \"X-Cascade\" header by default" do
+  test 'should ignore "X-Cascade" header by default' do
     ExceptionNotifier.expects(:notify_exception).never
     ExceptionNotification::Rack.new(@pass_app).call({})
   end
 
-  test "should notify on \"X-Cascade\" = \"pass\" if ignore_cascade_pass option is false" do
+  test 'should notify on "X-Cascade" = "pass" if ignore_cascade_pass option is false' do
     ExceptionNotifier.expects(:notify_exception).once
-    ExceptionNotification::Rack.new(@pass_app, :ignore_cascade_pass => false).call({})
+    ExceptionNotification::Rack.new(@pass_app, ignore_cascade_pass: false).call({})
   end
 
-  test "should assign error_grouping if error_grouping is specified" do
+  test 'should assign error_grouping if error_grouping is specified' do
     refute ExceptionNotifier.error_grouping
     ExceptionNotification::Rack.new(@normal_app, error_grouping: true).call({})
     assert ExceptionNotifier.error_grouping
   end
 
-  test "should assign notification_trigger if notification_trigger is specified" do
+  test 'should assign notification_trigger if notification_trigger is specified' do
     assert_nil ExceptionNotifier.notification_trigger
-    ExceptionNotification::Rack.new(@normal_app, notification_trigger: lambda {|i| true}).call({})
+    ExceptionNotification::Rack.new(@normal_app, notification_trigger: ->(_i) { true }).call({})
     assert_respond_to ExceptionNotifier.notification_trigger, :call
   end
 
-  test "should set default cache to Rails cache" do
-    ExceptionNotification::Rack.new(@normal_app, error_grouping: true).call({})
-    assert_equal Rails.cache, ExceptionNotifier.error_grouping_cache
+  if defined?(Rails) && Rails.respond_to?(:cache)
+    test 'should set default cache to Rails cache' do
+      ExceptionNotification::Rack.new(@normal_app, error_grouping: true).call({})
+      assert_equal Rails.cache, ExceptionNotifier.error_grouping_cache
+    end
+  end
+
+  test 'should ignore exceptions with Usar Agent in ignore_crawlers' do
+    exception_app = Object.new
+    exception_app.stubs(:call).raises(RuntimeError)
+
+    env = { 'HTTP_USER_AGENT' => 'Mozilla/5.0 (compatible; Crawlerbot/2.1;)' }
+
+    begin
+      ExceptionNotification::Rack.new(exception_app, ignore_crawlers: %w[Crawlerbot]).call(env)
+
+      flunk
+    rescue StandardError
+      refute env['exception_notifier.delivered']
+    end
+  end
+
+  test 'should ignore exceptions if ignore_if condition is met' do
+    exception_app = Object.new
+    exception_app.stubs(:call).raises(RuntimeError)
+
+    env = {}
+
+    begin
+      ExceptionNotification::Rack.new(
+        exception_app,
+        ignore_if: ->(_env, exception) { exception.is_a? RuntimeError }
+      ).call(env)
+
+      flunk
+    rescue StandardError
+      refute env['exception_notifier.delivered']
+    end
+  end
+
+  test 'should ignore exceptions with notifiers that satisfies ignore_notifier_if condition' do
+    exception_app = Object.new
+    exception_app.stubs(:call).raises(RuntimeError)
+
+    notifier1_called = notifier2_called = false
+    notifier1 = ->(_exception, _options) { notifier1_called = true }
+    notifier2 = ->(_exception, _options) { notifier2_called = true }
+
+    env = {}
+
+    begin
+      ExceptionNotification::Rack.new(
+        exception_app,
+        ignore_notifier_if: {
+          notifier1: ->(_env, exception) { exception.is_a? RuntimeError }
+        },
+        notifier1: notifier1,
+        notifier2: notifier2
+      ).call(env)
+
+      flunk
+    rescue StandardError
+      refute notifier1_called
+      assert notifier2_called
+    end
   end
 end

data/test/exception_notification/resque_test.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+require 'exception_notification/resque'
+require 'resque'
+require 'mock_redis'
+require 'resque/failure/multiple'
+require 'resque/failure/redis'
+
+class ResqueTest < ActiveSupport::TestCase
+  setup do
+    # Resque.redis=() only supports a String or Redis instance in Resque 1.8
+    Resque.instance_variable_set(:@redis, MockRedis.new)
+
+    Resque::Failure::Multiple.classes = [Resque::Failure::Redis, ExceptionNotification::Resque]
+    Resque::Failure.backend = Resque::Failure::Multiple
+
+    @worker = Resque::Worker.new(:jobs)
+    # Forking causes issues with Mocha's `.expects`
+    @worker.cant_fork = true
+  end
+
+  test 'count returns the number of failures' do
+    Resque::Job.create(:jobs, BadJob)
+    @worker.work(0)
+    assert_equal 1, ExceptionNotification::Resque.count
+  end
+
+  test 'notifies exception when job fails' do
+    ExceptionNotifier.expects(:notify_exception).with do |ex, opts|
+      ex.is_a?(RuntimeError) &&
+        ex.message == 'Bad job!' &&
+        opts[:data][:resque][:error_class] == 'RuntimeError' &&
+        opts[:data][:resque][:error_message] == 'Bad job!' &&
+        opts[:data][:resque][:failed_at].present? &&
+        opts[:data][:resque][:payload] == {
+          'class' => 'ResqueTest::BadJob',
+          'args' => []
+        } &&
+        opts[:data][:resque][:queue] == :jobs &&
+        opts[:data][:resque][:worker].present?
+    end
+
+    Resque::Job.create(:jobs, BadJob)
+    @worker.work(0)
+  end
+
+  class BadJob
+    def self.perform
+      raise 'Bad job!'
+    end
+  end
+end

data/test/exception_notifier/datadog_notifier_test.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'dogapi/common'
+require 'dogapi/event'
+
+class DatadogNotifierTest < ActiveSupport::TestCase
+  def setup
+    @client = FakeDatadogClient.new
+    @options = {
+      client: @client
+    }
+    @notifier = ExceptionNotifier::DatadogNotifier.new(@options)
+    @exception = FakeException.new
+    @controller = FakeController.new
+    @request = FakeRequest.new
+  end
+
+  test 'should send an event to datadog' do
+    fake_event = Dogapi::Event.any_instance
+    @client.expects(:emit_event).with(fake_event)
+
+    @notifier.stubs(:datadog_event).returns(fake_event)
+    @notifier.call(@exception)
+  end
+
+  test 'should include exception class in event title' do
+    event = @notifier.datadog_event(@exception)
+    assert_includes event.msg_title, 'FakeException'
+  end
+
+  test 'should include prefix in event title and not append previous events' do
+    options = {
+      client: @client,
+      title_prefix: 'prefix'
+    }
+
+    notifier = ExceptionNotifier::DatadogNotifier.new(options)
+    event = notifier.datadog_event(@exception)
+    assert_equal event.msg_title, 'prefix (DatadogNotifierTest::FakeException) "Fake exception message"'
+
+    event2 = notifier.datadog_event(@exception)
+    assert_equal event2.msg_title, 'prefix (DatadogNotifierTest::FakeException) "Fake exception message"'
+  end
+
+  test 'should include exception message in event title' do
+    event = @notifier.datadog_event(@exception)
+    assert_includes event.msg_title, 'Fake exception message'
+  end
+
+  test 'should include controller info in event title if controller information is available' do
+    event = @notifier.datadog_event(@exception,
+                                    env: {
+                                      'action_controller.instance' => @controller,
+                                      'REQUEST_METHOD' => 'GET',
+                                      'rack.input' => ''
+                                    })
+    assert_includes event.msg_title, 'Fake controller'
+    assert_includes event.msg_title, 'Fake action'
+  end
+
+  test 'should include backtrace info in event body' do
+    event = @notifier.datadog_event(@exception)
+    assert_includes event.msg_text, "backtrace line 1\nbacktrace line 2\nbacktrace line 3"
+  end
+
+  test 'should include request info in event body' do
+    ActionDispatch::Request.stubs(:new).returns(@request)
+
+    event = @notifier.datadog_event(@exception,
+                                    env: {
+                                      'action_controller.instance' => @controller,
+                                      'REQUEST_METHOD' => 'GET',
+                                      'rack.input' => ''
+                                    })
+    assert_includes event.msg_text, 'http://localhost:8080'
+    assert_includes event.msg_text, 'GET'
+    assert_includes event.msg_text, '127.0.0.1'
+    assert_includes event.msg_text, '{"param 1"=>"value 1", "param 2"=>"value 2"}'
+  end
+
+  test 'should include tags in event' do
+    options = {
+      client: @client,
+      tags: %w[error production]
+    }
+    notifier = ExceptionNotifier::DatadogNotifier.new(options)
+    event = notifier.datadog_event(@exception)
+    assert_equal event.tags, %w[error production]
+  end
+
+  test 'should include event title in event aggregation key' do
+    event = @notifier.datadog_event(@exception)
+    assert_equal event.aggregation_key, [event.msg_title]
+  end
+
+  class FakeDatadogClient
+    def emit_event(event); end
+  end
+
+  class FakeController
+    def controller_name
+      'Fake controller'
+    end
+
+    def action_name
+      'Fake action'
+    end
+  end
+
+  class FakeException
+    def backtrace
+      [
+        'backtrace line 1',
+        'backtrace line 2',
+        'backtrace line 3',
+        'backtrace line 4',
+        'backtrace line 5'
+      ]
+    end
+
+    def message
+      'Fake exception message'
+    end
+  end
+
+  class FakeRequest
+    def url
+      'http://localhost:8080'
+    end
+
+    def request_method
+      'GET'
+    end
+
+    def remote_ip
+      '127.0.0.1'
+    end
+
+    def filtered_parameters
+      {
+        'param 1' => 'value 1',
+        'param 2' => 'value 2'
+      }
+    end
+
+    def session
+      {
+        'session_id' => '1234'
+      }
+    end
+  end
+end