exception_notification 3.0.1 → 4.4.0

data/lib/exception_notification/rails.rb

@@ -0,0 +1,9 @@
+module ExceptionNotification
+  class Engine < ::Rails::Engine
+    config.exception_notification = ExceptionNotifier
+    config.exception_notification.logger = Rails.logger
+    config.exception_notification.error_grouping_cache = Rails.cache
+
+    config.app_middleware.use ExceptionNotification::Rack
+  end
+end

data/lib/exception_notification/resque.rb

@@ -0,0 +1,22 @@
+require 'resque/failure/base'
+
+module ExceptionNotification
+  class Resque < Resque::Failure::Base
+    def self.count
+      ::Resque::Stat[:failed]
+    end
+
+    def save
+      data = {
+        error_class: exception.class.name,
+        error_message: exception.message,
+        failed_at: Time.now.to_s,
+        payload: payload,
+        queue: queue,
+        worker: worker.to_s
+      }
+
+      ExceptionNotifier.notify_exception(exception, data: { resque: data })
+    end
+  end
+end

data/lib/exception_notification/sidekiq.rb

@@ -0,0 +1,27 @@
+require 'sidekiq'
+
+# Note: this class is only needed for Sidekiq version < 3.
+module ExceptionNotification
+  class Sidekiq
+    def call(_worker, msg, _queue)
+      yield
+    rescue Exception => exception
+      ExceptionNotifier.notify_exception(exception, data: { sidekiq: msg })
+      raise exception
+    end
+  end
+end
+
+if ::Sidekiq::VERSION < '3'
+  ::Sidekiq.configure_server do |config|
+    config.server_middleware do |chain|
+      chain.add ::ExceptionNotification::Sidekiq
+    end
+  end
+else
+  ::Sidekiq.configure_server do |config|
+    config.error_handlers << proc do |ex, context|
+      ExceptionNotifier.notify_exception(ex, data: { sidekiq: context })
+    end
+  end
+end

data/lib/exception_notification/version.rb

@@ -0,0 +1,3 @@
+module ExceptionNotification
+  VERSION = '4.4.0'.freeze
+end

data/lib/exception_notifier.rb

@@ -1,75 +1,151 @@
-require 'action_dispatch'
-require 'exception_notifier/notifier'
-require 'exception_notifier/campfire_notifier'
+require 'logger'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'exception_notifier/base_notifier'
+require 'exception_notifier/modules/error_grouping'
 
-class ExceptionNotifier
+module ExceptionNotifier
+  include ErrorGrouping
 
-  def self.default_ignore_exceptions
-    [].tap do |exceptions|
-      exceptions << 'ActiveRecord::RecordNotFound'
-      exceptions << 'AbstractController::ActionNotFound'
-      exceptions << 'ActionController::RoutingError'
+  autoload :BacktraceCleaner, 'exception_notifier/modules/backtrace_cleaner'
+  autoload :Formatter, 'exception_notifier/modules/formatter'
+
+  autoload :Notifier, 'exception_notifier/notifier'
+  autoload :EmailNotifier, 'exception_notifier/email_notifier'
+  autoload :CampfireNotifier, 'exception_notifier/campfire_notifier'
+  autoload :HipchatNotifier, 'exception_notifier/hipchat_notifier'
+  autoload :WebhookNotifier, 'exception_notifier/webhook_notifier'
+  autoload :IrcNotifier, 'exception_notifier/irc_notifier'
+  autoload :SlackNotifier, 'exception_notifier/slack_notifier'
+  autoload :MattermostNotifier, 'exception_notifier/mattermost_notifier'
+  autoload :TeamsNotifier, 'exception_notifier/teams_notifier'
+  autoload :SnsNotifier, 'exception_notifier/sns_notifier'
+  autoload :GoogleChatNotifier, 'exception_notifier/google_chat_notifier'
+  autoload :DatadogNotifier, 'exception_notifier/datadog_notifier'
+
+  class UndefinedNotifierError < StandardError; end
+
+  # Define logger
+  mattr_accessor :logger
+  @@logger = Logger.new(STDOUT)
+
+  # Define a set of exceptions to be ignored, ie, dont send notifications when any of them are raised.
+  mattr_accessor :ignored_exceptions
+  @@ignored_exceptions = %w[ActiveRecord::RecordNotFound Mongoid::Errors::DocumentNotFound AbstractController::ActionNotFound ActionController::RoutingError ActionController::UnknownFormat ActionController::UrlGenerationError]
+
+  mattr_accessor :testing_mode
+  @@testing_mode = false
+
+  class << self
+    # Store conditions that decide when exceptions must be ignored or not.
+    @@ignores = []
+
+    # Store notifiers that send notifications when exceptions are raised.
+    @@notifiers = {}
+
+    def testing_mode!
+      self.testing_mode = true
     end
