exception_notification 4.2.0 → 4.4.1

data/lib/exception_notifier/google_chat_notifier.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+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

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module ExceptionNotifier
   class HipchatNotifier < BaseNotifier
-
     attr_accessor :from
     attr_accessor :room
     attr_accessor :message_options
@@ -11,26 +12,31 @@ module ExceptionNotifier
         api_token         = options.delete(:api_token)
         room_name         = options.delete(:room_name)
         opts              = {
-                              :api_version => options.delete(:api_version) || 'v1'
-                            }
+          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) || ->(exception) {
-          msg = "A new exception occurred: '#{Rack::Utils.escape_html(exception.message)}'"
+        @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 = options
         @message_options[:color] ||= 'red'
-      rescue
+      rescue StandardError
         @room = nil
       end
     end
 
-    def call(exception, options={})
-      return if !active?
+    def call(exception, options = {})
+      return unless active?
 
-      message = @message_template.call(exception)
+      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

data/lib/exception_notifier/irc_notifier.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ExceptionNotifier
   class IrcNotifier < BaseNotifier
     def initialize(options)
@@ -6,46 +8,51 @@ module ExceptionNotifier
       parse_options(options)
     end
 
-    def call(exception, options={})
-      message = "'#{exception.message}'"
+    def call(exception, options = {})
+      errors_count = options[:accumulated_errors_count].to_i
+
+      occurrences = "(#{errors_count} times)" if errors_count > 1
+      message = "#{occurrences}'#{exception.message}'"
       message += " on '#{exception.backtrace.first}'" if exception.backtrace
-      if active?
-        send_notice(exception, options, message) do |msg, _|
-          send_message([*@config.prefix, *msg].join(' '))
-        end
+
+      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})
+      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 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
 
-      def valid_uri?(uri)
-        !!URI.parse(uri)
-      rescue URI::InvalidURIError
-        false
-      end
+      @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

@@ -1,159 +1,82 @@
-require 'action_dispatch'
-require 'active_support/core_ext/time'
+# frozen_string_literal: true
 
-module ExceptionNotifier
-  class MattermostNotifier
-    include ExceptionNotifier::BacktraceCleaner
-
-    attr_accessor :httparty
-
-    def initialize(options = {})
-      super()
-      @default_options = options
-      @httparty = HTTParty
-    end
+require 'httparty'
 
-    def call(exception, options = {})
-      @options = options.merge(@default_options)
+module ExceptionNotifier
+  class MattermostNotifier < BaseNotifier
+    def call(exception, opts = {})
+      options = opts.merge(base_options)
       @exception = exception
-      @backtrace = exception.backtrace ? clean_backtrace(exception) : nil
-
-      @env = @options.delete(:env)
 
-      @application_name = @options.delete(:app_name) || Rails.application.class.parent_name.underscore
-      @gitlab_url = @options.delete(:git_url)
-      @username = @options.delete(:username) || "Exception Notifier"
-      @avatar = @options.delete(:avatar)
+      @formatter = Formatter.new(exception, options)
 
-      @channel = @options.delete(:channel)
-      @webhook_url = @options.delete(:webhook_url)
-      raise ArgumentError.new "You must provide 'webhook_url' parameter." unless @webhook_url
+      @gitlab_url = options[:git_url]
 
-      unless @env.nil?
-        @controller = @env['action_controller.instance'] || MissingController.new
+      @env = options[:env] || {}
 
-        request = ActionDispatch::Request.new(@env)
+      payload = {
+        text: message_text.compact.join("\n"),
+        username: options[:username] || 'Exception Notifier'
+      }
 
-        @request_items = { url: request.original_url,
-                           http_method: request.method,
-                           ip_address: request.remote_ip,
-                           parameters: request.filtered_parameters,
-                           timestamp: Time.current }
-
-        if request.session["warden.user.user.key"]
-          current_user = User.find(request.session["warden.user.user.key"][0][0])
-          @request_items.merge!({ current_user: { id: current_user.id, email: current_user.email  } })
-        end
-      else
-        @controller = @request_items = nil
-      end
+      payload[:icon_url] = options[:avatar] if options[:avatar]
+      payload[:channel] = options[:channel] if options[:channel]
 
-      payload = message_text.merge(user_info).merge(channel_info)
+      httparty_options = options.except(
+        :avatar, :channel, :username, :git_url, :webhook_url,
+        :env, :accumulated_errors_count, :app_name
+      )
 
