exception_notification 4.3.0 → 4.5.0

data/lib/exception_notifier/google_chat_notifier.rb

@@ -1,136 +1,44 @@
-require 'action_dispatch'
-require 'active_support/core_ext/time'
+# frozen_string_literal: true
 
-module ExceptionNotifier
-  class GoogleChatNotifier
-    include ExceptionNotifier::BacktraceCleaner
-
-    class MissingController
-      def method_missing(*args, &block)
-      end
-    end
-
-    attr_accessor :httparty
-
-    def initialize(options = {})
-      super()
-      @default_options = options
-      @httparty = HTTParty
-    end
-
-    def call(exception, options = {})
-      @options = options.merge(@default_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
-
-      @webhook_url = @options.delete(:webhook_url)
-      raise ArgumentError.new "You must provide 'webhook_url' parameter." unless @webhook_url
+require 'httparty'
 
-      unless @env.nil?
-        @controller = @env['action_controller.instance'] || MissingController.new
-
-        request = ActionDispatch::Request.new(@env)
-
-        @request_items = { url: request.original_url,
-                           http_method: request.method,
-                           ip_address: request.remote_ip,
-                           parameters: request.filtered_parameters,
-                           timestamp: Time.current }
-      else
-        @controller = @request_items = nil
-      end
-
-
-      @options[:body] = payload.to_json
-      @options[:headers] ||= {}
-      @options[:headers].merge!({ 'Content-Type' => 'application/json' })
+module ExceptionNotifier
+  class GoogleChatNotifier < BaseNotifier
+    def call(exception, opts = {})
+      options = base_options.merge(opts)
+      formatter = Formatter.new(exception, options)
 
-      @httparty.post(@webhook_url, @options)
+      HTTParty.post(
+        options[:webhook_url],
+        body: { text: body(exception, formatter) }.to_json,
+        headers: { 'Content-Type' => 'application/json' }
+      )
     end
 
     private
 
-    def payload
-      {
-        text: exception_text
-      }
-    end
-
-    def header
-      errors_count = @options[:accumulated_errors_count].to_i
-      text = ['']
+    def body(exception, formatter)
+      text = [
+        "\nApplication: *#{formatter.app_name}*",
+        formatter.subtitle,
+        '',
+        formatter.title,
+        "*#{exception.message.tr('`', "'")}*"
+      ]
 
-      text << "Application: *#{@application_name}*"
-      text << "#{errors_count > 1 ? errors_count : 'An'} *#{@exception.class}* occured" + if @controller then " in *#{controller_and_method}*." else "." end
-
-      text
-    end
-
-    def exception_text
-      text = []
-
-      text << header
-      text << ''
-
-      text << "⚠️ Error 500 in #{Rails.env} ⚠️"
-      text << "*#{@exception.message.gsub('`', %q('))}*"
-
-      if @request_items
+      if (request = formatter.request_message.presence)
         text << ''
-        text += message_request
+        text << '*Request:*'
+        text << request
       end
 
-      if @backtrace
+      if (backtrace = formatter.backtrace_message.presence)
         text << ''
-        text += message_backtrace
-      end
-
-      text.join("\n")
-    end
-
-    def message_request
-      text = []
-
-      text << "*Request:*"
-      text << "```"
-      text << hash_presentation(@request_items)
-      text << "```"
-
-      text
-    end
-
-    def hash_presentation(hash)
-      text = []
-
-      hash.each do |key, value|
-        text << "* #{key} : #{value}"
+        text << '*Backtrace:*'
+        text << backtrace
       end
 
-      text.join("\n")
-    end
-
-    def message_backtrace(size = 3)
-      text = []
-
-      size = @backtrace.size < size ? @backtrace.size : size
-      text << "*Backtrace:*"
-      text << "```"
-      size.times { |i| text << "* " + @backtrace[i] }
-      text << "```"
-
-      text
-    end
-
-    def controller_and_method
-      if @controller
-        "#{@controller.controller_name}##{@controller.action_name}"
-      else
-        ""
-      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,29 +12,29 @@ 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, errors_count) {
+        @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
+                  "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, options[:accumulated_errors_count].to_i)
       send_notice(exception, options, message, @message_options) do |msg, message_opts|

data/lib/exception_notifier/irc_notifier.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ExceptionNotifier
   class IrcNotifier < BaseNotifier
     def initialize(options)
@@ -6,50 +8,51 @@ module ExceptionNotifier
       parse_options(options)
     end
 
-    def call(exception, options={})
+    def call(exception, options = {})
       errors_count = options[:accumulated_errors_count].to_i
 
-      message = "'#{exception.message}'"
-      message.prepend("(#{errors_count} times)") if errors_count > 1
-
+      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
+
+      @config.prefix = [*prefix, *recipients].join(' ')
+      @config.irc = { uri: uri, ssl: ssl, notice: notice, join: join }
+    end
 
-      def valid_uri?(uri)
-        !!URI.parse(uri)
-      rescue URI::InvalidURIError
-        false
-      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,165 +1,82 @@
-require 'action_dispatch'
-require 'active_support/core_ext/time'
+# frozen_string_literal: true
 
-module ExceptionNotifier
-  class MattermostNotifier
-    include ExceptionNotifier::BacktraceCleaner
-
-    class MissingController
-      def method_missing(*args, &block)
-      end
-    end
-
-    attr_accessor :httparty
+require 'httparty'
 
-    def initialize(options = {})
-      super()
-      @default_options = options
-      @httparty = HTTParty
-    end
-
-    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 }
+      payload[:icon_url] = options[:avatar] if options[:avatar]
+      payload[:channel] = options[:channel] if options[:channel]
 
