exception_notification 3.0.1 → 4.4.0

data/lib/exception_notifier/email_notifier.rb

@@ -0,0 +1,196 @@
+require 'active_support/core_ext/time'
+require 'action_mailer'
+require 'action_dispatch'
+require 'pp'
+
+module ExceptionNotifier
+  class EmailNotifier < BaseNotifier
+    DEFAULT_OPTIONS = {
+      sender_address: %("Exception Notifier" <exception.notifier@example.com>),
+      exception_recipients: [],
+      email_prefix: '[ERROR] ',
+      email_format: :text,
+      sections: %w[request session environment backtrace],
+      background_sections: %w[backtrace data],
+      verbose_subject: true,
+      normalize_subject: false,
+      include_controller_and_action_names_in_subject: true,
+      delivery_method: nil,
+      mailer_settings: nil,
+      email_headers: {},
+      mailer_parent: 'ActionMailer::Base',
+      template_path: 'exception_notifier',
+      deliver_with: nil
+    }.freeze
+
+    module Mailer
+      class MissingController
+        def method_missing(*args, &block); end
+      end
+
+      def self.extended(base)
+        base.class_eval do
+          send(:include, ExceptionNotifier::BacktraceCleaner)
+
+          # Append application view path to the ExceptionNotifier lookup context.
+          append_view_path "#{File.dirname(__FILE__)}/views"
+
+          def exception_notification(env, exception, options = {}, default_options = {})
+            load_custom_views
+
+            @env        = env
+            @exception  = exception
+
+            env_options = env['exception_notifier.options'] || {}
+            @options    = default_options.merge(env_options).merge(options)
+
+            @kontroller = env['action_controller.instance'] || MissingController.new
+            @request    = ActionDispatch::Request.new(env)
+            @backtrace  = exception.backtrace ? clean_backtrace(exception) : []
+            @timestamp  = Time.current
+            @sections   = @options[:sections]
+            @data       = (env['exception_notifier.exception_data'] || {}).merge(options[:data] || {})
+            @sections += %w[data] unless @data.empty?
+
+            compose_email
+          end
+
+          def background_exception_notification(exception, options = {}, default_options = {})
+            load_custom_views
+
+            @exception = exception
+            @options   = default_options.merge(options).symbolize_keys
+            @backtrace = exception.backtrace || []
+            @timestamp = Time.current
+            @sections  = @options[:background_sections]
+            @data      = options[:data] || {}
+            @env = @kontroller = nil
+
+            compose_email
+          end
+
+          private
+
+          def compose_subject
+            subject = @options[:email_prefix].to_s.dup
+            subject << "(#{@options[:accumulated_errors_count]} times)" if @options[:accumulated_errors_count].to_i > 1
+            subject << "#{@kontroller.controller_name} #{@kontroller.action_name}" if @kontroller && @options[:include_controller_and_action_names_in_subject]
+            subject << " (#{@exception.class})"
+            subject << " #{@exception.message.inspect}" if @options[:verbose_subject]
+            subject = EmailNotifier.normalize_digits(subject) if @options[:normalize_subject]
+            subject.length > 120 ? subject[0...120] + '...' : subject
+          end
+
+          def set_data_variables
+            @data.each do |name, value|
+              instance_variable_set("@#{name}", value)
+            end
+          end
+
+          helper_method :inspect_object
+
+          def truncate(string, max)
+            string.length > max ? "#{string[0...max]}..." : string
+          end
+
+          def inspect_object(object)
+            case object
+            when Hash, Array
+              truncate(object.inspect, 300)
+            else
+              object.to_s
+            end
+          end
+
+          helper_method :safe_encode
+
+          def safe_encode(value)
+            value.encode('utf-8', invalid: :replace, undef: :replace, replace: '_')
+          end
+
+          def html_mail?
+            @options[:email_format] == :html
+          end
+
+          def compose_email
+            set_data_variables
+            subject = compose_subject
+            name = @env.nil? ? 'background_exception_notification' : 'exception_notification'
+            exception_recipients = maybe_call(@options[:exception_recipients])
+
+            headers = {
+              delivery_method: @options[:delivery_method],
+              to: exception_recipients,
+              from: @options[:sender_address],
+              subject: subject,
+              template_name: name
+            }.merge(@options[:email_headers])
+
+            mail = mail(headers) do |format|
+              format.text
+              format.html if html_mail?
+            end
+
+            mail.delivery_method.settings.merge!(@options[:mailer_settings]) if @options[:mailer_settings]
+
+            mail
+          end
+
+          def load_custom_views
+            prepend_view_path Rails.root.nil? ? 'app/views' : "#{Rails.root}/app/views" if defined?(Rails) && Rails.respond_to?(:root)
+          end
+
+          def maybe_call(maybe_proc)
+            maybe_proc.respond_to?(:call) ? maybe_proc.call : maybe_proc
+          end
+        end
+      end
+    end
+
+    def initialize(options)
+      super
+
+      delivery_method = (options[:delivery_method] || :smtp)
+      mailer_settings_key = "#{delivery_method}_settings".to_sym
+      options[:mailer_settings] = options.delete(mailer_settings_key)
+
+      @base_options = DEFAULT_OPTIONS.merge(options)
+    end
+
+    def call(exception, options = {})
+      message = create_email(exception, options)
+
+      message.send(base_options[:deliver_with] || default_deliver_with(message))
+    end
+
+    def create_email(exception, options = {})
+      env = options[:env]
+
+      send_notice(exception, options, nil, base_options) do |_, default_opts|
+        if env.nil?
+          mailer.background_exception_notification(exception, options, default_opts)
+        else
+          mailer.exception_notification(env, exception, options, default_opts)
+        end
+      end
+    end
+
+    def self.normalize_digits(string)
+      string.gsub(/[0-9]+/, 'N')
+    end
+
+    private
+
+    def mailer
+      @mailer ||= Class.new(base_options[:mailer_parent].constantize).tap do |mailer|
+        mailer.extend(EmailNotifier::Mailer)
+        mailer.mailer_name = base_options[:template_path]
+      end
+    end
+
+    def default_deliver_with(message)
+      # FIXME: use `if Gem::Version.new(ActionMailer::VERSION::STRING) < Gem::Version.new('4.1')`
+      message.respond_to?(:deliver_now) ? :deliver_now : :deliver
+    end
+  end
+end

