exception_notification 4.2.0 → 4.4.1

data/lib/exception_notifier/views/exception_notifier/_backtrace.html.erb

@@ -1,3 +1,3 @@
 <pre style="font-size: 12px; padding: 10px; border: 1px solid #e1e1e8; background-color:#f5f5f5">
-<%= @backtrace.join("\n") %>
+  <%= @backtrace.join("\n") %>
 </pre>

data/lib/exception_notifier/views/exception_notifier/_environment.text.erb

@@ -1,5 +1,5 @@
 <% filtered_env = @request.filtered_env -%>
 <% max = filtered_env.keys.map(&:to_s).max { |a, b| a.length <=> b.length } -%>
 <% filtered_env.keys.map(&:to_s).sort.each do |key| -%>
-* <%= raw safe_encode("%-*s: %s" % [max.length, key, inspect_object(filtered_env[key])]) %>
+  * <%= raw safe_encode("%-*s: %s" % [max.length, key, inspect_object(filtered_env[key])]).strip %>
 <% end -%>

data/lib/exception_notifier/views/exception_notifier/_request.text.erb

@@ -5,6 +5,6 @@
 * Timestamp  : <%= raw @timestamp %>
 * Server : <%= raw Socket.gethostname %>
 <% if defined?(Rails) && Rails.respond_to?(:root) %>
-* Rails root : <%= raw Rails.root %>
+  * Rails root : <%= raw Rails.root %>
 <% end %>
 * Process: <%= raw $$ %>

data/lib/exception_notifier/views/exception_notifier/background_exception_notification.text.erb

@@ -3,12 +3,12 @@
   <%= @exception.message %>
   <%= @backtrace.first %>
 
-  <%  sections = @sections.map do |section|
-        summary = render(section).strip
-        unless summary.blank?
-          title = render("title", :title => section).strip
-          "#{title}\n\n#{summary.gsub(/^/, "  ")}\n\n"
-        end
-      end.join
-  %>
-  <%= raw sections %>
+<%  sections = @sections.map do |section|
+      summary = render(section).strip
+      unless summary.blank?
+        title = render("title", :title => section).strip
+        "#{title}\n\n#{summary.gsub(/^/, "  ")}\n\n"
+      end
+    end.join
+%>
+<%= raw sections %>

data/lib/exception_notifier/views/exception_notifier/exception_notification.html.erb

@@ -11,14 +11,12 @@
     begin
       summary = render(section).strip
       unless summary.blank?
-        title = render("title", :title => section).strip
+        title = render("title", title: section).strip
         [title, summary]
       end
-
     rescue Exception => e
-      title = render("title", :title => section).strip
+      title = render("title", title: section).strip
       summary = ["ERROR: Failed to generate exception summary:", [e.class.to_s, e.message].join(": "), e.backtrace && e.backtrace.join("\n")].compact.join("\n\n")
-
       [title, summary]
     end
   end

data/lib/exception_notifier/views/exception_notifier/exception_notification.text.erb

@@ -8,12 +8,12 @@
       begin
         summary = render(section).strip
         unless summary.blank?
-          title = render("title", :title => section).strip
+          title = render("title", title: section).strip
           "#{title}\n\n#{summary.gsub(/^/, "  ")}\n\n"
         end
 
       rescue Exception => e
-        title = render("title", :title => section).strip
+        title = render("title", title: section).strip
         summary = ["ERROR: Failed to generate exception summary:", [e.class.to_s, e.message].join(": "), e.backtrace && e.backtrace.join("\n")].compact.join("\n\n")
 
         [title, summary.gsub(/^/, "  "), nil].join("\n\n")

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,30 +19,32 @@ 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
         options[:body][:environment] = request.filtered_env
       end
-      send_notice(exception, options, nil, @default_options) do |msg, opts|
-        HTTParty.send(http_method, url, opts)
+      send_notice(exception, options, nil, @default_options) do |_, _|
+        HTTParty.send(http_method, url, options)
       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}