-  end
 
-  def self.default_ignore_crawlers
-    []
-  end
+    def notify_exception(exception, options = {}, &block)
+      return false if ignored_exception?(options[:ignore_exceptions], exception)
+      return false if ignored?(exception, options)
 
-  def initialize(app, options = {})
-    @app, @options = app, options
-
-    Notifier.default_sender_address       = @options[:sender_address]
-    Notifier.default_exception_recipients = @options[:exception_recipients]
-    Notifier.default_email_prefix         = @options[:email_prefix]
-    Notifier.default_email_format         = @options[:email_format]
-    Notifier.default_sections             = @options[:sections]
-    Notifier.default_background_sections  = @options[:background_sections]
-    Notifier.default_verbose_subject      = @options[:verbose_subject]
-    Notifier.default_normalize_subject    = @options[:normalize_subject]
-    Notifier.default_smtp_settings        = @options[:smtp_settings]
-    Notifier.default_email_headers        = @options[:email_headers]
-
-    @campfire = CampfireNotifier.new @options[:campfire]
-
-    @options[:ignore_exceptions] ||= self.class.default_ignore_exceptions
-    @options[:ignore_crawlers]   ||= self.class.default_ignore_crawlers
-    @options[:ignore_if]         ||= lambda { |env, e| false }
-  end
+      if error_grouping
+        errors_count = group_error!(exception, options)
+        return false unless send_notification?(exception, errors_count)
+      end
 
-  def call(env)
-    @app.call(env)
-  rescue Exception => exception
-    options = (env['exception_notifier.options'] ||= Notifier.default_options)
-    options.reverse_merge!(@options)
-
-    unless ignored_exception(options[:ignore_exceptions], exception)       ||
-           from_crawler(options[:ignore_crawlers], env['HTTP_USER_AGENT']) ||
-           conditionally_ignored(options[:ignore_if], env, exception)
-      Notifier.exception_notification(env, exception).deliver
-      @campfire.exception_notification(exception)
-      env['exception_notifier.delivered'] = true
+      selected_notifiers = options.delete(:notifiers) || notifiers
+      [*selected_notifiers].each do |notifier|
+        fire_notification(notifier, exception, options.dup, &block)
+      end
+      true
     end
 
-    raise exception
-  end
+    def register_exception_notifier(name, notifier_or_options)
+      if notifier_or_options.respond_to?(:call)
+        @@notifiers[name] = notifier_or_options
+      elsif notifier_or_options.is_a?(Hash)
+        create_and_register_notifier(name, notifier_or_options)
+      else
+        raise ArgumentError, "Invalid notifier '#{name}' defined as #{notifier_or_options.inspect}"
+      end
+    end
+    alias add_notifier register_exception_notifier
 
-  private
+    def unregister_exception_notifier(name)
+      @@notifiers.delete(name)
+    end
 
-  def ignored_exception(ignore_array, exception)
-    Array.wrap(ignore_array).map(&:to_s).include?(exception.class.name)
-  end
+    def registered_exception_notifier(name)
+      @@notifiers[name]
+    end
 
-  def from_crawler(ignore_array, agent)
-    ignore_array.each do |crawler|
-      return true if (agent =~ Regexp.new(crawler))
-    end unless ignore_array.blank?
-    false
-  end
+    def notifiers
+      @@notifiers.keys
+    end
 