data/lib/exception_notifier/google_chat_notifier.rb

@@ -0,0 +1,42 @@
+require 'httparty'
+
+module ExceptionNotifier
+  class GoogleChatNotifier < BaseNotifier
+    def call(exception, opts = {})
+      options = base_options.merge(opts)
+      formatter = Formatter.new(exception, options)
+
+      HTTParty.post(
+        options[:webhook_url],
+        body: { text: body(exception, formatter) }.to_json,
+        headers: { 'Content-Type' => 'application/json' }
+      )
+    end
+
+    private
+
+    def body(exception, formatter)
+      text = [
+        "\nApplication: *#{formatter.app_name}*",
+        formatter.subtitle,
+        '',
+        formatter.title,
+        "*#{exception.message.tr('`', "'")}*"
+      ]
+
+      if (request = formatter.request_message.presence)
+        text << ''
+        text << '*Request:*'
+        text << request
+      end
+
+      if (backtrace = formatter.backtrace_message.presence)
+        text << ''
+        text << '*Backtrace:*'
+        text << backtrace
+      end
+
+      text.compact.join("\n")
+    end
+  end
+end

data/lib/exception_notifier/hipchat_notifier.rb

@@ -0,0 +1,49 @@
+module ExceptionNotifier
+  class HipchatNotifier < BaseNotifier
+    attr_accessor :from
+    attr_accessor :room
+    attr_accessor :message_options
+
+    def initialize(options)
+      super
+      begin
+        api_token         = options.delete(:api_token)
+        room_name         = options.delete(:room_name)
+        opts              = {
+          api_version: options.delete(:api_version) || 'v1'
+        }
+        opts[:server_url] = options.delete(:server_url) if options[:server_url]
+        @from             = options.delete(:from) || 'Exception'
+        @room             = HipChat::Client.new(api_token, opts)[room_name]
+        @message_template = options.delete(:message_template) || lambda { |exception, errors_count|
+          msg = if errors_count > 1
+                  "The exception occurred #{errors_count} times: '#{Rack::Utils.escape_html(exception.message)}'"
+                else
+                  "A new exception occurred: '#{Rack::Utils.escape_html(exception.message)}'"
+                end
+          msg += " on '#{exception.backtrace.first}'" if exception.backtrace
+          msg
+        }
+        @message_options = options
+        @message_options[:color] ||= 'red'
+      rescue StandardError
+        @room = nil
+      end
+    end
+
+    def call(exception, options = {})
+      return unless active?
+
+      message = @message_template.call(exception, options[:accumulated_errors_count].to_i)
+      send_notice(exception, options, message, @message_options) do |msg, message_opts|
+        @room.send(@from, msg, message_opts)
+      end
+    end
+
+    private
+
+    def active?
+      !@room.nil?
+    end
+  end
+end

