exception_notification 4.3.0 → 4.5.0

data/lib/exception_notification/resque.rb

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

data/lib/exception_notification/sidekiq.rb

@@ -1,18 +1,16 @@
+# frozen_string_literal: true
+
 require 'sidekiq'
 
 # Note: this class is only needed for Sidekiq version < 3.
 module ExceptionNotification
   class Sidekiq
-
-    def call(worker, msg, queue)
-      begin
-        yield
-      rescue Exception => exception
-        ExceptionNotifier.notify_exception(exception, :data => { :sidekiq => msg })
-        raise exception
-      end
+    def call(_worker, msg, _queue)
+      yield
+    rescue Exception => e
+      ExceptionNotifier.notify_exception(e, data: { sidekiq: msg })
+      raise e
     end
-
   end
 end
 
@@ -24,8 +22,8 @@ if ::Sidekiq::VERSION < '3'
   end
 else
   ::Sidekiq.configure_server do |config|
-    config.error_handlers << Proc.new { |ex, context|
-      ExceptionNotifier.notify_exception(ex, :data => { :sidekiq => context })
-    }
+    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,5 @@
+# frozen_string_literal: true
+
+module ExceptionNotification
+  VERSION = '4.5.0'
+end

data/lib/exception_notification.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require 'exception_notifier'
 require 'exception_notification/rack'
+require 'exception_notification/version'
 
 module ExceptionNotification
   # Alternative way to setup ExceptionNotification.

data/lib/exception_notifier/base_notifier.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module ExceptionNotifier
   class BaseNotifier
     attr_accessor :base_options
 
-    def initialize(options={})
+    def initialize(options = {})
       @base_options = options
     end
 
-    def send_notice(exception, options, message, message_opts=nil)
+    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)
@@ -14,12 +16,15 @@ module ExceptionNotifier
     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)
+      return unless @base_options[:pre_callback].respond_to?(:call)
+
+      @base_options[:pre_callback].call(options, self, exception.backtrace, message, message_opts)
     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
+      return unless @base_options[:post_callback].respond_to?(:call)
 
+      @base_options[:post_callback].call(options, self, exception.backtrace, message, message_opts)
+    end
   end
 end

data/lib/exception_notifier/datadog_notifier.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+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'
+
+      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_prefix}#{controller_subtitle} (#{exception.class}) #{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)
+        text << formatted_key_value('Rails root', Rails.root) if defined?(Rails) && Rails.respond_to?(:root)
+        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
+
+      private
+
+      def controller_subtitle
+        "#{controller.controller_name} #{controller.action_name}" if controller
+      end
+    end
+  end
+end

data/lib/exception_notifier/email_notifier.rb

@@ -1,4 +1,5 @@
-require "active_support/core_ext/hash/reverse_merge"
+# frozen_string_literal: true
+
 require 'active_support/core_ext/time'
 require 'action_mailer'
 require 'action_dispatch'
@@ -6,47 +7,61 @@ require 'pp'
 
 module ExceptionNotifier
   class EmailNotifier < BaseNotifier
-    attr_accessor(:sender_address, :exception_recipients,
-    :pre_callback, :post_callback,
-    :email_prefix, :email_format, :sections, :background_sections,
-    :verbose_subject, :normalize_subject, :include_controller_and_action_names_in_subject,
-    :delivery_method, :mailer_settings, :email_headers, :mailer_parent, :template_path, :deliver_with)
+    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
+        def method_missing(*args, &block); end
       end
 
       def self.extended(base)
         base.class_eval do
-          self.send(:include, ExceptionNotifier::BacktraceCleaner)
+          send(:include, ExceptionNotifier::BacktraceCleaner)
 
           # Append application view path to the ExceptionNotifier lookup context.
-          self.append_view_path "#{File.dirname(__FILE__)}/views"
+          append_view_path "#{File.dirname(__FILE__)}/views"
 
-          def exception_notification(env, exception, options={}, default_options={})
+          def exception_notification(env, exception, options = {}, default_options = {})
             load_custom_views
 
             @env        = env
             @exception  = exception
