exception_notification_more_info 1.0.0

data/lib/exception_notifier/base_notifier.rb

@@ -0,0 +1,25 @@
+module ExceptionNotifier
+  class BaseNotifier
+    attr_accessor :base_options
+
+    def initialize(options={})
+      @base_options = options
+    end
+
+    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)
+      result
+    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)
+    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
+
+  end
+end

data/lib/exception_notifier/campfire_notifier.rb

@@ -0,0 +1,36 @@
+module ExceptionNotifier
+  class CampfireNotifier < BaseNotifier
+
+    attr_accessor :subdomain
+    attr_accessor :token
+    attr_accessor :room
+
+    def initialize(options)
+      super
+      begin
+        subdomain = options.delete(:subdomain)
+        room_name = options.delete(:room_name)
+        @campfire = Tinder::Campfire.new subdomain, options
+        @room     = @campfire.find_room_by_name room_name
+      rescue
+        @campfire = @room = nil
+      end
+    end
+
+    def call(exception, options={})
+      if active?
+        message = "A new exception occurred: '#{exception.message}'"
+        message += " on '#{exception.backtrace.first}'" if exception.backtrace
+        send_notice(exception, options, message) do |msg, _|
+          @room.paste msg
+        end
+      end
+    end
+
+    private
+
+    def active?
+      !@room.nil?
+    end
+  end
+end

data/lib/exception_notifier/email_notifier.rb

@@ -0,0 +1,204 @@
+require "active_support/core_ext/hash/reverse_merge"
+require 'action_mailer'
+require 'action_dispatch'
+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, :delivery_method, :mailer_settings,
+    :email_headers, :mailer_parent, :template_path, :deliver_with)
+
+    module Mailer
+      class MissingController
+        def method_missing(*args, &block)
+        end
+      end
+
+      def self.extended(base)
+        base.class_eval do
+          self.send(:include, ExceptionNotifier::BacktraceCleaner)
+
+          # Append application view path to the ExceptionNotifier lookup context.
+          self.append_view_path "#{File.dirname(__FILE__)}/views"
+
+          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)
+            @kontroller = env['action_controller.instance'] || MissingController.new
+            @request    = ActionDispatch::Request.new(env)
+            @backtrace  = exception.backtrace ? clean_backtrace(exception) : []
+            @sections   = @options[:sections]
+            @data       = (env['exception_notifier.exception_data'] || {}).merge(options[:data] || {})
+            @sections   = @sections + %w(data) unless @data.empty?
+
+            compose_email
+          end
+
+          def background_exception_notification(exception, options={}, default_options={})
+            load_custom_views
+
+            @exception = exception
+            @options   = options.reverse_merge(default_options)
+            @backtrace = exception.backtrace || []
+            @sections  = @options[:background_sections]
+            @data      = options[:data] || {}
+
+            compose_email
+          end
+
+          private
+
+          def compose_subject
+            subject = "#{@options[:email_prefix]}"
+            subject << "#{@kontroller.controller_name}##{@kontroller.action_name}" if @kontroller
+            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 inspect_object(object)
+            case object
+              when Hash, Array
+                object.inspect
+              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'
+
+            headers = {
+              :delivery_method => @options[:delivery_method],
+              :to => @options[: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
+            if defined?(Rails) && Rails.respond_to?(:root)
+              self.prepend_view_path Rails.root.nil? ? "app/views" : "#{Rails.root}/app/views"
+            end
+          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)
+
+      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, :delivery_method, :mailer_settings,
+        :email_headers, :mailer_parent, :template_path, :deliver_with].include?(k)}.each{|k,v| send("#{k}=", v)}
+    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={})
+      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)
+          deliver_with = :deliver_now
+        else
+          deliver_with = :deliver
+        end
+      end
+
+      message.send(deliver_with)
+    end
+
+    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|
+          mailer.background_exception_notification(exception, options, default_opts)
+        end
+      else
+        send_notice(exception, options, nil, default_options) do |_, default_opts|
+          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,
+        :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
+  end
+end

data/lib/exception_notifier/hipchat_notifier.rb