-  def conditionally_ignored(ignore_proc, env, exception)
-    ignore_proc.call(env, exception)
-  rescue Exception => ex
-    false
+    # Adds a condition to decide when an exception must be ignored or not.
+    #
+    #   ExceptionNotifier.ignore_if do |exception, options|
+    #     not Rails.env.production?
+    #   end
+    def ignore_if(&block)
+      @@ignores << block
+    end
+
+    def ignore_crawlers(crawlers)
+      ignore_if do |_exception, opts|
+        opts.key?(:env) && from_crawler(opts[:env], crawlers)
+      end
+    end
+
+    def clear_ignore_conditions!
+      @@ignores.clear
+    end
+
+    private
+
+    def ignored?(exception, options)
+      @@ignores.any? { |condition| condition.call(exception, options) }
+    rescue Exception => e
+      raise e if @@testing_mode
+
+      logger.warn "An error occurred when evaluating an ignore condition. #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+      false
+    end
+
+    def ignored_exception?(ignore_array, exception)
+      all_ignored_exceptions = (Array(ignored_exceptions) + Array(ignore_array)).map(&:to_s)
+      exception_ancestors = exception.class.ancestors.map(&:to_s)
+      !(all_ignored_exceptions & exception_ancestors).empty?
+    end
+
+    def fire_notification(notifier_name, exception, options, &block)
+      notifier = registered_exception_notifier(notifier_name)
+      notifier.call(exception, options, &block)
+    rescue Exception => e
+      raise e if @@testing_mode
+
+      logger.warn "An error occurred when sending a notification using '#{notifier_name}' notifier. #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}"
+      false
+    end
+
+    def create_and_register_notifier(name, options)
+      notifier_classname = "#{name}_notifier".camelize
+      notifier_class = ExceptionNotifier.const_get(notifier_classname)
+      notifier = notifier_class.new(options)
+      register_exception_notifier(name, notifier)
+    rescue NameError => e
+      raise UndefinedNotifierError, "No notifier named '#{name}' was found. Please, revise your configuration options. Cause: #{e.message}"
+    end
+
+    def from_crawler(env, ignored_crawlers)
+      agent = env['HTTP_USER_AGENT']
+      Array(ignored_crawlers).any? do |crawler|
+        agent =~ Regexp.new(crawler)
+      end
+    end
   end
 end

data/lib/exception_notifier/base_notifier.rb

@@ -0,0 +1,24 @@
+module ExceptionNotifier
+  class BaseNotifier
+    attr_accessor :base_options
+
+    def initialize(options = {})
+      @base_options = options
+    end
+
+    def send_notice(exception, options, message, message_opts = nil)
+      _pre_callback(exception, options, message, message_opts)
+      result = yield(message, message_opts)
+      _post_callback(exception, options, message, message_opts)
+      result
+    end
+
+    def _pre_callback(exception, options, message, message_opts)
+      @base_options[:pre_callback].call(options, self, exception.backtrace, message, message_opts) if @base_options[:pre_callback].respond_to?(:call)
+    end
+
+    def _post_callback(exception, options, message, message_opts)
+      @base_options[:post_callback].call(options, self, exception.backtrace, message, message_opts) if @base_options[:post_callback].respond_to?(:call)
+    end
+  end
+end

data/lib/exception_notifier/campfire_notifier.rb

@@ -1,26 +1,33 @@
-class ExceptionNotifier
-  class CampfireNotifier
-    cattr_accessor :tinder_available, true
-
+module ExceptionNotifier
+  class CampfireNotifier < BaseNotifier
     attr_accessor :subdomain
     attr_accessor :token
     attr_accessor :room
 
     def initialize(options)
+      super
       begin
-        return unless tinder_available
-
         subdomain = options.delete(:subdomain)
         room_name = options.delete(:room_name)
         @campfire = Tinder::Campfire.new subdomain, options
         @room     = @campfire.find_room_by_name room_name
-      rescue
+      rescue StandardError
         @campfire = @room = nil
       end
     end
 
-    def exception_notification(exception)
-      @room.paste "A new exception occurred: '#{exception.message}' on '#{exception.backtrace.first}'" if active?
+    def call(exception, options = {})
+      return unless active?
+
+      message = if options[:accumulated_errors_count].to_i > 1
+                  "The exception occurred #{options[:accumulated_errors_count]} times: '#{exception.message}'"
+                else
+                  "A new exception occurred: '#{exception.message}'"
+                end
+      message += " on '#{exception.backtrace.first}'" if exception.backtrace
+      send_notice(exception, options, message) do |msg, _|
+        @room.paste msg
+      end
     end
 
     private