-            @options    = options.reverse_merge(env['exception_notifier.options'] || {}).reverse_merge(default_options)
+
+            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   = @sections + %w(data) unless @data.empty?
+            @sections += %w[data] unless @data.empty?
 
             compose_email
           end
 
-          def background_exception_notification(exception, options={}, default_options={})
+          def background_exception_notification(exception, options = {}, default_options = {})
             load_custom_views
 
             @exception = exception
-            @options   = options.reverse_merge(default_options).symbolize_keys
+            @options   = default_options.merge(options).symbolize_keys
             @backtrace = exception.backtrace || []
             @timestamp = Time.current
             @sections  = @options[:background_sections]
@@ -59,13 +74,17 @@ module ExceptionNotifier
           private
 
           def compose_subject
-            subject = "#{@options[:email_prefix]}"
+            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 << "#{@kontroller.controller_name}##{@kontroller.action_name}" if include_controller?
             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
+            subject.length > 120 ? subject[0...120] + '...' : subject
+          end
+
+          def include_controller?
+            @kontroller && @options[:include_controller_and_action_names_in_subject]
           end
 
           def set_data_variables
@@ -82,17 +101,17 @@ module ExceptionNotifier
 
           def inspect_object(object)
             case object
-              when Hash, Array
-                truncate(object.inspect, 300)
-              else
-                  object.to_s
+            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: "_")
+            value.encode('utf-8', invalid: :replace, undef: :replace, replace: '_')
           end
 
           def html_mail?
@@ -106,11 +125,11 @@ module ExceptionNotifier
             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
+              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|
@@ -124,9 +143,9 @@ module ExceptionNotifier
           end
 
           def load_custom_views
-            if defined?(Rails) && Rails.respond_to?(:root)
-              self.prepend_view_path Rails.root.nil? ? "app/views" : "#{Rails.root}/app/views"
-            end
+            return unless defined?(Rails) && Rails.respond_to?(:root)
+
+            prepend_view_path Rails.root.nil? ? 'app/views' : "#{Rails.root}/app/views"
           end
 
           def maybe_call(maybe_proc)
@@ -138,82 +157,48 @@ module ExceptionNotifier
 
     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)
 
-      options.reverse_merge(EmailNotifier.default_options).select{|k,v|[
-        :sender_address, :exception_recipients, :pre_callback,
-        :post_callback, :email_prefix, :email_format,
-        :sections, :background_sections, :verbose_subject, :normalize_subject,
-        :include_controller_and_action_names_in_subject, :delivery_method, :mailer_settings,
-        :email_headers, :mailer_parent, :template_path, :deliver_with].include?(k)}.each{|k,v| send("#{k}=", v)}
+      @base_options = DEFAULT_OPTIONS.merge(options)
     end
 
-    def options
-      @options ||= {}.tap do |opts|
-        self.instance_variables.each { |var| opts[var[1..-1].to_sym] = self.instance_variable_get(var) }
-      end
-    end
-
-    def mailer
-      @mailer ||= Class.new(mailer_parent.constantize).tap do |mailer|
-        mailer.extend(EmailNotifier::Mailer)
-        mailer.mailer_name = template_path
-      end
-    end
-
-    def call(exception, options={})
+    def call(exception, options = {})
       message = create_email(exception, options)
 
-      # FIXME: use `if Gem::Version.new(ActionMailer::VERSION::STRING) < Gem::Version.new('4.1')`
-      if deliver_with == :default
-        if message.respond_to?(:deliver_now)
-          message.deliver_now
-        else
-          message.deliver
-        end
-      else
-        message.send(deliver_with)
-      end
+      message.send(base_options[:deliver_with] || default_deliver_with(message))
     end
 
-    def create_email(exception, options={})
+    def create_email(exception, options = {})
       env = options[:env]
-      default_options = self.options
-      if env.nil?
-        send_notice(exception, options, nil, default_options) do |_, default_opts|
+
+      send_notice(exception, options, nil, base_options) do |_, default_opts|
+        if env.nil?
           mailer.background_exception_notification(exception, options, default_opts)
-        end
-      else
-        send_notice(exception, options, nil, default_options) do |_, default_opts|
+        else
           mailer.exception_notification(env, exception, options, default_opts)
         end
       end
     end
 
-    def self.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 => :default
-      }
-    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