@@ -13,7 +13,7 @@ Resque::Failure.backend = Resque::Failure::Multiple
 
 ExceptionNotification.configure do |config|
   # Ignore additional exception types.
-  # ActiveRecord::RecordNotFound, AbstractController::ActionNotFound and ActionController::RoutingError are already added.
+  # ActiveRecord::RecordNotFound, Mongoid::Errors::DocumentNotFound, AbstractController::ActionNotFound and ActionController::RoutingError are already added.
   # config.ignored_exceptions += %w{ActionView::TemplateError CustomError}
 
   # Adds a condition to decide when an exception must be ignored or not.
@@ -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,20 +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])
   end
 
-  test "should ignore \"X-Cascade\" header by default" do
+  teardown do
+    ExceptionNotifier.reset_notifiers!
+  end
+
+  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
+    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
+    assert_nil ExceptionNotifier.notification_trigger
+    ExceptionNotification::Rack.new(@normal_app, notification_trigger: ->(_i) { true }).call({})
+    assert_respond_to ExceptionNotifier.notification_trigger, :call
+  end
+
+  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/campfire_notifier_test.rb

@@ -1,44 +1,51 @@
+# frozen_string_literal: true
+
 require 'test_helper'
-require 'tinder'
 
-class CampfireNotifierTest < ActiveSupport::TestCase
+# silence_warnings trick around require can be removed once
+# https://github.com/collectiveidea/tinder/pull/77
+# gets merged and released
+silence_warnings do
+  require 'tinder'
+end
 
-  test "should send campfire notification if properly configured" do
+class CampfireNotifierTest < ActiveSupport::TestCase
+  test 'should send campfire notification if properly configured' do
     ExceptionNotifier::CampfireNotifier.stubs(:new).returns(Object.new)
-    campfire = ExceptionNotifier::CampfireNotifier.new({:subdomain => 'test', :token => 'test_token', :room_name => 'test_room'})
+    campfire = ExceptionNotifier::CampfireNotifier.new(subdomain: 'test', token: 'test_token', room_name: 'test_room')
     campfire.stubs(:call).returns(fake_notification)
     notif = campfire.call(fake_exception)
 
     assert !notif[:message].empty?
     assert_equal notif[:message][:type], 'PasteMessage'
-    assert_includes notif[:message][:body], "A new exception occurred:"
-    assert_includes notif[:message][:body], "divided by 0"
-    assert_includes notif[:message][:body], "/exception_notification/test/campfire_test.rb:45"
+    assert_includes notif[:message][:body], 'A new exception occurred:'
+    assert_includes notif[:message][:body], 'divided by 0'
+    assert_includes notif[:message][:body], '/exception_notification/test/campfire_test.rb:45'
   end
 
-  test "should send campfire notification without backtrace info if properly configured" do
+  test 'should send campfire notification without backtrace info if properly configured' do
     ExceptionNotifier::CampfireNotifier.stubs(:new).returns(Object.new)
-    campfire = ExceptionNotifier::CampfireNotifier.new({:subdomain => 'test', :token => 'test_token', :room_name => 'test_room'})
+    campfire = ExceptionNotifier::CampfireNotifier.new(subdomain: 'test', token: 'test_token', room_name: 'test_room')
     campfire.stubs(:call).returns(fake_notification_without_backtrace)
     notif = campfire.call(fake_exception_without_backtrace)
 
     assert !notif[:message].empty?
     assert_equal notif[:message][:type], 'PasteMessage'
-    assert_includes notif[:message][:body], "A new exception occurred:"
-    assert_includes notif[:message][:body], "my custom error"
+    assert_includes notif[:message][:body], 'A new exception occurred:'
+    assert_includes notif[:message][:body], 'my custom error'
   end
 
