exception_notification_more_info 1.0.0

data/test/exception_notifier/irc_notifier_test.rb

@@ -0,0 +1,121 @@
+require 'test_helper'
+require 'carrier-pigeon'
+
+class IrcNotifierTest < ActiveSupport::TestCase
+
+  test "should send irc notification if properly configured" do
+    options = {
+      :domain => 'irc.example.com'
+    }
+
+    CarrierPigeon.expects(:send).with(has_key(:uri)) do |v|
+      /divided by 0/.match(v[:message])
+    end
+
+    irc = ExceptionNotifier::IrcNotifier.new(options)
+    irc.call(fake_exception)
+  end
+
+  test "should call pre/post_callback if specified" do
+    pre_callback_called, post_callback_called = 0,0
+
+    options = {
+      :domain => 'irc.example.com',
+      :pre_callback => proc { |*| pre_callback_called += 1},
+      :post_callback => proc { |*| post_callback_called += 1}
+    }
+
+    CarrierPigeon.expects(:send).with(has_key(:uri)) do |v|
+      /divided by 0/.match(v[:message])
+    end
+
+    irc = ExceptionNotifier::IrcNotifier.new(options)
+    irc.call(fake_exception)
+    assert_equal(1, pre_callback_called)
+    assert_equal(1, post_callback_called)
+  end
+
+  test "should send irc notification without backtrace info if properly configured" do
+    options = {
+      :domain => 'irc.example.com'
+    }
+
+    CarrierPigeon.expects(:send).with(has_key(:uri)) do |v|
+      /my custom error/.match(v[:message])
+    end
+
+    irc = ExceptionNotifier::IrcNotifier.new(options)
+    irc.call(fake_exception_without_backtrace)
+  end
+
+  test "should properly construct URI from constituent parts" do
+    options = {
+      :nick => 'BadNewsBot',
+      :password => 'secret',
+      :domain => 'irc.example.com',
+      :port => 9999,
+      :channel => '#exceptions'
+    }
+
+    CarrierPigeon.expects(:send).with(has_entry(uri: "irc://BadNewsBot:secret@irc.example.com:9999/#exceptions"))
+
+    irc = ExceptionNotifier::IrcNotifier.new(options)
+    irc.call(fake_exception)
+  end
+
+  test "should properly add recipients if specified" do
+    options = {
+      domain: 'irc.example.com',
+      recipients: ['peter', 'michael', 'samir']
+    }
+
+    CarrierPigeon.expects(:send).with(has_key(:uri)) do |v|
+      /peter, michael, samir/.match(v[:message])
+    end
+
+    irc = ExceptionNotifier::IrcNotifier.new(options)
+    irc.call(fake_exception)
+  end
+
+  test "should properly set miscellaneous options" do
+    options = {
+      domain: 'irc.example.com',
+      ssl: true,
+      join: true,
+      notice: true,
+      prefix: '[test notification]'
+    }
+
+    CarrierPigeon.expects(:send).with(has_entries(
+      ssl: true,
+      join: true,
+      notice: true,
+    )) do |v|
+      /\[test notification\]/.match(v[:message])
+    end
+
+    irc = ExceptionNotifier::IrcNotifier.new(options)
+    irc.call(fake_exception)
+  end
+
+  test "should not send irc notification if badly configured" do
+    wrong_params = { domain: '##scriptkiddie.com###'}
+    irc = ExceptionNotifier::IrcNotifier.new(wrong_params)
+
+    assert_nil irc.call(fake_exception)
+  end
+
+  private
+
+  def fake_exception
+    exception = begin
+      5/0
+    rescue Exception => e
+      e
+    end
+  end
+
+  def fake_exception_without_backtrace
+    StandardError.new('my custom error')
+  end
+end

data/test/exception_notifier/sidekiq_test.rb

@@ -0,0 +1,27 @@
+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
+  test "should call notify_exception when sidekiq raises an error" do
+    server = MockSidekiqServer.new
+    message = Hash.new
+    exception = RuntimeError.new
+
+    ExceptionNotifier.expects(:notify_exception).with(
+      exception,
+      :data => { :sidekiq => message }
+    )
+
+    server.handle_exception(exception, message)
+  end
+end

