exception_notification 4.2.0 → 4.4.1

data/test/exception_notifier/modules/error_grouping_test.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class ErrorGroupTest < ActiveSupport::TestCase
+  setup do
+    module TestModule
+      include ExceptionNotifier::ErrorGrouping
+      @@error_grouping_cache = ActiveSupport::Cache::FileStore.new('test/dummy/tmp/non_default_location')
+    end
+
+    @exception = RuntimeError.new('ERROR')
+    @exception.stubs(:backtrace).returns(['/path/where/error/raised:1'])
+
+    @exception2 = RuntimeError.new('ERROR2')
+    @exception2.stubs(:backtrace).returns(['/path/where/error/found:2'])
+  end
+
+  teardown do
+    TestModule.error_grouping_cache.clear
+    TestModule.fallback_cache_store.clear
+  end
+
+  test 'should add additional option: error_grouping' do
+    assert_respond_to TestModule, :error_grouping
+    assert_respond_to TestModule, :error_grouping=
+  end
+
+  test 'should set error_grouping to false default' do
+    assert_equal false, TestModule.error_grouping
+  end
+
+  test 'should add additional option: error_grouping_cache' do
+    assert_respond_to TestModule, :error_grouping_cache
+    assert_respond_to TestModule, :error_grouping_cache=
+  end
+
+  test 'should add additional option: error_grouping_period' do
+    assert_respond_to TestModule, :error_grouping_period
+    assert_respond_to TestModule, :error_grouping_period=
+  end
+
+  test 'shoud set error_grouping_period to 5.minutes default' do
+    assert_equal 300, TestModule.error_grouping_period
+  end
+
+  test 'should add additional option: notification_trigger' do
+    assert_respond_to TestModule, :notification_trigger
+    assert_respond_to TestModule, :notification_trigger=
+  end
+
+  test 'should return errors count nil when not same error for .error_count' do
+    assert_nil TestModule.error_count('something')
+  end
+
+  test 'should return errors count when same error for .error_count' do
+    TestModule.error_grouping_cache.write('error_key', 13)
+    assert_equal 13, TestModule.error_count('error_key')
+  end
+
+  test 'should fallback to memory store cache if specified cache store failed to read' do
+    TestModule.error_grouping_cache.stubs(:read).raises(RuntimeError.new('Failed to read'))
+    original_fallback = TestModule.fallback_cache_store
+    TestModule.expects(:fallback_cache_store).returns(original_fallback).at_least_once
+
+    assert_nil TestModule.error_count('something_to_read')
+  end
+
+  test 'should save error with count for .save_error_count' do
+    count = rand(1..10)
+
+    TestModule.save_error_count('error_key', count)
+    assert_equal count, TestModule.error_grouping_cache.read('error_key')
+  end
+
+  test 'should fallback to memory store cache if specified cache store failed to write' do
+    TestModule.error_grouping_cache.stubs(:write).raises(RuntimeError.new('Failed to write'))
+    original_fallback = TestModule.fallback_cache_store
+    TestModule.expects(:fallback_cache_store).returns(original_fallback).at_least_once
+
+    assert TestModule.save_error_count('something_to_cache', rand(1..10))
+  end
+
+  test 'should save accumulated_errors_count into options' do
+    options = {}
+    TestModule.group_error!(@exception, options)
+
+    assert_equal 1, options[:accumulated_errors_count]
+  end
+
+  test 'should not group error if different exception in .group_error!' do
+    options1 = {}
+    TestModule.expects(:save_error_count).with { |key, count| key.is_a?(String) && count == 1 }.times(4).returns(true)
+    TestModule.group_error!(@exception, options1)
+
+    options2 = {}
+    TestModule.group_error!(NoMethodError.new('method not found'), options2)
+
+    assert_equal 1, options1[:accumulated_errors_count]
+    assert_equal 1, options2[:accumulated_errors_count]
+  end
+
+  test 'should not group error is same exception but different message or backtrace' do
+    options1 = {}
+    TestModule.expects(:save_error_count).with { |key, count| key.is_a?(String) && count == 1 }.times(4).returns(true)
+    TestModule.group_error!(@exception, options1)
+
+    options2 = {}
+    TestModule.group_error!(@exception2, options2)
+
+    assert_equal 1, options1[:accumulated_errors_count]
+    assert_equal 1, options2[:accumulated_errors_count]
+  end
+
+  test 'should group error if same exception and message' do
+    options = {}
+
+    10.times do |i|
+      @exception2.stubs(:backtrace).returns(["/path:#{i}"])
+      TestModule.group_error!(@exception2, options)
+    end
+
+    assert_equal 10, options[:accumulated_errors_count]
+  end
+
+  test 'should group error if same exception and backtrace' do
+    options = {}
+
+    10.times do |i|
+      @exception2.stubs(:message).returns("ERRORS#{i}")
+      TestModule.group_error!(@exception2, options)
+    end
+
+    assert_equal 10, options[:accumulated_errors_count]
+  end
+
+  test 'should group error by that message have high priority' do
+    message_based_key = "exception:#{Zlib.crc32("RuntimeError\nmessage:ERROR")}"
+    backtrace_based_key = "exception:#{Zlib.crc32("RuntimeError\npath:/path/where/error/raised:1")}"
+
+    TestModule.save_error_count(message_based_key, 1)
+    TestModule.save_error_count(backtrace_based_key, 1)
+
+    TestModule.expects(:save_error_count).with(message_based_key, 2).once
+    TestModule.expects(:save_error_count).with(backtrace_based_key, 2).never
+
+    TestModule.group_error!(@exception, {})
+  end
+
+  test 'use default formula if not specify notification_trigger in .send_notification?' do
+    TestModule.stubs(:notification_trigger).returns(nil)
+
+    count = 16
+    Math.expects(:log2).with(count).returns(4)
+
+    assert TestModule.send_notification?(@exception, count)
+  end
+
+  test 'use specified trigger in .send_notification?' do
+    trigger = proc { |_exception, count| (count % 4).zero? }
+    TestModule.stubs(:notification_trigger).returns(trigger)
+
+    count = 16
+    trigger.expects(:call).with(@exception, count).returns(true)
+    assert TestModule.send_notification?(@exception, count)
+  end
+end

