super_exception_notifier 2.0.0

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 2
+:minor: 0
+:patch: 0

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/rails/init"

data/lib/exception_notifiable.rb

@@ -0,0 +1,175 @@
+require 'ipaddr'
+
+module ExceptionNotifiable
+  include SuperExceptionNotifier::NotifiableHelper
+
+  def self.included(base)
+    base.extend ClassMethods
+
+    # Adds the following class attributes to the classes that include ExceptionNotifiable
+    #  HTTP status codes and what their 'English' status message is
+    base.cattr_accessor :http_status_codes
+    base.http_status_codes = HTTP_STATUS_CODES
+    # error_layout:
+    #   can be defined at controller level to the name of the desired error layout,
+    #   or set to true to render the controller's own default layout,
+    #   or set to false to render errors with no layout
+    base.cattr_accessor :error_layout
+    base.error_layout = nil
+    # Rails error classes to rescue and how to rescue them (which error code to use)
+    base.cattr_accessor :error_class_status_codes
+    base.error_class_status_codes = self.codes_for_error_classes
+    # Verbosity of the gem
+    base.cattr_accessor :exception_notifiable_verbose
+    base.exception_notifiable_verbose = false
+    # Do Not Ever send error notification emails for these Error Classes
+    base.cattr_accessor :exception_notifiable_silent_exceptions
+    base.exception_notifiable_silent_exceptions = SILENT_EXCEPTIONS
+    # Notification Level
+    base.cattr_accessor :exception_notifiable_notification_level
+    base.exception_notifiable_notification_level = [:render, :email, :web_hooks]
+  end
+  
+  module ClassMethods
+    include SuperExceptionNotifier::DeprecatedMethods
+
+    # specifies ip addresses that should be handled as though local
+    def consider_local(*args)
+      local_addresses.concat(args.flatten.map { |a| IPAddr.new(a) })
+    end
+
+    def local_addresses
+      addresses = read_inheritable_attribute(:local_addresses)
+      unless addresses
+        addresses = [IPAddr.new("127.0.0.1")]
+        write_inheritable_attribute(:local_addresses, addresses)
+      end
+      addresses
+    end
+
+    # set the exception_data deliverer OR retrieve the exception_data
+    def exception_data(deliverer = nil)
+      if deliverer
+        write_inheritable_attribute(:exception_data, deliverer)
+      else
+        read_inheritable_attribute(:exception_data)
+      end
+    end
+
+    def be_silent_for_exception?(exception)
+      self.exception_notifiable_silent_exceptions.respond_to?(:any?) && self.exception_notifiable_silent_exceptions.any? {|klass| klass === exception }
+    end
+
+  end
+
+  def be_silent_for_exception?(exception)
+    self.class.be_silent_for_exception?(exception)
+  end
+
+
+  private
+
+    def notification_level_sends_email?
+      self.class.exception_notifiable_notification_level.include?(:email)
+    end
+
+    def notification_level_sends_web_hooks?
+      self.class.exception_notifiable_notification_level.include?(:web_hooks)
+    end
+
+    def notification_level_renders?
+      self.class.exception_notifiable_notification_level.include?(:render)
+    end
+
+    # overrides Rails' local_request? method to also check any ip
+    # addresses specified through consider_local.
+    def local_request?
+      remote = IPAddr.new(request.remote_ip)
+      !self.class.local_addresses.detect { |addr| addr.include?(remote) }.nil?
+    end
+
+    # When the action being executed has its own local error handling (rescue)
+    # Or when the error accurs somewhere without a subsequent render (eg. method calls in console)
+    def rescue_with_handler(exception)
+      to_return = super
+      if to_return
+        verbose = self.class.exception_notifiable_verbose
+        puts "[RESCUE STYLE] rescue_with_handler" if verbose
+        data = get_exception_data
+        status_code = status_code_for_exception(exception)
+        #We only send email if it has been configured in environment
+        send_email = should_email_on_exception?(exception, status_code, verbose)
+        #We only send web hooks if they've been configured in environment
+        send_web_hooks = should_web_hook_on_exception?(exception, status_code, verbose)
+        the_blamed = ExceptionNotifier.config[:git_repo_path].nil? ? nil : lay_blame(exception)
+        verbose_output(exception, status_code, "rescued by handler", send_email, send_web_hooks, nil, the_blamed) if verbose
+        # Send the exception notificaiton email
+        perform_exception_notify_mailing(exception, data, nil, the_blamed, verbose) if send_email
+        # Send Web Hook requests
+        HooksNotifier.deliver_exception_to_web_hooks(ExceptionNotifier.config, exception, self, request, data, the_blamed) if send_web_hooks
+      end
+      to_return
+    end
+
+    # When the action being executed is letting SEN handle the exception completely
+    def rescue_action_in_public(exception)
+      # If the error class is NOT listed in the rails_errror_class hash then we get a generic 500 error:
+      # OTW if the error class is listed, but has a blank code or the code is == '200' then we get a custom error layout rendered
+      # OTW the error class is listed!
+      verbose = self.class.exception_notifiable_verbose
+      puts "[RESCUE STYLE] rescue_action_in_public" if verbose
+      status_code = status_code_for_exception(exception)
+      if status_code == '200'
+        notify_and_render_error_template(status_code, request, exception, ExceptionNotifier.get_view_path_for_class(exception, verbose), verbose)
+      else
+        notify_and_render_error_template(status_code, request, exception, ExceptionNotifier.get_view_path_for_status_code(status_code, verbose), verbose)
+      end
+    end
+
+    def notify_and_render_error_template(status_cd, request, exception, file_path, verbose = false)
+      status = self.class.http_status_codes[status_cd] ? status_cd + " " + self.class.http_status_codes[status_cd] : status_cd
+      data = get_exception_data
+      #We only send email if it has been configured in environment
+      send_email = should_email_on_exception?(exception, status_cd, verbose)
+      #We only send web hooks if they've been configured in environment
+      send_web_hooks = should_web_hook_on_exception?(exception, status_cd, verbose)
+      the_blamed = ExceptionNotifier.config[:git_repo_path].nil? ? nil : lay_blame(exception)
+
+      # Debugging output
+      verbose_output(exception, status_cd, file_path, send_email, send_web_hooks, request, the_blamed) if verbose
+
+      #TODO: is _rescue_action something from rails 3?
+      #if !(self.controller_name == 'application' && self.action_name == '_rescue_action')
+      perform_exception_notify_mailing(exception, data, request, the_blamed, verbose) if send_email
+      # Send Web Hook requests
+      HooksNotifier.deliver_exception_to_web_hooks(ExceptionNotifier.config, exception, self, request, data, the_blamed) if send_web_hooks
+
+      # We put the render call after the deliver call to ensure that, if the
+      # deliver raises an exception, we don't call render twice.
+      # Render the error page to the end user
+      render_error_template(file_path, status)
+    end
+
+    def is_local?
+      (consider_all_requests_local || local_request?)
+    end
+
+    def status_code_for_exception(exception)
+      self.class.error_class_status_codes[exception.class].nil? ? 
+              '500' :
+              self.class.error_class_status_codes[exception.class].blank? ?
+                      '200' :
+                      self.class.error_class_status_codes[exception.class]
+    end
+
+    def render_error_template(file, status)
+      respond_to do |type|
+        type.html { render :file => file,
+                            :layout => self.class.error_layout,
+                            :status => status }
+        type.all  { render :nothing => true,
+                            :status => status}
+      end
+    end
+
+end