data/test/exception_notifier/slack_notifier_test.rb

@@ -0,0 +1,179 @@
+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')
+    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)
+
+    assert_equal slack_notifier.notifier.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)
+
+    assert_equal slack_notifier.notifier.username, options[:username]
+  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}" == '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, 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")}", 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
+    begin
+      5/0
+    rescue Exception => e
+      e
+    end
+  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_notification(exception = @exception, data_string = nil)
+    text = "*An exception occurred while doing*: ` <>`\n"
+
+    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
+
+    { attachments: [ color: 'danger', text: text, fields: fields, mrkdwn_in: %w(text fields) ] }
+  end
+
+end

data/test/exception_notifier/webhook_notifier_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+require 'httparty'
+
+class WebhookNotifierTest < ActiveSupport::TestCase
+
+  test "should send webhook notification if properly configured" do
+    ExceptionNotifier::WebhookNotifier.stubs(:new).returns(Object.new)
+    webhook = ExceptionNotifier::WebhookNotifier.new({:url => 'http://localhost:8000'})
+    webhook.stubs(:call).returns(fake_response)
+    response = webhook.call(fake_exception)
+
+    refute_nil response
+    assert_equal response[:status], 200
+    assert_equal response[:body][:exception][:error_class], "ZeroDivisionError"
+    assert_includes response[:body][:exception][:message], "divided by 0"
+    assert_includes response[:body][:exception][:backtrace], "/exception_notification/test/webhook_notifier_test.rb:48"
+    
+    assert response[:body][:request][:cookies].has_key?(:cookie_item1)
+    assert_equal response[:body][:request][:url], "http://example.com/example"
+    assert_equal response[:body][:request][:ip_address], "192.168.1.1"
+    assert response[:body][:request][:environment].has_key?(:env_item1)
+    assert_equal response[:body][:request][:controller], "#<ControllerName:0x007f9642a04d00>"
+    assert response[:body][:request][:session].has_key?(:session_item1)
+    assert response[:body][:request][:parameters].has_key?(:controller)
+    assert response[:body][:data][:extra_data].has_key?(:data_item1)
+  end
+
+  test "should call pre/post_callback if specified" do
+    HTTParty.stubs(:send).returns(fake_response)
+    webhook = ExceptionNotifier::WebhookNotifier.new({:url => 'http://localhost:8000'})
+    webhook.call(fake_exception)
+  end
+
+  private
+
+  def fake_response
+    {
+      :status => 200,
+      :body => {
+        :exception => {
+          :error_class => 'ZeroDivisionError',
+          :message => 'divided by 0',
+          :backtrace => '/exception_notification/test/webhook_notifier_test.rb:48:in `/'
+        },
+        :data => {
+          :extra_data => {:data_item1 => "datavalue1", :data_item2 => "datavalue2"}
+        },
+        :request => {
+          :cookies => {:cookie_item1 => 'cookieitemvalue1', :cookie_item2 => 'cookieitemvalue2'},
+          :url => 'http://example.com/example',
+          :ip_address => '192.168.1.1',
+          :environment => {:env_item1 => "envitem1", :env_item2 => "envitem2"},
+          :controller => '#<ControllerName:0x007f9642a04d00>',
+          :session => {:session_item1 => "sessionitem1", :session_item2 => "sessionitem2"},
+          :parameters => {:action =>"index", :controller =>"projects"}
+        }
+      }
+    }
+  end
+
+  def fake_exception
+    exception = begin
+      5/0
+    rescue Exception => e
+      e
+    end
+  end
+end

data/test/exception_notifier_test.rb