data/test/exception_notifier/modules/formatter_test.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'timecop'
+
+class FormatterTest < ActiveSupport::TestCase
+  setup do
+    @exception = RuntimeError.new('test')
+    Timecop.freeze('2018-12-09 12:07:16 UTC')
+  end
+
+  teardown do
+    Timecop.return
+  end
+
+  #
+  # #title
+  #
+  test 'title returns correct content' do
+    formatter = ExceptionNotifier::Formatter.new(@exception)
+
+    title = if defined?(::Rails) && ::Rails.respond_to?(:env)
+              '⚠️ Error occurred in test ⚠️'
+            else
+              '⚠️ Error occurred ⚠️'
+            end
+
+    assert_equal title, formatter.title
+  end
+
+  #
+  # #subtitle
+  #
+  test 'subtitle without accumulated error' do
+    formatter = ExceptionNotifier::Formatter.new(@exception)
+    assert_equal 'A *RuntimeError* occurred.', formatter.subtitle
+  end
+
+  test 'subtitle with accumulated error' do
+    formatter = ExceptionNotifier::Formatter.new(@exception, accumulated_errors_count: 3)
+    assert_equal '3 *RuntimeError* occurred.', formatter.subtitle
+  end
+
+  test 'subtitle with controller' do
+    env = Rack::MockRequest.env_for(
+      '/', 'action_controller.instance' => test_controller
+    )
+
+    formatter = ExceptionNotifier::Formatter.new(@exception, env: env)
+    assert_equal 'A *RuntimeError* occurred in *home#index*.', formatter.subtitle
+  end
+
+  #
+  # #app_name
+  #
+  test 'app_name defaults to Rails app name' do
+    formatter = ExceptionNotifier::Formatter.new(@exception)
+
+    if defined?(::Rails) && ::Rails.respond_to?(:application)
+      assert_equal 'dummy', formatter.app_name
+    else
+      assert_nil formatter.app_name
+    end
+  end
+
+  test 'app_name can be overwritten using options' do
+    formatter = ExceptionNotifier::Formatter.new(@exception, app_name: 'test')
+    assert_equal 'test', formatter.app_name
+  end
+
+  #
+  # #request_message
+  #
+  test 'request_message when env set' do
+    text = [
+      '```',
+      '* url : http://test.address/?id=foo',
+      '* http_method : GET',
+      '* ip_address : 127.0.0.1',
+      '* parameters : {"id"=>"foo"}',
+      '* timestamp : 2018-12-09 12:07:16 UTC',
+      '```'
+    ].join("\n")
+
+    env = Rack::MockRequest.env_for(
+      '/',
+      'HTTP_HOST' => 'test.address',
+      'REMOTE_ADDR' => '127.0.0.1',
+      params: { id: 'foo' }
+    )
+
+    formatter = ExceptionNotifier::Formatter.new(@exception, env: env)
+    assert_equal text, formatter.request_message
+  end
+
+  test 'request_message when env not set' do
+    formatter = ExceptionNotifier::Formatter.new(@exception)
+    assert_nil formatter.request_message
+  end
+
+  #
+  # #backtrace_message
+  #
+  test 'backtrace_message when backtrace set' do
+    text = [
+      '```',
+      "* app/controllers/my_controller.rb:53:in `my_controller_params'",
+      "* app/controllers/my_controller.rb:34:in `update'",
+      '```'
+    ].join("\n")
+
+    @exception.set_backtrace([
+                               "app/controllers/my_controller.rb:53:in `my_controller_params'",
+                               "app/controllers/my_controller.rb:34:in `update'"
+                             ])
+
+    formatter = ExceptionNotifier::Formatter.new(@exception)
+    assert_equal text, formatter.backtrace_message
+  end
+
+  test 'backtrace_message when no backtrace' do
+    formatter = ExceptionNotifier::Formatter.new(@exception)
+    assert_nil formatter.backtrace_message
+  end
+
+  #
+  # #controller_and_action
+  #
+  test 'correct controller_and_action if controller is present' do
+    env = Rack::MockRequest.env_for(
+      '/', 'action_controller.instance' => test_controller
+    )
+
+    formatter = ExceptionNotifier::Formatter.new(@exception, env: env)
+    assert_equal 'home#index', formatter.controller_and_action
+  end
+
+  test 'controller_and_action is nil if no controller' do
+    env = Rack::MockRequest.env_for('/')
+
+    formatter = ExceptionNotifier::Formatter.new(@exception, env: env)
+    assert_nil formatter.controller_and_action
+  end
+
+  def test_controller
+    controller = mock('controller')
+    controller.stubs(:action_name).returns('index')
+    controller.stubs(:controller_name).returns('home')
+
+    controller
+  end
+end