@@ -0,0 +1,45 @@
+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'
+                            }
+        @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)}'"
+          msg += " on '#{exception.backtrace.first}'" if exception.backtrace
+          msg
+        }
+        @message_options  = options
+        @message_options[:color] ||= 'red'
+      rescue
+        @room = nil
+      end
+    end
+
+    def call(exception, options={})
+      return if !active?
+
+      message = @message_template.call(exception)
+      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,51 @@
+module ExceptionNotifier
+  class IrcNotifier < BaseNotifier
+    def initialize(options)
+      super
+      @config = OpenStruct.new
+      parse_options(options)
+    end
+
+    def call(exception, options={})
+      message = "'#{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
+      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/modules/backtrace_cleaner.rb

@@ -0,0 +1,13 @@
+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/notifier.rb

@@ -0,0 +1,16 @@
+require 'active_support/deprecation'
+
+module ExceptionNotifier
+  class Notifier
+
+    def self.exception_notification(env, exception, options={})
+      ActiveSupport::Deprecation.warn "Please use ExceptionNotifier.notify_exception(exception, options.merge(:env => env))."
+      ExceptionNotifier.registered_exception_notifier(:email).create_email(exception, options.merge(:env => env))
+    end
+
+    def self.background_exception_notification(exception, options={})
+      ActiveSupport::Deprecation.warn "Please use ExceptionNotifier.notify_exception(exception, options)."
+      ExceptionNotifier.registered_exception_notifier(:email).create_email(exception, options)
+    end
+  end
+end

data/lib/exception_notifier/slack_notifier.rb

@@ -0,0 +1,73 @@
+module ExceptionNotifier
+  class SlackNotifier < BaseNotifier
+    include ExceptionNotifier::BacktraceCleaner
+
+    attr_accessor :notifier
+
+    def initialize(options)
+      super
+      begin
+        @ignore_data_if = options[:ignore_data_if]
+
+        webhook_url = options.fetch(:webhook_url)
+        @message_opts = options.fetch(:additional_parameters, {})
+        @notifier = Slack::Notifier.new webhook_url, options
+      rescue
+        @notifier = nil
+      end
+    end
+
+    def call(exception, options={})
+      env = options[:env] || {}
+      title = "#{env['REQUEST_METHOD']} <#{env['REQUEST_URI']}>"
+      data = (env['exception_notifier.exception_data'] || {}).merge(options[:data] || {})
+      text = "*An exception occurred while doing*: `#{title}`\n"
+
+      clean_message = exception.message.gsub("`", "'")
+      fields = [ { title: 'Exception', value: clean_message} ]
+
+      fields.push({ title: 'Hostname', value: Socket.gethostname })
+
+      if exception.backtrace
+        formatted_backtrace = "```#{exception.backtrace.join("\n")}```"
+        fields.push({ title: 'Backtrace', value: formatted_backtrace })
+      end
+
+      unless data.empty?
+        deep_reject(data, @ignore_data_if) if @ignore_data_if.is_a?(Proc)
+        data_string = data.map{|k,v| "#{k}: #{v}"}.join("\n")
+        fields.push({ title: 'Data', value: "```#{data_string}```" })
+      end
+
+      fields.push({title: 'Request Params'}, value: options[:env]['action_dispatch.request.parameters'].to_s)
+      fields.push({title: 'User Agent'}, value: options[:env]['HTTP_USER_AGENT'])
+      fields.push({title: 'Remote IP'}, value: options[:env]['REMOTE_ADDR'])
+      attchs = [color: 'danger', text: text, fields: fields, mrkdwn_in: %w(text fields)]
+
+      if valid?
+        send_notice(exception, options, clean_message, @message_opts.merge(attachments: attchs)) do |msg, message_opts|
+          @notifier.ping '', message_opts
+        end
+      end
+    end
+
+    protected
+
+    def valid?
+      !@notifier.nil?
+    end
+
+    def deep_reject(hash, block)
+      hash.each do |k, v|
+        if v.is_a?(Hash)
+          deep_reject(v, block)
+        end
+
+        if block.call(k, v)
+          hash.delete(k)
+        end
+      end
+    end
+
+  end
+end