-      @options[:body] = payload.to_json
-      @options[:headers] ||= {}
-      @options[:headers].merge!({ 'Content-Type' => 'application/json' })
+      httparty_options[:body] = payload.to_json
+      httparty_options[:headers] ||= {}
+      httparty_options[:headers]['Content-Type'] = 'application/json'
 
-      @httparty.post(@webhook_url, @options)
+      HTTParty.post(options[:webhook_url], httparty_options)
     end
 
     private
 
-      def channel_info
-        if @channel
-          { channel: @channel }
-        else
-          {}
-        end
-      end
-
-      def user_info
-        infos = {}
-
-        infos.merge!({ username: @username }) if @username
-        infos.merge!({ icon_url: @avatar }) if @avatar
-
-        infos
-      end
-
-      def message_text
-        text = []
-
-        text += ["@channel"]
-        text += message_header
-        text += message_request if @request_items
-        text += message_backtrace if @backtrace
-        text += message_issue_link if @gitlab_url
-
-        { text: text.join("\n") }
-      end
-
-      def message_header
-        text = []
-
-        text << "### :warning: Error 500 in #{Rails.env} :warning:"
-        text << "An *#{@exception.class}* occured" + if @controller then " in *#{controller_and_method}*." else "." end
-        text << "*#{@exception.message}*"
-
-        text
-      end
-
-      def message_request
-        text = []
-
-        text << "### Request"
-        text << "```"
-        text << hash_presentation(@request_items)
-        text << "```"
-
-        text
-      end
-
-      def message_backtrace(size = 3)
-        text = []
+    attr_reader :formatter
 
-        size = @backtrace.size < size ? @backtrace.size : size
-        text << "### Backtrace"
-        text << "```"
-        size.times { |i| text << "* " + @backtrace[i] }
-        text << "```"
+    def message_text
+      text = [
+        '@channel',
+        "### #{formatter.title}",
+        formatter.subtitle,
+        "*#{@exception.message}*"
+      ]
 
-        text
+      if (request = formatter.request_message.presence)
+        text << '### Request'
+        text << request
       end
 
-      def message_issue_link
-        text = []
-
-        link = [@gitlab_url, @application_name, "issues", "new"].join("/")
-        params = {
-          "issue[title]" => ["[BUG] Error 500 :",
-                                       controller_and_method,
-                                       "(#{@exception.class})",
-                                       @exception.message].compact.join(" ")
-        }.to_query
-
-        text << "[Create an issue](#{link}/?#{params})"
-
-        text
+      if (backtrace = formatter.backtrace_message.presence)
+        text << '### Backtrace'
+        text << backtrace
       end
 
-      def controller_and_method
-        if @controller
-          "#{@controller.controller_name}##{@controller.action_name}"
-        else
-          ""
-        end
+      if (exception_data = @env['exception_notifier.exception_data'])
+        text << '### Data'
+        data_string = exception_data.map { |k, v| "* #{k} : #{v}" }.join("\n")
+        text << "```\n#{data_string}\n```"
       end
 
-      def hash_presentation(hash)
-        text = []
+      text << message_issue_link if @gitlab_url
 
-        hash.each do |key, value|
-          text << "* #{key} : #{value}"
-        end
+      text
+    end
 
-        text.join("\n")
-      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

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module ExceptionNotifier
   module BacktraceCleaner
-
     def clean_backtrace(exception)
       if defined?(Rails) && Rails.respond_to?(:backtrace_cleaner)
         Rails.backtrace_cleaner.send(:filter, exception.backtrace)
@@ -8,6 +9,5 @@ module ExceptionNotifier
         exception.backtrace
       end
     end
-
   end
 end

data/lib/exception_notifier/modules/error_grouping.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+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
+            log_cache_error(error_grouping_cache, e, :read)
+            fallback_cache_store.read(error_key)
+          end
+
+        count&.to_i
+      end
+
+      def save_error_count(error_key, count)
+        error_grouping_cache.write(error_key, count, expires_in: error_grouping_period)
+      rescue StandardError => e
+        log_cache_error(error_grouping_cache, e, :write)
+        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
+
+      private
+
+      def log_cache_error(cache, exception, action)
+        "#{cache.inspect} failed to #{action}, reason: #{exception.message}. Falling back to memory cache store."
+      end
+    end
+  end
+end