data/test/exception_notifier/sidekiq_test.rb

@@ -1,25 +1,28 @@
-require "test_helper"
+# frozen_string_literal: true
+
+require 'test_helper'
 
 # To allow sidekiq error handlers to be registered, sidekiq must be in
 # "server mode". This mode is triggered by loading sidekiq/cli. Note this
 # has to be loaded before exception_notification/sidekiq.
-require "sidekiq/cli"
+require 'sidekiq/cli'
+require 'sidekiq/testing'
 
-require "exception_notification/sidekiq"
+require 'exception_notification/sidekiq'
 
 class MockSidekiqServer
   include ::Sidekiq::ExceptionHandler
 end
 
 class SidekiqTest < ActiveSupport::TestCase
-  test "should call notify_exception when sidekiq raises an error" do
+  test 'should call notify_exception when sidekiq raises an error' do
     server = MockSidekiqServer.new
-    message = Hash.new
+    message = {}
     exception = RuntimeError.new
 
     ExceptionNotifier.expects(:notify_exception).with(
       exception,
-      :data => { :sidekiq => message }
+      data: { sidekiq: message }
     )
 
     server.handle_exception(exception, message)

data/test/exception_notifier/slack_notifier_test.rb

@@ -1,18 +1,20 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'slack-notifier'
 
 class SlackNotifierTest < ActiveSupport::TestCase
-
   def setup
     @exception = fake_exception
     @exception.stubs(:backtrace).returns(fake_backtrace)
     @exception.stubs(:message).returns('exception message')
+    ExceptionNotifier::SlackNotifier.any_instance.stubs(:clean_backtrace).returns(fake_cleaned_backtrace)
     Socket.stubs(:gethostname).returns('example.com')
   end
 
-  test "should send a slack notification if properly configured" do
+  test 'should send a slack notification if properly configured' do
     options = {
-      webhook_url: "http://slack.webhook.url"
+      webhook_url: 'http://slack.webhook.url'
     }
 
     Slack::Notifier.any_instance.expects(:ping).with('', fake_notification)
@@ -21,9 +23,9 @@ class SlackNotifierTest < ActiveSupport::TestCase
     slack_notifier.call(@exception)
   end
 
-  test "should send a slack notification without backtrace info if properly configured" do
+  test 'should send a slack notification without backtrace info if properly configured' do
     options = {
-      webhook_url: "http://slack.webhook.url"
+      webhook_url: 'http://slack.webhook.url'
     }
 
     Slack::Notifier.any_instance.expects(:ping).with('', fake_notification(fake_exception_without_backtrace))