-        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 = 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
+    attr_reader :formatter
 
-      def user_info
-        infos = {}
+    def message_text
+      text = [
+        '@channel',
+        "### #{formatter.title}",
+        formatter.subtitle,
+        "*#{@exception.message}*"
+      ]
 
-        infos.merge!({ username: @username }) if @username
-        infos.merge!({ icon_url: @avatar }) if @avatar
-
-        infos
+      if (request = formatter.request_message.presence)
+        text << '### Request'
+        text << request
       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") }
+      if (backtrace = formatter.backtrace_message.presence)
+        text << '### Backtrace'
+        text << backtrace
       end
 
-      def message_header
-        text = []
-
-        errors_count = @options[:accumulated_errors_count].to_i
-        text << "### :warning: Error 500 in #{Rails.env} :warning:"
-        text << "#{errors_count > 1 ? errors_count : 'An'} *#{@exception.class}* occured" + if @controller then " in *#{controller_and_method}*." else "." end
-        text << "*#{@exception.message}*"
-
-        text
+      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 message_request
-        text = []
-
-        text << "### Request"
-        text << "```"
-        text << hash_presentation(@request_items)
-        text << "```"
+      text << message_issue_link if @gitlab_url
 
-        text
-      end
-
-      def message_backtrace(size = 3)
-        text = []
-
-        size = @backtrace.size < size ? @backtrace.size : size
-        text << "### Backtrace"
-        text << "```"
-        size.times { |i| text << "* " + @backtrace[i] }
-        text << "```"
-
-        text
-      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
-      end
-
-      def controller_and_method
-        if @controller
-          "#{@controller.controller_name}##{@controller.action_name}"
-        else
-          ""
-        end
-      end
-
-      def hash_presentation(hash)
-        text = []
-
-        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

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require 'active_support'
 require 'active_support/core_ext/numeric/time'
 require 'active_support/concern'
 
@@ -25,20 +28,21 @@ module ExceptionNotifier
       end
 
       def error_count(error_key)
-        count = begin
-          error_grouping_cache.read(error_key)
-        rescue => 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 =
+          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 if count
+        count&.to_i
       end
 
       def save_error_count(error_key, count)
         error_grouping_cache.write(error_key, count, expires_in: error_grouping_period)
-      rescue => e
-        ExceptionNotifier.logger.warn("#{error_grouping_cache.inspect} failed to write, reason: #{e.message}. Falling back to memory cache store.")
+      rescue StandardError => e
+        log_cache_error(error_grouping_cache, e, :write)
         fallback_cache_store.write(error_key, count, expires_in: error_grouping_period)
       end
 
@@ -46,13 +50,14 @@ module ExceptionNotifier
         message_based_key = "exception:#{Zlib.crc32("#{exception.class.name}\nmessage:#{exception.message}")}"
         accumulated_errors_count = 1
 
-        if count = error_count(message_based_key)
+        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)}")}"
+          backtrace_based_key =
+            "exception:#{Zlib.crc32("#{exception.class.name}\npath:#{exception.backtrace.try(:first)}")}"
 
-          if count = error_grouping_cache.read(backtrace_based_key)
+          if (count = error_grouping_cache.read(backtrace_based_key))
             accumulated_errors_count = count + 1
             save_error_count(backtrace_based_key, accumulated_errors_count)
           else
@@ -72,6 +77,12 @@ module ExceptionNotifier
           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
+end