exception_notification 4.3.0 → 4.4.0

data/lib/exception_notifier/google_chat_notifier.rb

@@ -1,136 +1,42 @@
-require 'action_dispatch'
-require 'active_support/core_ext/time'
+require 'httparty'
 
 module ExceptionNotifier
-  class GoogleChatNotifier
-    include ExceptionNotifier::BacktraceCleaner
+  class GoogleChatNotifier < BaseNotifier
+    def call(exception, opts = {})
+      options = base_options.merge(opts)
+      formatter = Formatter.new(exception, options)
 
-    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
-
-      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' })
-
-      @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 = ['']
-
-      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 << ''
+    def body(exception, formatter)
+      text = [
+        "\nApplication: *#{formatter.app_name}*",
+        formatter.subtitle,
+        '',
+        formatter.title,
+        "*#{exception.message.tr('`', "'")}*"
+      ]
 
-      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,5 @@
 module ExceptionNotifier
   class HipchatNotifier < BaseNotifier
-
     attr_accessor :from
     attr_accessor :room
     attr_accessor :message_options
@@ -11,29 +10,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

@@ -6,50 +6,52 @@ 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
 
       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,72 @@
-require 'action_dispatch'
-require 'active_support/core_ext/time'
+require 'httparty'
 
 module ExceptionNotifier
-  class MattermostNotifier
-    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)
+  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
+      payload = {
+        text: message_text.compact.join("\n"),
+        username: options[:username] || 'Exception Notifier'
+      }
 
-        request = ActionDispatch::Request.new(@env)
+      payload[:icon_url] = options[:avatar] if options[:avatar]
+      payload[:channel] = options[:channel] if options[:channel]
 
-        @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
+      httparty_options = options.except(
+        :avatar, :channel, :username, :git_url, :webhook_url,
+        :env, :accumulated_errors_count, :app_name
+      )
 
-      payload = message_text.merge(user_info).merge(channel_info)
+      httparty_options[:body] = payload.to_json
+      httparty_options[:headers] ||= {}
+      httparty_options[:headers]['Content-Type'] = 'application/json'
 
-      @options[:body] = payload.to_json
-      @options[:headers] ||= {}
-      @options[:headers].merge!({ '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 = {}
+    attr_reader :formatter
 
-        infos.merge!({ username: @username }) if @username
-        infos.merge!({ icon_url: @avatar }) if @avatar
+    def message_text
+      text = [
+        '@channel',
+        "### #{formatter.title}",
+        formatter.subtitle,
+        "*#{@exception.message}*"
+      ]
 
-        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") }
-      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 (backtrace = formatter.backtrace_message.presence)
+        text << '### Backtrace'
+        text << backtrace
       end
 
-      def message_request
-        text = []
+      text << message_issue_link if @gitlab_url
 
-        text << "### Request"
-        text << "```"
-        text << hash_presentation(@request_items)
-        text << "```"
-
-        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