@@ -32,10 +34,10 @@ class SlackNotifierTest < ActiveSupport::TestCase
     slack_notifier.call(fake_exception_without_backtrace)
   end
 
-  test "should send the notification to the specified channel" do
+  test 'should send the notification to the specified channel' do
     options = {
-      webhook_url: "http://slack.webhook.url",
-      channel: "channel"
+      webhook_url: 'http://slack.webhook.url',
+      channel: 'channel'
     }
 
     Slack::Notifier.any_instance.expects(:ping).with('', fake_notification)
@@ -43,13 +45,14 @@ class SlackNotifierTest < ActiveSupport::TestCase
     slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
     slack_notifier.call(@exception)
 
-    assert_equal slack_notifier.notifier.channel, options[:channel]
+    channel = slack_notifier.notifier.config.defaults[:channel]
+    assert_equal channel, options[:channel]
   end
 
-  test "should send the notification to the specified username" do
+  test 'should send the notification to the specified username' do
     options = {
-      webhook_url: "http://slack.webhook.url",
-      username: "username"
+      webhook_url: 'http://slack.webhook.url',
+      username: 'username'
     }
 
     Slack::Notifier.any_instance.expects(:ping).with('', fake_notification)
@@ -57,20 +60,49 @@ class SlackNotifierTest < ActiveSupport::TestCase
     slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
     slack_notifier.call(@exception)
 
-    assert_equal slack_notifier.notifier.username, options[:username]
+    username = slack_notifier.notifier.config.defaults[:username]
+    assert_equal username, options[:username]
   end
 
-  test "should pass the additional parameters to Slack::Notifier.ping" do
+  test 'should send the notification with specific backtrace lines' do
     options = {
-      webhook_url: "http://slack.webhook.url",
-      username: "test",
-      custom_hook: "hook",
+      webhook_url: 'http://slack.webhook.url',
+      backtrace_lines: 1
+    }
+
+    Slack::Notifier.any_instance.expects(:ping).with('', fake_notification(@exception, {}, nil, 1))
+
+    slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
+    slack_notifier.call(@exception)
+  end
+
+  test 'should send the notification with additional fields' do
+    field = { title: 'Branch', value: 'master', short: true }
+    options = {
+      webhook_url: 'http://slack.webhook.url',
+      additional_fields: [field]
+    }
+
+    Slack::Notifier.any_instance.expects(:ping).with('', fake_notification(@exception, {}, nil, 10, [field]))
+
+    slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
+    slack_notifier.call(@exception)
+
+    additional_fields = slack_notifier.notifier.config.defaults[:additional_fields]
+    assert_equal additional_fields, options[:additional_fields]
+  end
+
+  test 'should pass the additional parameters to Slack::Notifier.ping' do
+    options = {
+      webhook_url: 'http://slack.webhook.url',
+      username: 'test',
+      custom_hook: 'hook',
       additional_parameters: {
-        icon_url: "icon",
+        icon_url: 'icon'
       }
     }
 
-    Slack::Notifier.any_instance.expects(:ping).with('', options[:additional_parameters].merge(fake_notification) )
+    Slack::Notifier.any_instance.expects(:ping).with('', options[:additional_parameters].merge(fake_notification))
 
     slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
     slack_notifier.call(@exception)
@@ -85,55 +117,57 @@ class SlackNotifierTest < ActiveSupport::TestCase
     assert_nil slack_notifier.call(@exception)
   end
 