-  test "should not send campfire notification if badly configured" do
-    wrong_params = {:subdomain => 'test', :token => 'bad_token', :room_name => 'test_room'}
-    Tinder::Campfire.stubs(:new).with('test', {:token => 'bad_token'}).returns(nil)
+  test 'should not send campfire notification if badly configured' do
+    wrong_params = { subdomain: 'test', token: 'bad_token', room_name: 'test_room' }
+    Tinder::Campfire.stubs(:new).with('test', token: 'bad_token').returns(nil)
     campfire = ExceptionNotifier::CampfireNotifier.new(wrong_params)
 
     assert_nil campfire.room
     assert_nil campfire.call(fake_exception)
   end
 
-  test "should not send campfire notification if config attr missing" do
-    wrong_params  = {:subdomain => 'test', :room_name => 'test_room'}
+  test 'should not send campfire notification if config attr missing' do
+    wrong_params = { subdomain: 'test', room_name: 'test_room' }
     Tinder::Campfire.stubs(:new).with('test', {}).returns(nil)
     campfire = ExceptionNotifier::CampfireNotifier.new(wrong_params)
 
@@ -46,21 +53,34 @@ class CampfireNotifierTest < ActiveSupport::TestCase
     assert_nil campfire.call(fake_exception)
   end
 
-  test "should call pre/post_callback if specified" do 
-    pre_callback_called, post_callback_called = 0,0
+  test 'should send the new exception message if no :accumulated_errors_count option' do
+    campfire = ExceptionNotifier::CampfireNotifier.new({})
+    campfire.stubs(:active?).returns(true)
+    campfire.expects(:send_notice).with { |_, _, message| message.start_with?('A new exception occurred') }.once
+    campfire.call(fake_exception)
+  end
+
+  test 'shoud send the exception message if :accumulated_errors_count option greater than 1' do
+    campfire = ExceptionNotifier::CampfireNotifier.new({})
+    campfire.stubs(:active?).returns(true)
+    campfire.expects(:send_notice).with { |_, _, message| message.start_with?('The exception occurred 3 times:') }.once
+    campfire.call(fake_exception, accumulated_errors_count: 3)
+  end
+
+  test 'should call pre/post_callback if specified' do
+    pre_callback_called = 0
+    post_callback_called = 0
     Tinder::Campfire.stubs(:new).returns(Object.new)
 
     campfire = ExceptionNotifier::CampfireNotifier.new(
-      {
-        :subdomain => 'test',
-        :token => 'test_token',
-        :room_name => 'test_room',
-        :pre_callback => proc { |opts, notifier, backtrace, message, message_opts|
-          pre_callback_called += 1
-        },
-        :post_callback => proc { |opts, notifier, backtrace, message, message_opts|
-          post_callback_called += 1
-        }
+      subdomain: 'test',
+      token: 'test_token',
+      room_name: 'test_room',
+      pre_callback: proc { |_opts, _notifier, _backtrace, _message, _message_opts|
+        pre_callback_called += 1
+      },
+      post_callback: proc { |_opts, _notifier, _backtrace, _message, _message_opts|
+        post_callback_called += 1
       }
     )
     campfire.room = Object.new
@@ -73,24 +93,31 @@ class CampfireNotifierTest < ActiveSupport::TestCase
   private
 
   def fake_notification
-    {:message => {:type => 'PasteMessage',
-                  :body => "A new exception occurred: 'divided by 0' on '/Users/sebastian/exception_notification/test/campfire_test.rb:45:in `/'"
-                 }
+    {
+      message: {
+        type: 'PasteMessage',
+        body: fake_notification_body
+      }
     }
   end
 
+  def fake_notification_body
+    "A new exception occurred: 'divided by 0' on " \
+    "/Users/sebastian/exception_notification/test/campfire_test.rb:45:in `/'"
+  end
+
   def fake_exception
-    exception = begin
-      5/0
-    rescue Exception => e
-      e
-    end
+    5 / 0
+  rescue StandardError => e
+    e
   end
 
   def fake_notification_without_backtrace
-    {:message => {:type => 'PasteMessage',
-                  :body => "A new exception occurred: 'my custom error'"
-                 }
+    {
+      message: {
+        type: 'PasteMessage',
+        body: "A new exception occurred: 'my custom error'"
+      }
     }
   end