@@ -30,5 +37,3 @@ class ExceptionNotifier
     end
   end
 end
-
-ExceptionNotifier::CampfireNotifier.tinder_available = Gem.loaded_specs.keys.include? 'tinder'

data/lib/exception_notifier/datadog_notifier.rb

@@ -0,0 +1,153 @@
+require 'action_dispatch'
+
+module ExceptionNotifier
+  class DatadogNotifier < BaseNotifier
+    attr_reader :client,
+                :default_options
+
+    def initialize(options)
+      super
+      @client = options.fetch(:client)
+      @default_options = options
+    end
+
+    def call(exception, options = {})
+      client.emit_event(
+        datadog_event(exception, options)
+      )
+    end
+
+    def datadog_event(exception, options = {})
+      DatadogExceptionEvent.new(
+        exception,
+        options.reverse_merge(default_options)
+      ).event
+    end
+
+    class DatadogExceptionEvent
+      include ExceptionNotifier::BacktraceCleaner
+
+      MAX_TITLE_LENGTH = 120
+      MAX_VALUE_LENGTH = 300
+      MAX_BACKTRACE_SIZE = 3
+      ALERT_TYPE = 'error'.freeze
+
+      attr_reader :exception,
+                  :options
+
+      def initialize(exception, options)
+        @exception = exception
+        @options = options
+      end
+
+      def request
+        @request ||= ActionDispatch::Request.new(options[:env]) if options[:env]
+      end
+
+      def controller
+        @controller ||= options[:env] && options[:env]['action_controller.instance']
+      end
+
+      def backtrace
+        @backtrace ||= exception.backtrace ? clean_backtrace(exception) : []
+      end
+
+      def tags
+        options[:tags] || []
+      end
+
+      def title_prefix
+        options[:title_prefix] || ''
+      end
+
+      def event
+        title = formatted_title
+        body = formatted_body
+
+        Dogapi::Event.new(
+          body,
+          msg_title: title,
+          alert_type: ALERT_TYPE,
+          tags: tags,
+          aggregation_key: [title]
+        )
+      end
+
+      def formatted_title
+        title = ''
+        title << title_prefix
+        title << "#{controller.controller_name} #{controller.action_name}" if controller
+        title << " (#{exception.class})"
+        title << " #{exception.message.inspect}"
+
+        truncate(title, MAX_TITLE_LENGTH)
+      end
+
+      def formatted_body
+        text = []
+
+        text << '%%%'
+        text << formatted_request if request
+        text << formatted_session if request
+        text << formatted_backtrace
+        text << '%%%'
+
+        text.join("\n")
+      end
+
+      def formatted_key_value(key, value)
+        "**#{key}:** #{value}"
+      end
+
+      def formatted_request
+        text = []
+        text << '### **Request**'
+        text << formatted_key_value('URL', request.url)
+        text << formatted_key_value('HTTP Method', request.request_method)
+        text << formatted_key_value('IP Address', request.remote_ip)
+        text << formatted_key_value('Parameters', request.filtered_parameters.inspect)
+        text << formatted_key_value('Timestamp', Time.current)
+        text << formatted_key_value('Server', Socket.gethostname)
+        if defined?(Rails) && Rails.respond_to?(:root)
+          text << formatted_key_value('Rails root', Rails.root)
+        end
+        text << formatted_key_value('Process', $PROCESS_ID)
+        text << '___'
+        text.join("\n")
+      end
+
+      def formatted_session
+        text = []
+        text << '### **Session**'
+        text << formatted_key_value('Data', request.session.to_hash)
+        text << '___'
+        text.join("\n")
+      end
+
+      def formatted_backtrace
+        size = [backtrace.size, MAX_BACKTRACE_SIZE].min
+
+        text = []
+        text << '### **Backtrace**'
+        text << '````'
+        size.times { |i| text << backtrace[i] }
+        text << '````'
+        text << '___'
+        text.join("\n")
+      end
+
+      def truncate(string, max)
+        string.length > max ? "#{string[0...max]}..." : string
+      end
+
+      def inspect_object(object)
+        case object
+        when Hash, Array
+          truncate(object.inspect, MAX_VALUE_LENGTH)
+        else
+          object.to_s
+        end
+      end
+    end
+  end
+end