data/lib/exception_notifier/irc_notifier.rb

@@ -0,0 +1,57 @@
+module ExceptionNotifier
+  class IrcNotifier < BaseNotifier
+    def initialize(options)
+      super
+      @config = OpenStruct.new
+      parse_options(options)
+    end
+
+    def call(exception, options = {})
+      errors_count = options[:accumulated_errors_count].to_i
+
+      message = "'#{exception.message}'"
+      message.prepend("(#{errors_count} times)") if errors_count > 1
+
+      message += " on '#{exception.backtrace.first}'" if exception.backtrace
+
+      return unless active?
+
+      send_notice(exception, options, message) do |msg, _|
+        send_message([*@config.prefix, *msg].join(' '))
+      end
+    end
+
+    def send_message(message)
+      CarrierPigeon.send @config.irc.merge(message: message)
+    end
+
+    private
+
+    def parse_options(options)
+      nick = options.fetch(:nick, 'ExceptionNotifierBot')
+      password = options[:password] ? ":#{options[:password]}" : nil
+      domain = options.fetch(:domain, nil)
+      port = options[:port] ? ":#{options[:port]}" : nil
+      channel = options.fetch(:channel, '#log')
+      notice = options.fetch(:notice, false)
+      ssl = options.fetch(:ssl, false)
+      join = options.fetch(:join, false)
+      uri = "irc://#{nick}#{password}@#{domain}#{port}/#{channel}"
+      prefix = options.fetch(:prefix, nil)
+      recipients = options[:recipients] ? options[:recipients].join(', ') + ':' : nil
+
+      @config.prefix = [*prefix, *recipients].join(' ')
+      @config.irc = { uri: uri, ssl: ssl, notice: notice, join: join }
+    end
+
+    def active?
+      valid_uri? @config.irc[:uri]
+    end
+
+    def valid_uri?(uri)
+      URI.parse(uri)
+    rescue URI::InvalidURIError
+      false
+    end
+  end
+end

data/lib/exception_notifier/mattermost_notifier.rb

@@ -0,0 +1,72 @@
+require 'httparty'
+
+module ExceptionNotifier
+  class MattermostNotifier < BaseNotifier
+    def call(exception, opts = {})
+      options = opts.merge(base_options)
+      @exception = exception
+
+      @formatter = Formatter.new(exception, options)
+
+      @gitlab_url = options[:git_url]
+
+      payload = {
+        text: message_text.compact.join("\n"),
+        username: options[:username] || 'Exception Notifier'
+      }
+
+      payload[:icon_url] = options[:avatar] if options[:avatar]
+      payload[:channel] = options[:channel] if options[:channel]
+
+      httparty_options = options.except(
+        :avatar, :channel, :username, :git_url, :webhook_url,
+        :env, :accumulated_errors_count, :app_name
+      )
+
+      httparty_options[:body] = payload.to_json
+      httparty_options[:headers] ||= {}
+      httparty_options[:headers]['Content-Type'] = 'application/json'
+
+      HTTParty.post(options[:webhook_url], httparty_options)
+    end
+
+    private
+
+    attr_reader :formatter
+
+    def message_text
+      text = [
+        '@channel',
+        "### #{formatter.title}",
+        formatter.subtitle,
+        "*#{@exception.message}*"
+      ]
+
+      if (request = formatter.request_message.presence)
+        text << '### Request'
+        text << request
+      end
+
+      if (backtrace = formatter.backtrace_message.presence)
+        text << '### Backtrace'
+        text << backtrace
+      end
+
+      text << message_issue_link if @gitlab_url
+
+      text
+    end
+
+    def message_issue_link
+      link = [@gitlab_url, formatter.app_name, 'issues', 'new'].join('/')
+      params = {
+        'issue[title]' => ['[BUG] Error 500 :',
+                           formatter.controller_and_action || '',
+                           "(#{@exception.class})",
+                           @exception.message].compact.join(' ')
+      }.to_query
+
+      "[Create an issue](#{link}/?#{params})"
+    end
+  end
+end

