exception_notification 3.0.1 → 4.4.0

data/test/exception_notifier/modules/error_grouping_test.rb

@@ -0,0 +1,165 @@
+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,150 @@
+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

@@ -0,0 +1,38 @@
+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 'exception_notification/sidekiq'
+
+class MockSidekiqServer
+  include ::Sidekiq::ExceptionHandler
+end
+
+class SidekiqTest < ActiveSupport::TestCase
+  setup do
+    @_original_sidekiq_logger = Sidekiq::Logging.logger
+
+    # Silence sidekiq warning to stdout
+    Sidekiq::Logging.logger = nil
+  end
+
+  test 'should call notify_exception when sidekiq raises an error' do
+    server = MockSidekiqServer.new
+    message = {}
+    exception = RuntimeError.new
+
+    ExceptionNotifier.expects(:notify_exception).with(
+      exception,
+      data: { sidekiq: message }
+    )
+
+    server.handle_exception(exception, message)
+  end
+
+  teardown do
+    Sidekiq::Logging.logger = @_original_sidekiq_logger
+  end
+end

data/test/exception_notifier/slack_notifier_test.rb

@@ -0,0 +1,227 @@
+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
+    options = {
+      webhook_url: 'http://slack.webhook.url'
+    }
+
+    Slack::Notifier.any_instance.expects(:ping).with('', fake_notification)
+
+    slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
+    slack_notifier.call(@exception)
+  end
+
+  test 'should send a slack notification without backtrace info if properly configured' do
+    options = {
+      webhook_url: 'http://slack.webhook.url'
+    }
+
+    Slack::Notifier.any_instance.expects(:ping).with('', fake_notification(fake_exception_without_backtrace))
+
+    slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
+    slack_notifier.call(fake_exception_without_backtrace)
+  end
+
+  test 'should send the notification to the specified channel' do
+    options = {
+      webhook_url: 'http://slack.webhook.url',
+      channel: 'channel'
+    }
+
+    Slack::Notifier.any_instance.expects(:ping).with('', fake_notification)
+
+    slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
+    slack_notifier.call(@exception)
+
+    channel = slack_notifier.notifier.config.defaults[:channel]
+    assert_equal channel, options[:channel]
+  end
+
+  test 'should send the notification to the specified username' do
+    options = {
+      webhook_url: 'http://slack.webhook.url',
+      username: 'username'
+    }
+
+    Slack::Notifier.any_instance.expects(:ping).with('', fake_notification)
+
+    slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
+    slack_notifier.call(@exception)
+
+    username = slack_notifier.notifier.config.defaults[:username]
+    assert_equal username, options[:username]
+  end
+
+  test 'should send the notification with specific backtrace lines' do
+    options = {
+      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'
+      }
+    }
+
+    Slack::Notifier.any_instance.expects(:ping).with('', options[:additional_parameters].merge(fake_notification))
+
+    slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
+    slack_notifier.call(@exception)
+  end
+
+  test "shouldn't send a slack notification if webhook url is missing" do
+    options = {}
+
+    slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
+
+    assert_nil slack_notifier.notifier
+    assert_nil slack_notifier.call(@exception)
+  end
+
+  test 'should pass along environment data' do
+    options = {
+      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' }
+      },
+      data: {
+        'user_id'           => 5,
+        'key_to_be_ignored' => 'whatever',
+        '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, 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
+    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").to_s, color: 'danger' }
+      },
+      post_callback: proc { |_opts, _notifier, _backtrace, _message, _message_opts|
+        post_callback_called = 1
+      },
+      additional_parameters: {
+        icon_url: 'icon'
+      }
+    }
+
+    Slack::Notifier.any_instance.expects(:ping).with('',
+                                                     icon_url: 'icon',
+                                                     attachments: [{
+                                                       text: fake_backtrace.join("\n"),
+                                                       color: 'danger'
+                                                     }])
+
+    slack_notifier = ExceptionNotifier::SlackNotifier.new(options)
+    slack_notifier.call(@exception)
+    assert_equal(post_callback_called, 1)
+  end
+
+  private
+
+  def fake_exception
+    5 / 0
+  rescue StandardError => e
+    e
+  end
+
+  def fake_exception_without_backtrace
+    StandardError.new('my custom error')
+  end
+
+  def fake_backtrace
+    [
+      'backtrace line 1',
+      'backtrace line 2',
+      'backtrace line 3',
+      'backtrace line 4',
+      'backtrace line 5',
+      'backtrace line 6'
+    ]
+  end
+
+  def fake_cleaned_backtrace
+    fake_backtrace[2..-1]
+  end
+
+  def fake_notification(exception = @exception, notification_options = {}, data_string = nil, expected_backtrace_lines = 10, additional_fields = [])
+    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