-  test "should pass along environment data" do
+  test 'should pass along environment data' do
     options = {
-      webhook_url: "http://slack.webhook.url",
-      ignore_data_if: lambda {|k,v|
-        "#{k}" == 'key_to_be_ignored' || v.is_a?(Hash)
+      webhook_url: 'http://slack.webhook.url',
+      ignore_data_if: lambda { |k, v|
+        k.to_s == 'key_to_be_ignored' || v.is_a?(Hash)
       }
     }
 
     notification_options = {
       env: {
-        'exception_notifier.exception_data' => {foo: 'bar', john: 'doe'}
+        'exception_notifier.exception_data' => { foo: 'bar', john: 'doe' }
       },
       data: {
-        'user_id'           => 5,
+        'user_id' => 5,
         'key_to_be_ignored' => 'whatever',
-        'ignore_as_well'    => {what: 'ever'}
+        'ignore_as_well' => { what: 'ever' }
       }
     }
 
     expected_data_string = "foo: bar\njohn: doe\nuser_id: 5"
 
-    Slack::Notifier.any_instance.expects(:ping).with('', fake_notification(@exception, expected_data_string))
+    Slack::Notifier.any_instance
+                   .expects(:ping)
+                   .with('', fake_notification(@exception, notification_options, expected_data_string))
     slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
     slack_notifier.call(@exception, notification_options)
   end
 
-  test "should call pre/post_callback proc if specified" do
+  test 'should call pre/post_callback proc if specified' do
     post_callback_called = 0
     options = {
-      webhook_url: "http://slack.webhook.url",
-      username: "test",
-      custom_hook: "hook",
-      :pre_callback => proc { |opts, notifier, backtrace, message, message_opts|
-        (message_opts[:attachments] = []) << { text: "#{backtrace.join("\n")}", color: 'danger' }
+      webhook_url: 'http://slack.webhook.url',
+      username: 'test',
+      custom_hook: 'hook',
+      pre_callback: proc { |_opts, _notifier, backtrace, _message, message_opts|
+        (message_opts[:attachments] = []) << { text: backtrace.join("\n").to_s, color: 'danger' }
       },
-      :post_callback => proc { |opts, notifier, backtrace, message, message_opts|
+      post_callback: proc { |_opts, _notifier, _backtrace, _message, _message_opts|
         post_callback_called = 1
       },
       additional_parameters: {
-        icon_url: "icon",
+        icon_url: 'icon'
       }
     }
 
     Slack::Notifier.any_instance.expects(:ping).with('',
-                                                     {:icon_url => 'icon',
-                                                      :attachments => [
-                                                        {:text => fake_backtrace.join("\n"),
-                                                         :color => 'danger'}
-                                                     ]})
+                                                     icon_url: 'icon',
+                                                     attachments: [{
+                                                       text: fake_backtrace.join("\n"),
+                                                       color: 'danger'
+                                                     }])
 
     slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
     slack_notifier.call(@exception)
@@ -143,11 +177,9 @@ class SlackNotifierTest < ActiveSupport::TestCase
   private
 
   def fake_exception
-    begin
-      5/0
-    rescue Exception => e
-      e
-    end
+    5 / 0
+  rescue StandardError => e
+    e
   end
 
   def fake_exception_without_backtrace
@@ -156,24 +188,42 @@ class SlackNotifierTest < ActiveSupport::TestCase
 
   def fake_backtrace
     [
-      "backtrace line 1",
-      "backtrace line 2",
-      "backtrace line 3",
-      "backtrace line 4",
-      "backtrace line 5",
-      "backtrace line 6",
+      'backtrace line 1', 'backtrace line 2', 'backtrace line 3',
+      'backtrace line 4', 'backtrace line 5', 'backtrace line 6'
     ]
   end
 
-  def fake_notification(exception = @exception, data_string = nil)
-    text = "*An exception occurred while doing*: ` <>`\n"
+  def fake_cleaned_backtrace
+    fake_backtrace[2..-1]
+  end
 
-    fields = [ { title: 'Exception', value: exception.message} ]
-    fields.push({ title: 'Hostname', value: 'example.com' })
-    fields.push({ title: 'Backtrace', value: "```#{fake_backtrace.join("\n")}```" }) if exception.backtrace
-    fields.push({ title: 'Data', value: "```#{data_string}```" }) if data_string
+  def fake_notification(exception = @exception, notification_options = {},
+                        data_string = nil, expected_backtrace_lines = 10, additional_fields = [])
 
-    { attachments: [ color: 'danger', text: text, fields: fields, mrkdwn_in: %w(text fields) ] }
-  end
+    exception_name = "*#{exception.class.to_s =~ /^[aeiou]/i ? 'An' : 'A'}* `#{exception.class}`"
+    if notification_options[:env].nil?
+      text = "#{exception_name} *occured in background*"
+    else
+      env = notification_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}`" if kontroller
+    end
+
+    text += "\n"
+
+    fields = [{ title: 'Exception', value: exception.message }]
+    fields.push(title: 'Hostname', value: 'example.com')
+    if exception.backtrace
+      formatted_backtrace = "```#{fake_cleaned_backtrace.first(expected_backtrace_lines).join("\n")}```"
+      fields.push(title: 'Backtrace', value: formatted_backtrace)
+    end
+    fields.push(title: 'Data', value: "```#{data_string}```") if data_string
+    additional_fields.each { |f| fields.push(f) }
+
+    { attachments: [color: 'danger', text: text, fields: fields, mrkdwn_in: %w[text fields]] }
+  end
 end