data/lib/exception_notifier/modules/backtrace_cleaner.rb

@@ -0,0 +1,11 @@
+module ExceptionNotifier
+  module BacktraceCleaner
+    def clean_backtrace(exception)
+      if defined?(Rails) && Rails.respond_to?(:backtrace_cleaner)
+        Rails.backtrace_cleaner.send(:filter, exception.backtrace)
+      else
+        exception.backtrace
+      end
+    end
+  end
+end

data/lib/exception_notifier/modules/error_grouping.rb

@@ -0,0 +1,77 @@
+require 'active_support/core_ext/numeric/time'
+require 'active_support/concern'
+
+module ExceptionNotifier
+  module ErrorGrouping
+    extend ActiveSupport::Concern
+
+    included do
+      mattr_accessor :error_grouping
+      self.error_grouping = false
+
+      mattr_accessor :error_grouping_period
+      self.error_grouping_period = 5.minutes
+
+      mattr_accessor :notification_trigger
+
+      mattr_accessor :error_grouping_cache
+    end
+
+    module ClassMethods
+      # Fallback to the memory store while the specified cache store doesn't work
+      #
+      def fallback_cache_store
+        @fallback_cache_store ||= ActiveSupport::Cache::MemoryStore.new
+      end
+
+      def error_count(error_key)
+        count = begin
+          error_grouping_cache.read(error_key)
+        rescue StandardError => e
+          ExceptionNotifier.logger.warn("#{error_grouping_cache.inspect} failed to read, reason: #{e.message}. Falling back to memory cache store.")
+          fallback_cache_store.read(error_key)
+        end
+
+        count.to_i if count
+      end
+
+      def save_error_count(error_key, count)
+        error_grouping_cache.write(error_key, count, expires_in: error_grouping_period)
+      rescue StandardError => e
+        ExceptionNotifier.logger.warn("#{error_grouping_cache.inspect} failed to write, reason: #{e.message}. Falling back to memory cache store.")
+        fallback_cache_store.write(error_key, count, expires_in: error_grouping_period)
+      end
+
+      def group_error!(exception, options)
+        message_based_key = "exception:#{Zlib.crc32("#{exception.class.name}\nmessage:#{exception.message}")}"
+        accumulated_errors_count = 1
+
+        if (count = error_count(message_based_key))
+          accumulated_errors_count = count + 1
+          save_error_count(message_based_key, accumulated_errors_count)
+        else
+          backtrace_based_key = "exception:#{Zlib.crc32("#{exception.class.name}\npath:#{exception.backtrace.try(:first)}")}"
+
+          if (count = error_grouping_cache.read(backtrace_based_key))
+            accumulated_errors_count = count + 1
+            save_error_count(backtrace_based_key, accumulated_errors_count)
+          else
+            save_error_count(backtrace_based_key, accumulated_errors_count)
+            save_error_count(message_based_key, accumulated_errors_count)
+          end
+        end
+
+        options[:accumulated_errors_count] = accumulated_errors_count
+      end
+
+      def send_notification?(exception, count)
+        if notification_trigger.respond_to?(:call)
+          notification_trigger.call(exception, count)
+        else
+          factor = Math.log2(count)
+          factor.to_i == factor
+        end
+      end
+    end
+  end
+end