exception_notification 4.3.0 → 4.5.0

data/docs/notifiers/slack.md

@@ -0,0 +1,161 @@
+### Slack notifier
+
+This notifier sends notifications to a slack channel using the slack-notifier gem.
+
+#### Usage
+
+Just add the [slack-notifier](https://github.com/stevenosloan/slack-notifier) gem to your `Gemfile`:
+
+```ruby
+gem 'slack-notifier'
+```
+
+To configure it, you need to set at least the 'webhook_url' option, like this:
+
+```ruby
+Rails.application.config.middleware.use ExceptionNotification::Rack,
+                                        email: {
+                                          email_prefix: '[PREFIX] ',
+                                          sender_address: %{"notifier" <notifier@example.com>},
+                                          exception_recipients: %w{exceptions@example.com}
+                                        },
+                                        slack: {
+                                          webhook_url: '[Your webhook url]',
+                                          channel: '#exceptions',
+                                          additional_parameters: {
+                                            icon_url: 'http://image.jpg',
+                                            mrkdwn: true
+                                          }
+                                        }
+```
+
+The slack notification will include any data saved under `env['exception_notifier.exception_data']`.
+
+An example of how to send the server name to Slack in Rails (put this code in application_controller.rb):
+
+```ruby
+before_action :set_notification
+
+def set_notification
+  request.env['exception_notifier.exception_data'] = { 'server' => request.env['SERVER_NAME'] }
+  # can be any key-value pairs
+end
+```
+
+If you find this too verbose, you can determine to exclude certain information by doing the following:
+
+```ruby
+Rails.application.config.middleware.use ExceptionNotification::Rack,
+                                        slack: {
+                                          webhook_url: '[Your webhook url]',
+                                          channel: '#exceptions',
+                                          additional_parameters: {
+                                            icon_url: 'http://image.jpg',
+                                            mrkdwn: true
+                                          },
+                                          ignore_data_if: lambda {|key, value|
+                                            "#{key}" == 'key_to_ignore' || value.is_a?(ClassToBeIgnored)
+                                          }
+                                        }
+```
+
+Any evaluation to `true` will cause the key / value pair not be be sent along to Slack.
+
+
+the `slack-notifier` gem allows to override the channel default value, if you ever
+need to send a notification to a different slack channel. Simply add the
+`channel` option when calling `.notify_exception`
+
+```ruby
+ExceptionNotifier.notify_exception(
+  exception,
+  env: request.env,
+  channel: '#my-custom-channel', # Make sure the channel name starts with `#`
+  data: {
+    error: error_variable,
+    server: server_name
+  }
+)
+```
+
+If you ever need to add more `slack-notifier` specific options, and
+particularly to the `#ping` method of the slack notifier, you can use
+the `pre_callback` option when defining the middleware.
+```ruby
+ pre_callback: proc { |opts, _notifier, _backtrace, _message, message_opts|
+   message_opts[:channel] = opts[:channel] if opts.key?(:channel)
+ }
+
+```
+- `message_opts` is the hash you want to append to if you need to add an option.
+- `options` is the hash containing the values when you call
+  `ExceptionNotification.notify_exception`
+
+An example implementation would be:
+```ruby
+config.middleware.use ExceptionNotification::Rack,
+  slack: {
+    webhook_url: '[Your webhook url]',
+    pre_callback: proc { |opts, _notifier, _backtrace, _message, message_opts|
+      message_opts[:ping_option] = opts[:ping_option] if
+      opts.key?(:ping_option)
+    }
+  },
+  error_grouping: true
+```
+Then when calling from within your application code:
+```ruby
+ExceptionNotifier.notify_exception(
+  exception,
+  env: request.env,
+  ping_option: 'value',
+  # this will be passed to the slack notifier's `#ping`
+  # method, as a parameter. The `:pre_callback` hook will catch it
+  # and do that for you.
+  # Helpful, if the API evolves, you only need to update
+  # the `slack-notifier` gem
+  data: {
+    error: error_variable,
+    server: server_name
+  }
+)
+
+```
+#### Options
+
+##### webhook_url
+
+*String, required*
+
+The Incoming WebHook URL on slack.
+
+##### channel
+
+*String, optional*
+
+Message will appear in this channel. Defaults to the channel you set as such on slack.
+
+##### username
+
+*String, optional*
+
+Username of the bot. Defaults to the name you set as such on slack
+
+##### custom_hook
+
+*String, optional*
+
+Custom hook name. See [slack-notifier](https://github.com/stevenosloan/slack-notifier#custom-hook-name) for
+more information. Default: 'incoming-webhook'
+
+##### additional_parameters
+
+*Hash of strings, optional*
+
+Contains additional payload for a message (e.g avatar, attachments, etc). See [slack-notifier](https://github.com/stevenosloan/slack-notifier#additional-parameters) for more information.. Default: '{}'
+
+##### additional_fields
+
+*Array of Hashes, optional*
+
+Contains additional fields that will be added to the attachement. See [Slack documentation](https://api.slack.com/docs/message-attachments).

data/docs/notifiers/sns.md

@@ -0,0 +1,37 @@
+### Amazon SNS Notifier
+
+Notify all exceptions Amazon - Simple Notification Service: [SNS](https://aws.amazon.com/sns/).
+
+#### Usage
+
+Add the [aws-sdk-sns](https://github.com/aws/aws-sdk-ruby/tree/master/gems/aws-sdk-sns) gem to your `Gemfile`:
+
+```ruby
+  gem 'aws-sdk-sns', '~> 1.5'
+```
+
+To configure it, you **need** to set 3 required options for aws: `region`, `access_key_id` and `secret_access_key`, and one more option for sns: `topic_arn`.
+
+```ruby
+Rails.application.config.middleware.use ExceptionNotification::Rack,
+                                        sns: {
+                                          region: 'us-east-x',
+                                          access_key_id: 'access_key_id',
+                                          secret_access_key: 'secret_access_key',
+                                          topic_arn: 'arn:aws:sns:us-east-x:XXXX:my-topic'
+                                        }
+```
+
+##### sns_prefix
+*String, optional *
+
+Prefix in the notification subject, by default: "[Error]"
+
+##### backtrace_lines
+*Integer, optional *
+
+Number of backtrace lines to be displayed in the notification message. By default: 10
+
+#### Note:
+* You may need to update your previous `aws-sdk-*` gems in order to setup `aws-sdk-sns` correctly.
+* If you need any further information about the available regions or any other SNS related topic consider: [SNS faqs](https://aws.amazon.com/sns/faqs/)

data/docs/notifiers/teams.md

@@ -0,0 +1,54 @@
+### Teams notifier
+
+Post notification in a Microsoft Teams channel via [Incoming Webhook Connector](https://docs.microsoft.com/en-us/outlook/actionable-messages/actionable-messages-via-connectors)
+Just add the [HTTParty](https://github.com/jnunemaker/httparty) gem to your `Gemfile`:
+
+```ruby
+gem 'httparty'
+```
+
+To configure it, you **need** to set the `webhook_url` option.
+If you are using GitLab for issue tracking, you can specify `git_url` as follows to add a *Create issue* button in your notification.
+By default this will use your Rails application name to match the git repository. If yours differs, you can specify `app_name`.
+By that same notion, you may also set a `jira_url` to get a button that will send you to the New Issue screen in Jira.
+
+```ruby
+Rails.application.config.middleware.use ExceptionNotification::Rack,
+  email: {
+    email_prefix: "[PREFIX] ",
+    sender_address: %{"notifier" <notifier@example.com>},
+    exception_recipients: %w{exceptions@example.com}
+  },
+  teams: {
+    webhook_url: 'https://outlook.office.com/webhook/your-guid/IncomingWebhook/team-guid',
+    git_url: 'https://your-gitlab.com/Group/Project',
+    jira_url: 'https://your-jira.com'
+  }
+```
+
+#### Options
+
+##### webhook_url
+
+*String, required*
+
+The Incoming WebHook URL on Teams.
+
+##### git_url
+
+*String, optional*
+
+Url of your gitlab or github with your organisation name for issue creation link (Eg: `github.com/aschen`). Defaults to nil and doesn't add link to the notification.
+
+##### jira_url
+
+*String, optional*
+
+Url of your Jira instance, adds button for Create Issue screen. Defaults to nil and doesn't add a button to the card.
+
+##### app_name
+
+*String, optional*
+
+Your application name used for git issue creation link. Defaults to `Rails.application.class.module_parent_name.underscore` for Rails versions >= 6;
+`Rails.application.class.parent_name.underscore` otherwise.

data/docs/notifiers/webhook.md

@@ -0,0 +1,60 @@
+### WebHook notifier
+
+This notifier ships notifications over the HTTP protocol.
+
+#### Usage
+
+Just add the [HTTParty](https://github.com/jnunemaker/httparty) gem to your `Gemfile`:
+
+```ruby
+gem 'httparty'
+```
+
+To configure it, you need to set the `url` option, like this:
+
+```ruby
+Rails.application.config.middleware.use ExceptionNotification::Rack,
+                                        email: {
+                                          email_prefix: '[PREFIX] ',
+                                          sender_address: %{"notifier" <notifier@example.com>},
+                                          exception_recipients: %w{exceptions@example.com}
+                                        },
+                                        webhook: {
+                                          url: 'http://domain.com:5555/hubot/path'
+                                        }
+```
+
+By default, the WebhookNotifier will call the URLs using the POST method. But, you can change this using the `http_method` option.
+
+```ruby
+Rails.application.config.middleware.use ExceptionNotification::Rack,
+                                        email: {
+                                          email_prefix: '[PREFIX] ',
+                                          sender_address: %{"notifier" <notifier@example.com>},
+                                          exception_recipients: %w{exceptions@example.com}
+                                        },
+                                        webhook: {
+                                          url: 'http://domain.com:5555/hubot/path',
+                                          http_method: :get
+                                        }
+```
+
+Besides the `url` and `http_method` options, all the other options are passed directly to HTTParty. Thus, if the HTTP server requires authentication, you can include the following options:
+
+```ruby
+Rails.application.config.middleware.use ExceptionNotification::Rack,
+                                        email: {
+                                          email_prefix: '[PREFIX] ',
+                                          sender_address: %{"notifier" <notifier@example.com>},
+                                          exception_recipients: %w{exceptions@example.com}
+                                        },
+                                        webhook: {
+                                          url: 'http://domain.com:5555/hubot/path',
+                                          basic_auth: {
+                                            username: 'alice',
+                                            password: 'password'
+                                          }
+                                        }
+```
+
+For more HTTParty options, check out the [documentation](https://github.com/jnunemaker/httparty).

data/examples/sample_app.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# -------------------------------------------
+# To run the application: ruby examples/sample_app.rb
+# -------------------------------------------
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+
+  gem 'rails', '5.0.0'
+  gem 'exception_notification', '4.3.0'
+  gem 'httparty', '0.15.7'
+end
+
+class SampleApp < Rails::Application
+  config.middleware.use ExceptionNotification::Rack,
+                        webhook: {
+                          url: 'http://example.com'
+                        }
+
+  config.secret_key_base = 'my secret key base'
+
+  Rails.logger = Logger.new($stdout)
+
+  routes.draw do
+    get '/', to: 'exceptions#index'
+  end
+end
+
+require 'action_controller/railtie'
+
+class ExceptionsController < ActionController::Base
+  def index
+    raise 'Sample exception raised, you should receive a notification!'
+  end
+end
+
+require 'minitest/autorun'
+
+class Test < Minitest::Test
+  include Rack::Test::Methods
+
+  def test_raise_exception
+    get '/'
+
+    assert last_response.server_error?
+  end
+
+  private
+
+  def app
+    Rails.application
+  end
+end

data/examples/sinatra/Gemfile

@@ -1,8 +1,10 @@
-source "https://rubygems.org"
+# frozen_string_literal: true
 
-gem "exception_notification", path: "../../"
+source 'https://rubygems.org'
 
-gem "thin", "~> 1.5.1"
-gem "sinatra", "~> 1.3.5"
-gem "foreman"
-gem "mailcatcher"
+gem 'exception_notification', path: '../../'
+
+gem 'foreman'
+gem 'mailcatcher'
+gem 'sinatra', '~> 1.3.5'
+gem 'thin', '~> 1.5.1'

data/examples/sinatra/config.ru

@@ -1,3 +1,5 @@
-require ::File.expand_path('../sinatra_app',  __FILE__)
+# frozen_string_literal: true
+
+require ::File.expand_path('../sinatra_app', __FILE__)
 
 run SinatraApp

data/examples/sinatra/sinatra_app.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rubygems'
 require 'bundler/setup'
 require 'sinatra/base'
@@ -5,27 +7,33 @@ require 'exception_notification'
 
 class SinatraApp < Sinatra::Base
   use Rack::Config do |env|
-    env["action_dispatch.parameter_filter"] = [:password] # This is highly recommended.  It will prevent the ExceptionNotification email from including your users' passwords
+    # This is highly recommended.  It will prevent the ExceptionNotification email from including your users' passwords
+    env['action_dispatch.parameter_filter'] = [:password]
   end
 
   use ExceptionNotification::Rack,
-    :email => {
-      :email_prefix => "[Example] ",
-      :sender_address => %{"notifier" <notifier@example.com>},
-      :exception_recipients => %w{exceptions@example.com},
-      :smtp_settings => { :address => "localhost", :port => 1025 }
-    }
+      email: {
+        email_prefix: '[Example] ',
+        sender_address: %("notifier" <notifier@example.com>),
+        exception_recipients: %w[exceptions@example.com],
+        smtp_settings: {
+          address: 'localhost',
+          port: 1025
+        }
+      }
 
   get '/' do
     raise StandardError, "ERROR: #{params[:error]}" unless params[:error].blank?
-    'Everything is fine! Now, lets break things clicking <a href="/?error=ops"> here </a>. Dont forget to see the emails at <a href="http://localhost:1080">mailcatcher</a> !'
+
+    'Everything is fine! Now, lets break things clicking <a href="/?error=ops"> here </a>.' \
+    'Dont forget to see the emails at <a href="http://localhost:1080">mailcatcher</a> !'
   end
 
   get '/background_notification' do
     begin
-      1/0
-    rescue Exception => e
-      ExceptionNotifier.notify_exception(e, :data => {:msg => "Cannot divide by zero!"})
+      1 / 0
+    rescue StandardError => e
+      ExceptionNotifier.notify_exception(e, data: { msg: 'Cannot divide by zero!' })
     end
     'Check email at <a href="http://localhost:1080">mailcatcher</a>.'
   end

data/exception_notification.gemspec

@@ -1,14 +1,18 @@
+# frozen_string_literal: true
+
+require File.expand_path('lib/exception_notification/version', __dir__)
+
 Gem::Specification.new do |s|
   s.name = 'exception_notification'
-  s.version = '4.3.0'
-  s.authors = ["Jamis Buck", "Josh Peek"]
-  s.date = %q{2018-11-22}
-  s.summary = "Exception notification for Rails apps"
-  s.homepage = "https://smartinez87.github.io/exception_notification/"
-  s.email = "smartinez87@gmail.com"
-  s.license = "MIT"
+  s.version = ExceptionNotification::VERSION
+  s.authors = ['Jamis Buck', 'Josh Peek']
+  s.date = '2022-01-20'
+  s.summary = 'Exception notification for Rails apps'
+  s.homepage = 'https://smartinez87.github.io/exception_notification/'
+  s.email = 'smartinez87@gmail.com'
+  s.license = 'MIT'
 
-  s.required_ruby_version     = '>= 2.0'
+  s.required_ruby_version     = '>= 2.3'
   s.required_rubygems_version = '>= 1.8.11'
 
   s.files = `git ls-files`.split("\n")
@@ -16,21 +20,23 @@ Gem::Specification.new do |s|
   s.test_files = `git ls-files -- test`.split("\n")
   s.require_path = 'lib'
 
-  s.add_dependency("actionmailer", ">= 4.0", "< 6")
-  s.add_dependency("activesupport", ">= 4.0", "< 6")
+  s.add_dependency('actionmailer', '>= 5.2', '< 8')
+  s.add_dependency('activesupport', '>= 5.2', '< 8')
 
-  s.add_development_dependency "rails", ">= 4.0", "< 6"
-  s.add_development_dependency "resque", "~> 1.2.0"
-  # Sidekiq 3.2.2 does not support Ruby 1.9.
-  s.add_development_dependency "sidekiq", "~> 3.0.0", "< 3.2.2"
-  s.add_development_dependency "tinder", "~> 1.8"
-  s.add_development_dependency "httparty", "~> 0.10.2"
-  s.add_development_dependency "mocha", ">= 0.13.0"
-  s.add_development_dependency "sqlite3", ">= 1.3.4"
-  s.add_development_dependency "coveralls", "~> 0.8.2"
-  s.add_development_dependency "appraisal", "~> 2.0.0"
-  s.add_development_dependency "hipchat", ">= 1.0.0"
-  s.add_development_dependency "carrier-pigeon", ">= 0.7.0"
-  s.add_development_dependency "slack-notifier", ">= 1.0.0"
-  s.add_development_dependency "aws-sdk-sns", "~> 1"
+  s.add_development_dependency 'appraisal', '~> 2.2.0'
+  s.add_development_dependency 'aws-sdk-sns', '~> 1'
+  s.add_development_dependency 'carrier-pigeon', '>= 0.7.0'
+  s.add_development_dependency 'coveralls', '~> 0.8.2'
+  s.add_development_dependency 'dogapi', '>= 1.23.0'
+  s.add_development_dependency 'hipchat', '>= 1.0.0'
+  s.add_development_dependency 'httparty', '~> 0.10.2'
+  s.add_development_dependency 'mocha', '>= 0.13.0'
+  s.add_development_dependency 'mock_redis', '~> 0.19.0'
+  s.add_development_dependency 'net-smtp'
+  s.add_development_dependency 'rails', '>= 5.2', '< 8'
+  s.add_development_dependency 'resque', '~> 1.8.0'
+  s.add_development_dependency 'rubocop', '0.78.0'
+  s.add_development_dependency 'sidekiq', '>= 5.0.4'
+  s.add_development_dependency 'slack-notifier', '>= 1.0.0'
+  s.add_development_dependency 'timecop', '~> 0.9.0'
 end

data/gemfiles/{rails4_0.gemfile → rails5_2.gemfile}

@@ -2,6 +2,6 @@
 
 source "https://rubygems.org"
 
-gem "rails", "~> 4.0.5"
+gem "rails", "~> 5.2.0"
 
-gemspec :path => "../"
+gemspec path: "../"

data/gemfiles/{rails4_1.gemfile → rails6_0.gemfile}

@@ -2,6 +2,6 @@
 
 source "https://rubygems.org"
 
-gem "rails", "~> 4.1.1"
+gem "rails", "~> 6.0.0"
 
-gemspec :path => "../"
+gemspec path: "../"

data/gemfiles/{rails4_2.gemfile → rails6_1.gemfile}

@@ -2,6 +2,6 @@
 
 source "https://rubygems.org"
 
-gem "rails", "~> 4.2.0"
+gem "rails", "~> 6.1.0"
 
-gemspec :path => "../"
+gemspec path: "../"

data/gemfiles/{rails5_0.gemfile → rails7_0.gemfile}

@@ -2,6 +2,6 @@
 
 source "https://rubygems.org"
 
-gem "rails", "~> 5.0.0"
+gem "rails", "~> 7.0.0"
 
-gemspec :path => "../"
+gemspec path: "../"

data/lib/exception_notification/rack.rb

@@ -1,19 +1,23 @@
+# frozen_string_literal: true
+
 module ExceptionNotification
   class Rack
-    class CascadePassException < Exception; end
+    class CascadePassException < RuntimeError; end
 
     def initialize(app, options = {})
       @app = app
 
-      ExceptionNotifier.ignored_exceptions = options.delete(:ignore_exceptions) if options.key?(:ignore_exceptions)
-      ExceptionNotifier.error_grouping = options.delete(:error_grouping) if options.key?(:error_grouping)
-      ExceptionNotifier.error_grouping_period = options.delete(:error_grouping_period) if options.key?(:error_grouping_period)
-      ExceptionNotifier.notification_trigger = options.delete(:notification_trigger) if options.key?(:notification_trigger)
+      ExceptionNotifier.tap do |en|
+        en.ignored_exceptions = options.delete(:ignore_exceptions) if options.key?(:ignore_exceptions)
+        en.error_grouping = options.delete(:error_grouping) if options.key?(:error_grouping)
+        en.error_grouping_period = options.delete(:error_grouping_period) if options.key?(:error_grouping_period)
+        en.notification_trigger = options.delete(:notification_trigger) if options.key?(:notification_trigger)
 
-      if options.key?(:error_grouping_cache)
-        ExceptionNotifier.error_grouping_cache = options.delete(:error_grouping_cache)
-      elsif defined?(Rails)
-        ExceptionNotifier.error_grouping_cache = Rails.cache
+        if options.key?(:error_grouping_cache)
+          en.error_grouping_cache = options.delete(:error_grouping_cache)
+        elsif defined?(Rails) && Rails.respond_to?(:cache)
+          en.error_grouping_cache = Rails.cache
+        end
       end
 
       if options.key?(:ignore_if)
@@ -23,13 +27,17 @@ module ExceptionNotification
         end
       end
 
-      if options.key?(:ignore_crawlers)
-        ignore_crawlers = options.delete(:ignore_crawlers)
-        ExceptionNotifier.ignore_if do |exception, opts|
-          opts.key?(:env) && from_crawler(opts[:env], ignore_crawlers)
+      if options.key?(:ignore_notifier_if)
+        rack_ignore_by_notifier = options.delete(:ignore_notifier_if)
+        rack_ignore_by_notifier.each do |notifier, proc|
+          ExceptionNotifier.ignore_notifier_if(notifier) do |exception, opts|
+            opts.key?(:env) && proc.call(opts[:env], exception)
+          end
         end
       end
 
+      ExceptionNotifier.ignore_crawlers(options.delete(:ignore_crawlers)) if options.key?(:ignore_crawlers)
+
       @ignore_cascade_pass = options.delete(:ignore_cascade_pass) { true }
 
       options.each do |notifier_name, opts|
@@ -38,31 +46,21 @@ module ExceptionNotification
     end
 
     def call(env)
-      _, headers, _ = response = @app.call(env)
+      _, headers, = response = @app.call(env)
 
       if !@ignore_cascade_pass && headers['X-Cascade'] == 'pass'
-        msg = "This exception means that the preceding Rack middleware set the 'X-Cascade' header to 'pass' -- in " <<
-          "Rails, this often means that the route was not found (404 error)."
+        msg = "This exception means that the preceding Rack middleware set the 'X-Cascade' header to 'pass' -- in " \
+              'Rails, this often means that the route was not found (404 error).'
         raise CascadePassException, msg
       end
 
       response
-    rescue Exception => exception
-      if ExceptionNotifier.notify_exception(exception, :env => env)
-        env['exception_notifier.delivered'] = true
-      end
-
-      raise exception unless exception.is_a?(CascadePassException)
-      response
-    end
+    rescue Exception => e
+      env['exception_notifier.delivered'] = true if ExceptionNotifier.notify_exception(e, env: env)
 
-    private
+      raise e unless e.is_a?(CascadePassException)
 
-    def from_crawler(env, ignored_crawlers)
-      agent = env['HTTP_USER_AGENT']
-      Array(ignored_crawlers).any? do |crawler|
-        agent =~ Regexp.new(crawler)
-      end
+      response
     end
   end
 end

data/lib/exception_notification/rails.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ExceptionNotification
   class Engine < ::Rails::Engine
     config.exception_notification = ExceptionNotifier