@@ -0,0 +1,103 @@
+require 'test_helper'
+
+class ExceptionNotifierTest < ActiveSupport::TestCase
+  test "should have default ignored exceptions" do
+    assert_equal ExceptionNotifier.ignored_exceptions, ['ActiveRecord::RecordNotFound', 'AbstractController::ActionNotFound', 'ActionController::RoutingError', 'ActionController::UnknownFormat']
+  end
+
+  test "should have email notifier registered" do
+    assert_equal ExceptionNotifier.notifiers, [:email]
+  end
+
+  test "should have a valid email notifier" do
+    @email_notifier = ExceptionNotifier.registered_exception_notifier(:email)
+    refute_nil @email_notifier
+    assert_equal @email_notifier.class, ExceptionNotifier::EmailNotifier
+    assert_respond_to @email_notifier, :call
+  end
+
+  test "should allow register/unregister another notifier" do
+    called = false
+    proc_notifier = lambda { |exception, options| called = true }
+    ExceptionNotifier.register_exception_notifier(:proc, proc_notifier)
+
+    assert_equal ExceptionNotifier.notifiers.sort, [:email, :proc]
+
+    exception = StandardError.new
+
+    ExceptionNotifier.notify_exception(exception)
+    assert called
+
+    ExceptionNotifier.unregister_exception_notifier(:proc)
+    assert_equal ExceptionNotifier.notifiers, [:email]
+  end
+
+  test "should allow select notifiers to send error to" do
+    notifier1_calls = 0
+    notifier1 = lambda { |exception, options| notifier1_calls += 1 }
+    ExceptionNotifier.register_exception_notifier(:notifier1, notifier1)
+
+    notifier2_calls = 0
+    notifier2 = lambda { |exception, options| notifier2_calls += 1 }
+    ExceptionNotifier.register_exception_notifier(:notifier2, notifier2)
+
+    assert_equal ExceptionNotifier.notifiers.sort, [:email, :notifier1, :notifier2]
+
+    exception = StandardError.new
+    ExceptionNotifier.notify_exception(exception)
+    assert_equal notifier1_calls, 1
+    assert_equal notifier2_calls, 1
+
+    ExceptionNotifier.notify_exception(exception, {:notifiers => :notifier1})
+    assert_equal notifier1_calls, 2
+    assert_equal notifier2_calls, 1
+
+    ExceptionNotifier.notify_exception(exception, {:notifiers => :notifier2})
+    assert_equal notifier1_calls, 2
+    assert_equal notifier2_calls, 2
+
+    ExceptionNotifier.unregister_exception_notifier(:notifier1)
+    ExceptionNotifier.unregister_exception_notifier(:notifier2)
+    assert_equal ExceptionNotifier.notifiers, [:email]
+  end
+
+  test "should ignore exception if satisfies conditional ignore" do
+    env = "production"
+    ExceptionNotifier.ignore_if do |exception, options|
+      env != "production"
+    end
+
+    notifier_calls = 0
+    test_notifier = lambda { |exception, options| notifier_calls += 1 }
+    ExceptionNotifier.register_exception_notifier(:test, test_notifier)
+
+    exception = StandardError.new
+
+    ExceptionNotifier.notify_exception(exception, {:notifiers => :test})
+    assert_equal notifier_calls, 1
+
+    env = "development"
+    ExceptionNotifier.notify_exception(exception, {:notifiers => :test})
+    assert_equal notifier_calls, 1
+
+    ExceptionNotifier.clear_ignore_conditions!
+    ExceptionNotifier.unregister_exception_notifier(:test)
+  end
+
+  test "should not send notification if one of ignored exceptions" do
+    notifier_calls = 0
+    test_notifier = lambda { |exception, options| notifier_calls += 1 }
+    ExceptionNotifier.register_exception_notifier(:test, test_notifier)
+
+    exception = StandardError.new
+
+    ExceptionNotifier.notify_exception(exception, {:notifiers => :test})
+    assert_equal notifier_calls, 1
+
+    ExceptionNotifier.notify_exception(exception, {:notifiers => :test, :ignore_exceptions => 'StandardError' })
+    assert_equal notifier_calls, 1
+
+    ExceptionNotifier.unregister_exception_notifier(:test)
+  end
+
+end