data/lib/exception_notifier.rb

@@ -0,0 +1,185 @@
+require 'pathname'
+
+class ExceptionNotifier < ActionMailer::Base
+
+  #andrewroth reported that @@config gets clobbered because rails loads this class twice when installed as a plugin, and adding the ||= fixed it.
+  @@config ||= {
+    # If left empty web hooks will not be engaged
+    :web_hooks                => [],
+    :app_name                 => "[MYAPP]",
+    :version                  => "0.0.0",
+    :sender_address           => "super.exception.notifier@example.com",
+    :exception_recipients     => [],
+    # Customize the subject line
+    :subject_prepend          => "[#{(defined?(Rails) ? Rails.env : RAILS_ENV).capitalize} ERROR] ",
+    :subject_append           => nil,
+    # Include which sections of the exception email? 
+    :sections                 => %w(request session environment backtrace),
+    :skip_local_notification  => true,
+    :view_path                => nil,
+    #Error Notification will be sent if the HTTP response code for the error matches one of the following error codes
+    :notify_error_codes   => %W( 405 500 503 ),
+    #Error Notification will be sent if the error class matches one of the following error error classes
+    :notify_error_classes => %W( ),
+    :notify_other_errors  => true,
+    :git_repo_path            => nil,
+    :template_root            => "#{File.dirname(__FILE__)}/../views"
+  }
+
+  cattr_accessor :config
+
+  def self.configure_exception_notifier(&block)
+    yield @@config
+  end
+  
+  self.template_root = config[:template_root]
+
+  def self.reloadable?() false end
+
+  # Returns an array of potential filenames to look for
+  # eg. For the Exception Class - SuperExceptionNotifier::CustomExceptionClasses::MethodDisabled
+  # the filename handles are:
+  #   super_exception_notifier_custom_exception_classes_method_disabled
+  #   method_disabled
+  def self.exception_to_filenames(exception)
+    filenames = []
+    e = exception.to_s
+    filenames << ExceptionNotifier.filenamify(e)
+
+    last_colon = e.rindex(':')
+    unless last_colon.nil?
+      filenames << ExceptionNotifier.filenamify(e[(last_colon + 1)..(e.length - 1)])
+    end
+    filenames
+  end
+
+  # Converts Stringified Class Names to acceptable filename handles with underscores
+  def self.filenamify(str)
+    str.delete(':').gsub( /([A-Za-z])([A-Z])/, '\1' << '_' << '\2').downcase
+  end
+
+  # What is the path of the file we will render to the user based on a given status code?
+  def self.get_view_path_for_status_code(status_cd, verbose = false)
+    file_name = ExceptionNotifier.get_view_path(status_cd, verbose)
+    #ExceptionNotifierHelper::COMPAT_MODE ? "#{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/500.html" : "500.html"
+    file_name.nil? ? self.catch_all(verbose) : file_name
+  end
+
+#  def self.get_view_path_for_files(filenames = [])
+#    filepaths = filenames.map do |file|
+#      ExceptionNotifier.get_view_path(file)
+#    end.compact
+#    filepaths.empty? ? "#{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/500.html" : filepaths.first
+#  end
+
+  # What is the path of the file we will render to the user based on a given exception class?
+  def self.get_view_path_for_class(exception, verbose = false)
+    return self.catch_all if exception.nil?
+    return self.catch_all unless exception.is_a?(StandardError) || exception.is_a?(Class) # For some reason exception.is_a?(Class) works in console, but not when running in mongrel (ALWAYS returns false)?!?!?
+    filepaths = ExceptionNotifier.exception_to_filenames(exception).map do |file|
+      ExceptionNotifier.get_view_path(file, verbose)
+    end.compact
+    filepaths.empty? ? self.catch_all(verbose) : filepaths.first
+  end
+
+  def self.catch_all(verbose = false)
+    puts "[CATCH ALL INVOKED] #{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/500.html" if verbose
+    "#{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/500.html"
+  end
+
+  # Check the usual suspects
+  def self.get_view_path(file_name, verbose = false)
+    if File.exist?("#{RAILS_ROOT}/public/#{file_name}.html")
+      puts "[FOUND FILE] #{RAILS_ROOT}/public/#{file_name}.html" if verbose
+      "#{RAILS_ROOT}/public/#{file_name}.html"
+    elsif !config[:view_path].nil? && File.exist?("#{RAILS_ROOT}/#{config[:view_path]}/#{file_name}.html.erb")
+      puts "[FOUND FILE] #{RAILS_ROOT}/#{config[:view_path]}/#{file_name}.html.erb" if verbose
+      "#{RAILS_ROOT}/#{config[:view_path]}/#{file_name}.html.erb"
+    elsif !config[:view_path].nil? && File.exist?("#{RAILS_ROOT}/#{config[:view_path]}/#{file_name}.html")
+      puts "[FOUND FILE] #{RAILS_ROOT}/#{config[:view_path]}/#{file_name}.html" if verbose
+      "#{RAILS_ROOT}/#{config[:view_path]}/#{file_name}.html"
+    elsif File.exist?("#{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/#{file_name}.html.erb")
+      puts "[FOUND FILE] #{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/#{file_name}.html.erb" if verbose
+      "#{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/#{file_name}.html.erb"
+    elsif File.exist?("#{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/#{file_name}.html")
+      #ExceptionNotifierHelper::COMPAT_MODE ? "#{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/#{file_name}.html" : "#{status_cd}.html"
+      puts "[FOUND FILE] #{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/#{file_name}.html" if verbose
+      "#{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/#{file_name}.html"
+    else
+      nil
+    end
+  end
+
+  def exception_notification(exception, class_name = nil, method_name = nil, request = nil, data={}, the_blamed=nil)
+    body_hash = error_environment_data_hash(exception, class_name, method_name, request, data, the_blamed)
+    #Prefer to have custom, potentially HTML email templates available
+    #content_type  "text/plain"
+    recipients    config[:exception_recipients]
+    from          config[:sender_address]
+
+    request.session.inspect unless request.nil? # Ensure session data is loaded (Rails 2.3 lazy-loading)
+    
+    subject       "#{config[:subject_prepend]}#{body_hash[:location]} (#{exception.class}) #{exception.message.inspect}#{config[:subject_append]}"
+    body          body_hash
+  end
+  
+  def background_exception_notification(exception, data = {}, the_blamed = nil)
+    exception_notification(exception, nil, nil, data, the_blamed)
+  end
+
+  def rake_exception_notification(exception, task, data={})
+    content_type "text/plain"
+
+    subject    "#{email_prefix}#{task.name} (#{exception.class}) #{exception.message.inspect}"
+
+    recipients exception_recipients
+    from       sender_address
+
+    body       data.merge({ :task => task,
+                  :exception => exception,
+                  :backtrace => sanitize_backtrace(exception.backtrace),
+                  :rails_root => rails_root,
+                  :data => data,
+                  :sections => sections.reject{|s| %w(request session).include?(s) } 
+               })
+  end
+
+  private
+
+    def error_environment_data_hash(exception, class_name = nil, method_name = nil, request = nil, data={}, the_blamed=nil)
+      data.merge!({
+        :exception => exception,
+        :backtrace => sanitize_backtrace(exception.backtrace),
+        :rails_root => rails_root,
+        :data => data,
+        :the_blamed => the_blamed
+      })
+
+      data.merge!({:class_name => class_name}) if class_name
+      data.merge!({:method_name => method_name}) if method_name
+      if class_name && method_name
+        data.merge!({:location => "#{class_name}##{method_name}"})
+      else
+        data.merge!({:location => sanitize_backtrace([exception.backtrace.first]).first})
+      end
+      if request
+        data.merge!({:request => request})
+        data.merge!({:host => (request.env['HTTP_X_REAL_IP'] || request.env["HTTP_X_FORWARDED_HOST"] || request.env["HTTP_HOST"])})
+        data.merge!({:sections => config[:sections]})
+      else
+        # TODO: with refactoring in the view structure, the environment section could show useful ENV data even without a request?
+        data.merge!({:sections => config[:sections] - %w(request session environment)})
+      end
+      return data
+    end
+
+    def sanitize_backtrace(trace)
+      re = Regexp.new(/^#{Regexp.escape(rails_root)}/)
+      trace.map { |line| Pathname.new(line.gsub(re, "[RAILS_ROOT]")).cleanpath.to_s }
+    end
+
+    def rails_root
+      @rails_root ||= Pathname.new(RAILS_ROOT).cleanpath.to_s
+    end
+
+end

data/lib/exception_notifier_helper.rb

@@ -0,0 +1,60 @@
+require 'pp'
+
+module ExceptionNotifierHelper
+  VIEW_PATH = "views/exception_notifier" unless defined?(VIEW_PATH)
+  APP_PATH = "#{RAILS_ROOT}/app/#{VIEW_PATH}" unless defined?(APP_PATH)
+  PARAM_FILTER_REPLACEMENT = "[FILTERED]" unless defined?(PARAM_FILTER_REPLACEMENT)
+  COMPAT_MODE = defined?(RAILS_GEM_VERSION) ? RAILS_GEM_VERSION < '2' : false unless defined?(COMPAT_MODE)
+
+  def render_section(section)
+    RAILS_DEFAULT_LOGGER.info("rendering section #{section.inspect}")
+    summary = render_overridable(section).strip
+    unless summary.blank?
+      title = render_overridable(:title, :locals => { :title => section }).strip
+      "#{title}\n\n#{summary.gsub(/^/, "  ")}\n\n"
+    end
+  end
+
+  def render_overridable(partial, options={})
+    if File.exist?(path = "#{APP_PATH}/_#{partial}.html.erb") ||
+        File.exist?(path = "#{File.dirname(__FILE__)}/../#{VIEW_PATH}/_#{partial}.html.erb") ||
+        File.exist?(path = "#{APP_PATH}/_#{partial}.rhtml") ||
+        File.exist?(path = "#{APP_PATH}/_#{partial}.erb")
+      render(options.merge(:file => path, :use_full_path => false))
+    else
+      ""
+    end
+  end
+
+  def inspect_model_object(model, locals={})
+    render_overridable(:inspect_model,
+      :locals => { :inspect_model => model,
+                   :show_instance_variables => true,
+                   :show_attributes => true }.merge(locals))
+  end
+
+  def inspect_value(value)
+    len = 512
+    result = object_to_yaml(value).gsub(/\n/, "\n  ").strip
+    result = result[0,len] + "... (#{result.length-len} bytes more)" if result.length > len+20
+    result
+  end
+
+  def object_to_yaml(object)
+    object.to_yaml.sub(/^---\s*/m, "")
+  end
+
+  def exclude_raw_post_parameters?
+    @controller && @controller.respond_to?(:filter_parameters)
+  end
+
+  def filter_sensitive_post_data_parameters(parameters)
+    exclude_raw_post_parameters? ? COMPAT_MODE ? @controller.filter_parameters(parameters) : @controller.__send__(:filter_parameters, parameters) : parameters
+  end
+
+  def filter_sensitive_post_data_from_env(env_key, env_value)
+    return env_value unless exclude_raw_post_parameters?
+    return PARAM_FILTER_REPLACEMENT if (env_key =~ /RAW_POST_DATA/i)
+    return COMPAT_MODE ? @controller.filter_parameters({env_key => env_value}).values[0] : @controller.__send__(:filter_parameters, {env_key => env_value}).values[0]
+  end
+end

data/lib/notifiable.rb

@@ -0,0 +1,91 @@
+module Notifiable
+  include SuperExceptionNotifier::NotifiableHelper
+  
+  def self.included(base)
+    base.extend ClassMethods
+
+    # Verbosity of the gem
+    base.cattr_accessor :notifiable_verbose
+    base.notifiable_verbose = false
+    # Do Not Ever send error notification emails for these Error Classes
+    base.cattr_accessor :notifiable_silent_exceptions
+    base.notifiable_silent_exceptions = SILENT_EXCEPTIONS
+    # Notification Level
+    base.cattr_accessor :notifiable_notification_level
+    base.notifiable_notification_level = [:email, :web_hooks]
+
+    # Since there is no concept of locality from a request here allow user to explicitly define which env's are noisy (send notifications)
+    base.cattr_accessor :notifiable_noisy_environments
+    base.notifiable_noisy_environments = [:production]
+  end
+
+  module ClassMethods
+    # set the exception_data deliverer OR retrieve the exception_data
+    def exception_data(deliverer = nil)
+      if deliverer
+        write_inheritable_attribute(:exception_data, deliverer)
+      else
+        read_inheritable_attribute(:exception_data)
+      end
+    end
+
+    def be_silent_for_exception?(exception)
+      self.notifiable_silent_exceptions.respond_to?(:any?) && self.notifiable_silent_exceptions.any? {|klass| klass === exception }
+    end
+
+  end
+
+  # Usage:
+  #   notifiable { Klass.some_method }
+  # This will rescue any errors that occur within Klass.some_method
+  def notifiable(&block)
+    yield
+  rescue => exception
+    rescue_with_hooks(exception)
+    raise
+  end
+
+  def be_silent_for_exception?(exception)
+    self.class.be_silent_for_exception?(exception)
+  end
+
+  private
+
+  def notification_level_sends_email?
+    self.class.notifiable_notification_level.include?(:email)
+  end
+
+  def notification_level_sends_web_hooks?
+    self.class.notifiable_notification_level.include?(:web_hooks)
+  end
+  
+  def rescue_with_hooks(exception)
+    verbose = self.class.notifiable_verbose
+    puts "[RESCUE STYLE] rescue_with_hooks" if verbose
+    data = get_exception_data
+    # With ExceptionNotifiable you have an inherent request, and using a status code makes sense.
+    # With Notifiable class to wrap around everything that doesn't have a request,
+    #   the errors you want to be notified of need to be specified either positively or negatively
+    # 1. positive eg. set ExceptionNotifier.config[:notify_error_classes] to an array of classes
+    #               set ExceptionNotifier.config[:notify_other_errors] to false
+    # 1. negative eg. set Klass.silent_exceptions to the ones to keep quiet
+    #               set ExceptionNotifier.config[:notify_other_errors] to true
+    status_code = nil
+    #We only send email if it has been configured in environment
+    send_email = should_email_on_exception?(exception, status_code, verbose)
+    #We only send web hooks if they've been configured in environment
+    send_web_hooks = should_web_hook_on_exception?(exception, status_code, verbose)
+    the_blamed = ExceptionNotifier.config[:git_repo_path].nil? ? nil : lay_blame(exception)
+    verbose_output(exception, status_code, "rescued by handler", send_email, send_web_hooks, nil, the_blamed) if verbose
+    # Send the exception notificaiton email
+    perform_exception_notify_mailing(exception, data, nil, the_blamed, verbose) if send_email
+    # Send Web Hook requests
+    HooksNotifier.deliver_exception_to_web_hooks(ExceptionNotifier.config, exception, self, request, data, the_blamed) if send_web_hooks
+  end
+
+  def is_local? #like asking is_silent?
+    eenv = defined?(Rails) ? Rails.env : RAILS_ENV
+    !self.notifiable_noisy_environments.include?(eenv)
+  end
+
+end