super_exception_notifier 3.0.2 → 3.0.4

data/VERSION.yml

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

data/lib/exception_notification/consider_local.rb

@@ -0,0 +1,33 @@
+#From rails/exception_notifier 2-3-stable branch - Not yet integrated into SuperExceptionNotifier...
+
+#This didn't belong on ExceptionNotification::Notifier and made backtraces worse.  To keep original functionality in place
+#'ActionController::Base.send :include, ExceptionNotification::ConsiderLocal' or just include in your controller
+module ExceptionNotification::ConsiderLocal
+  module ClassMethods
+    def self.included(target)
+      require 'ipaddr'
+      target.extend(ClassMethods)
+    end
+    
+    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
+  end
+  
+private
+  
+  def local_request?
+    remote = IPAddr.new(request.remote_ip)
+    !self.class.local_addresses.detect { |addr| addr.include?(remote) }.nil?
+  end
+  
+end

data/lib/exception_notification/custom_exception_classes.rb

@@ -0,0 +1,14 @@
+#Copyright (c) 2008-2009 Peter H. Boling of 9thBit LLC
+#Released under the MIT license
+
+module ExceptionNotification::CustomExceptionClasses
+
+  class AccessDenied < StandardError; end
+  class ResourceGone < StandardError; end
+  class NotImplemented < StandardError; end
+  class PageNotFound < StandardError; end
+  class InvalidMethod < StandardError; end
+  class CorruptData < StandardError; end
+  class MethodDisabled < StandardError; end
+
+end

data/lib/exception_notification/custom_exception_methods.rb

@@ -0,0 +1,48 @@
+#Copyright (c) 2008-2009 Peter H. Boling of 9thBit LLC
+#Released under the MIT license
+
+module ExceptionNotification::CustomExceptionMethods
+
+  protected
+
+  #For a while after disabling a route/URL that had been functional we should set it to resource gone to inform people to remove bookmarks.
+  def resource_gone
+    raise ResourceGone
+  end
+  #Then for things that have never existed or have not for a long time we call not_implemented
+  def not_implemented
+    raise NotImplemented
+  end
+  #Resources that must be requested with a specific HTTP Method (GET, PUT, POST, DELETE, AJAX, etc) but are requested otherwise should:
+  def invalid_method
+    raise InvalidMethod
+  end
+  #If your ever at a spot in the code that should never get reached, but corrupt data might get you there anyways then this is for you:
+  def corrupt_data
+    raise CorruptData
+  end
+  def page_not_found
+    raise PageNotFound
+  end
+  def record_not_found
+    raise ActiveRecord::RecordNotFound
+  end
+  def method_disabled
+    raise MethodDisabled
+  end
+  #The current user does not have enough privileges to access the requested resource
+  def access_denied
+    raise AccessDenied
+  end
+
+  def generic_error
+    error_stickie("Sorry, an error has occurred.")
+    corrupt_data
+  end
+
+  def invalid_page
+    error_stickie("Sorry, the page number you requested was not valid.")
+    page_not_found
+  end
+
+end

data/lib/exception_notification/deprecated_methods.rb

@@ -0,0 +1,58 @@
+#Copyright (c) 2008-2009 Peter H. Boling of 9thBit LLC
+#Released under the MIT license
+
+module ExceptionNotification::DeprecatedMethods
+  @@namespacing = "Better namespacing to allow for ExceptionNotifiable.rb and ExceptionNotifiable to have similar APIs"
+  @@rails2ruby = "An effort to make this a 'Ruby' Gem and not a strictly 'Rails' Gem"
+
+  def http_error_codes
+    deprecation_warning("http_error_codes", "error_class_status_codes")
+    error_class_status_codes
+  end
+
+  def http_error_codes=(arg)
+    deprecation_warning("http_error_codes", "error_class_status_codes")
+    error_class_status_codes=(arg)
+  end
+
+  def rails_error_codes
+    deprecation_warning("rails_error_codes", "error_class_status_codes", @@rails2ruby)
+    error_class_status_codes
+  end
+
+  def rails_error_codes=(arg)
+    deprecation_warning("rails_error_codes=", "error_class_status_codes=", @@rails2ruby)
+    error_class_status_codes=(arg)
+  end
+
+  # Now defined in Object class by init.rb & ExceptionNotifiable.rb module,
+  #   so we need to override them for with the controller settings
+  def exception_notifier_verbose
+    deprecation_warning("exception_notifier_verbose", "exception_notifiable_verbose", @@namespacing)
+    exception_notifiable_verbose
+  end
+  def silent_exceptions
+    deprecation_warning("silent_exceptions", "exception_notifiable_silent_exceptions", @@namespacing)
+    exception_notifiable_silent_exceptions
+  end
+  def notification_level
+    deprecation_warning("notification_level", "exception_notifiable_notification_level", @@namespacing)
+    exception_notifiable_notification_level
+  end
+  def exception_notifier_verbose=(arg)
+    deprecation_warning("exception_notifier_verbose=", "exception_notifiable_verbose=", @@namespacing)
+    exception_notifiable_verbose = arg
+  end
+  def silent_exceptions=(arg)
+    deprecation_warning("silent_exceptions=", "exception_notifiable_silent_exceptions=", @@namespacing)
+    exception_notifiable_silent_exceptions = arg
+  end
+  def notification_level=(arg)
+    deprecation_warning("notification_level=", "exception_notifiable_notification_level=", @@namespacing)
+    exception_notifiable_notification_level = arg
+  end
+
+  def deprecation_warning(old, new, reason = "")
+    puts "[DEPRECATION WARNING] ** Method '#{old}' has been replaced by '#{new}', please update your code.#{' Reason for change: ' + reason + '.' if reason}"
+  end
+end

data/lib/exception_notification/exception_notifiable.rb

@@ -0,0 +1,205 @@
+require 'ipaddr'
+
+module ExceptionNotification::ExceptionNotifiable
+  include ExceptionNotification::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]
+    # 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 :exception_notifiable_noisy_environments
+    base.exception_notifiable_noisy_environments = [:production]
+
+    base.cattr_accessor :exception_notifiable_pass_through
+    base.exception_notifiable_pass_through = false
+  end
+
+  module ClassMethods
+    include ExceptionNotification::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 environment_is_noisy?
+      self.class.exception_notifiable_noisy_environments.include?(Rails.env)
+    end
+  
+    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 = ExceptionNotification::Notifier.config[:git_repo_path].nil? ? nil : lay_blame(exception)
+        rejected_sections = %w(request session)
+        # Debugging output
+        verbose_output(exception, status_code, "rescued by handler", send_email, send_web_hooks, nil, the_blamed, rejected_sections) if verbose
+        # Send the exception notification email
+        perform_exception_notify_mailing(exception, data, nil, the_blamed, verbose, rejected_sections) if send_email
+        # Send Web Hook requests
+        ExceptionNotification::HooksNotifier.deliver_exception_to_web_hooks(ExceptionNotification::Notifier.config, exception, self, request, data, the_blamed) if send_web_hooks
+      end
+      pass_it_on(exception)
+      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, ExceptionNotification::Notifier.get_view_path_for_class(exception, verbose), verbose)
+      else
+        notify_and_render_error_template(status_code, request, exception, ExceptionNotification::Notifier.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 = ExceptionNotification::Notifier.config[:git_repo_path].nil? ? nil : lay_blame(exception)
+      rejected_sections = request.nil? ? %w(request session) : []
+      # Debugging output
+      verbose_output(exception, status_cd, file_path, send_email, send_web_hooks, request, the_blamed, rejected_sections) if verbose
+      #TODO: is _rescue_action something from rails 3?
+      #if !(self.controller_name == 'application' && self.action_name == '_rescue_action')
+      # Send the exception notification email
+      perform_exception_notify_mailing(exception, data, request, the_blamed, verbose, rejected_sections) if send_email
+      # Send Web Hook requests
+      ExceptionNotification::HooksNotifier.deliver_exception_to_web_hooks(ExceptionNotification::Notifier.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)
+      pass_it_on(exception, request)
+    end
+
+    def pass_it_on(exception, request = nil)
+      begin
+        request ||= {:params => {}}
+        case self.class.exception_notifiable_pass_through
+          when :hoptoad then
+            HoptoadNotifier.notify(exception, {:request => request})
+            puts "[PASS-IT-ON] HOPTOAD NOTIFIED" if verbose
+          else
+            puts "[PASS-IT-ON] NO" if verbose
+            #nothing
+        end
+      rescue
+        #nothing
+      end
+    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_notification/git_blame.rb

@@ -0,0 +1,50 @@
+#Copyright (c) 2008-2009 Peter H. Boling of 9thBit LLC
+#Released under the MIT license
+
+module ExceptionNotification::GitBlame
+
+  def lay_blame(exception)
+    error = {}
+    unless(ExceptionNotification::Notifier.config[:git_repo_path].nil?)
+      if(exception.class == ActionView::TemplateError)
+          blame = blame_output(exception.line_number, "app/views/#{exception.file_name}")
+          error[:author] = blame[/^author\s.+$/].gsub(/author\s/,'')
+          error[:line]   = exception.line_number
+          error[:file]   = exception.file_name
+      else
+        exception.backtrace.each do |line|
+          file = exception_in_project?(line[/^.+?(?=:)/])
+          unless(file.nil?)
+            line_number = line[/:\d+:/].gsub(/[^\d]/,'')
+            # Use relative path or weird stuff happens
+            blame = blame_output(line_number, file.gsub(Regexp.new("#{RAILS_ROOT}/"),''))
+            error[:author] = blame[/^author\s.+$/].sub(/author\s/,'')
+            error[:line]   = line_number
+            error[:file]   = file
+            break
+          end
+        end
+      end
+    end
+    error
+  end
+
+  def blame_output(line_number, path)
+    app_directory = Dir.pwd
+    Dir.chdir ExceptionNotification::Notifier.config[:git_repo_path]
+    blame = `git blame -p -L #{line_number},#{line_number} #{path}`
+    Dir.chdir app_directory
+
+    blame
+  end
+
+  def exception_in_project?(path) # should be a path like /path/to/broken/thingy.rb
+    dir = File.split(path).first rescue ''
+    if(File.directory?(dir) and !(path =~ /vendor\/plugins/) and !(path =~ /vendor\/gems/) and path.include?(RAILS_ROOT))
+      path
+    else
+      nil
+    end
+  end
+
+end

data/lib/exception_notification/helpful_hashes.rb

@@ -0,0 +1,64 @@
+#Copyright (c) 2008-2009 Peter H. Boling of 9thBit LLC
+#Released under the MIT license
+
+module ExceptionNotification::HelpfulHashes
+  unless defined?(SILENT_EXCEPTIONS)
+    noiseless = []
+    noiseless << ActiveRecord::RecordNotFound if defined?(ActiveRecord)
+    if defined?(ActionController)
+      noiseless << ActionController::UnknownController
+      noiseless << ActionController::UnknownAction
+      noiseless << ActionController::RoutingError
+      noiseless << ActionController::MethodNotAllowed
+    end
+    SILENT_EXCEPTIONS = noiseless
+  end
+
+  # TODO: use ActionController::StatusCodes
+  HTTP_STATUS_CODES = {
+    "400" => "Bad Request",
+    "403" => "Forbidden",
+    "404" => "Not Found",
+    "405" => "Method Not Allowed",
+    "410" => "Gone",
+    "418" => "I'm a teapot",
+    "422" => "Unprocessable Entity",
+    "423" => "Locked",
+    "500" => "Internal Server Error",
+    "501" => "Not Implemented",
+    "503" => "Service Unavailable"
+  } unless defined?(HTTP_STATUS_CODES)
+
+  def codes_for_error_classes
+    #TODO: Format whitespace
+    classes = {
+      # These are standard errors in rails / ruby
+      NameError => "503",
+      TypeError => "503",
+      RuntimeError => "500",
+      ArgumentError => "500",
+      # These are custom error names defined in lib/super_exception_notifier/custom_exception_classes
+      AccessDenied => "403",
+      PageNotFound => "404",
+      InvalidMethod => "405",
+      ResourceGone => "410",
+      CorruptData => "422",
+      NoMethodError => "500",
+      NotImplemented => "501",
+      MethodDisabled => "200"
+    }
+    # Highly dependent on the verison of rails, so we're very protective about these'
+    classes.merge!({ ActionView::TemplateError => "500"})             if defined?(ActionView)       && ActionView.const_defined?(:TemplateError)
+    classes.merge!({ ActiveRecord::RecordNotFound => "400" })         if defined?(ActiveRecord)     && ActiveRecord.const_defined?(:RecordNotFound)
+    classes.merge!({ ActiveResource::ResourceNotFound => "404" })     if defined?(ActiveResource)   && ActiveResource.const_defined?(:ResourceNotFound)
+
+    if defined?(ActionController)
+      classes.merge!({ ActionController::UnknownController => "404" })          if ActionController.const_defined?(:UnknownController)
+      classes.merge!({ ActionController::MissingTemplate => "404" })            if ActionController.const_defined?(:MissingTemplate)
+      classes.merge!({ ActionController::MethodNotAllowed => "405" })           if ActionController.const_defined?(:MethodNotAllowed)
+      classes.merge!({ ActionController::UnknownAction => "501" })              if ActionController.const_defined?(:UnknownAction)
+      classes.merge!({ ActionController::RoutingError => "404" })               if ActionController.const_defined?(:RoutingError)
+      classes.merge!({ ActionController::InvalidAuthenticityToken => "405" })   if ActionController.const_defined?(:InvalidAuthenticityToken)
+    end
+  end
+end

data/lib/exception_notification/hooks_notifier.rb

@@ -0,0 +1,53 @@
+require 'net/http'
+require 'uri'
+
+module ExceptionNotification::HooksNotifier
+  # Deliver exception data hash to web hooks, if any
+  #
+  def self.deliver_exception_to_web_hooks(config, exception, controller, request, data={}, the_blamed = nil)
+    params = build_web_hook_params(config, exception, controller, request, data, the_blamed)
+    # TODO: use threads here
+    config[:web_hooks].each do |address|
+      post_hook(params, address)
+    end
+  end
+
+
+  # Parameters hash based on Merb Exceptions example
+  #
+  def self.build_web_hook_params(config, exception, controller, request, data={}, the_blamed = nil)
+    host = (request.env["HTTP_X_FORWARDED_HOST"] || request.env["HTTP_HOST"])
+    p = {
+      'environment'              => (defined?(Rails) ? Rails.env : RAILS_ENV),
+      'exceptions'               => [{
+        :class      => exception.class.to_s,
+        :backtrace  => exception.backtrace,
+        :message    => exception.message
+        }],
+      'app_name'                 => config[:app_name],
+      'version'                  => config[:version],
+      'blame'                    => "#{the_blamed}"
+    }
+    if !request.nil?
+      p.merge!({'request_url'         => "#{request.protocol}#{host}#{request.request_uri}"})
+      p.merge!({'request_action'      => request.parameters['action']})
+      p.merge!({'request_params'      => request.parameters.inspect})
+    end
+    p.merge!({'request_controller'    => controller.class.name}) if !controller.nil?
+    p.merge!({'status'                => exception.status}) if exception.respond_to?(:status)
+    return p
+  end
+
+  def self.post_hook(params, address)
+    uri = URI.parse(address)
+    uri.path = '/' if uri.path=='' # set a path if one isn't provided to keep Net::HTTP happy
+
+    headers = { 'Content-Type' => 'text/x-json' }
+    data = params.to_json
+    Net::HTTP.start(uri.host, uri.port) do |http|
+      http.request_post(uri.path, data, headers)
+    end
+    data
+  end
+
+end

data/lib/exception_notification/notifiable.rb

@@ -0,0 +1,115 @@
+module ExceptionNotification::Notifiable
+  include ExceptionNotification::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]
+
+    base.cattr_accessor :notifiable_pass_through
+    base.notifiable_pass_through = false
+  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 environment_is_noisy?
+    !self.notifiable_noisy_environments.include?(Rails.env)
+  end
+
+  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 = ExceptionNotification::Notifier.config[:git_repo_path].nil? ? nil : lay_blame(exception)
+    rejected_sections = %w(request session)
+    verbose_output(exception, status_code, "rescued by handler", send_email, send_web_hooks, nil, the_blamed, rejected_sections) if verbose
+    # Send the exception notification email
+    perform_exception_notify_mailing(exception, data, nil, the_blamed, verbose, rejected_sections) if send_email
+    # Send Web Hook requests
+    ExceptionNotification::HooksNotifier.deliver_exception_to_web_hooks(ExceptionNotification::Notifier.config, exception, self, request, data, the_blamed) if send_web_hooks
+    pass_it_on(exception)
+  end
+
+  def pass_it_on(exception, request = nil)
+    begin
+      request ||= {:params => {}}
+      case self.class.notifiable_pass_through
+        when :hoptoad then
+          HoptoadNotifier.notify(exception, {:request => request})
+          puts "[PASS-IT-ON] HOPTOAD NOTIFIED" if verbose
+        else
+          puts "[PASS-IT-ON] NO" if verbose
+          #nothing
+      end
+    rescue
+      #nothing
+    end
+  end
+
+  def is_local? #like asking is_silent?
+    self.notifiable_noisy_environments.include?(Rails.env)
+  end
+
+end

data/lib/exception_notification/notifiable_helper.rb

@@ -0,0 +1,77 @@
+#Copyright (c) 2008-2009 Peter H. Boling of 9thBit LLC
+#Released under the MIT license
+
+module ExceptionNotification::NotifiableHelper
+  include ExceptionNotification::CustomExceptionClasses
+  include ExceptionNotification::CustomExceptionMethods
+  include ExceptionNotification::HelpfulHashes
+  include ExceptionNotification::GitBlame
+  include ExceptionNotification::HooksNotifier
+
+  private
+
+  def get_method_name
+    if  /`(.*)'/.match(caller.first)
+      return $1
+    end
+    nil
+  end
+
+  def get_exception_data
+    deliverer = self.class.exception_data
+    return case deliverer
+      when nil then {}
+      when Symbol then send(deliverer)
+      when Proc then deliverer.call(self)
+    end
+  end
+
+  def verbose_output(exception, status_cd, file_path, send_email, send_web_hooks, request = nil, the_blamed = nil, rejected_sections = nil)
+    puts "[EXCEPTION] #{exception}"
+    puts "[EXCEPTION CLASS] #{exception.class}"
+    puts "[EXCEPTION STATUS_CD] #{status_cd}"
+    puts "[ERROR LAYOUT] #{self.class.error_layout}" if self.class.respond_to?(:error_layout)
+    puts "[ERROR VIEW PATH] #{ExceptionNotification::Notifier.config[:view_path]}" if !ExceptionNotification::Notifier.nil? && !ExceptionNotification::Notifier.config[:view_path].nil?
+    puts "[ERROR FILE PATH] #{file_path.inspect}"
+    puts "[ERROR EMAIL] #{send_email ? "YES" : "NO"}"
+    puts "[ERROR WEB HOOKS] #{send_web_hooks ? "YES" : "NO"}"
+    puts "[THE BLAMED] #{the_blamed}"
+    puts "[SECTIONS] #{ExceptionNotification::Notifier.sections_for_email(rejected_sections, request)}"
+    req = request ? " for request_uri=#{request.request_uri} and env=#{request.env.inspect}" : ""
+    logger.error("render_error(#{status_cd}, #{self.class.http_status_codes[status_cd]}) invoked#{req}") if self.class.respond_to?(:http_status_codes) && !logger.nil?
+  end
+
+  def perform_exception_notify_mailing(exception, data, request = nil, the_blamed = nil, verbose = false, rejected_sections = nil)
+    if ExceptionNotification::Notifier.config[:exception_recipients].blank?
+      puts "[EMAIL NOTIFICATION] ExceptionNotification::Notifier.config[:exception_recipients] is blank, notification cancelled!" if verbose
+    else
+      class_name = self.respond_to?(:controller_name) ? self.controller_name : self.to_s
+      method_name = self.respond_to?(:action_name) ? self.action_name : get_method_name
+      ExceptionNotification::Notifier.deliver_exception_notification(exception, class_name, method_name,
+        request, data, the_blamed, rejected_sections)
+      puts "[EMAIL NOTIFICATION] Sent" if verbose
+    end
+  end
+
+  def should_email_on_exception?(exception, status_cd = nil, verbose = false)
+    environment_is_noisy? && notification_level_sends_email? && !ExceptionNotification::Notifier.config[:exception_recipients].blank? && should_notify_on_exception?(exception, status_cd, verbose)
+  end
+
+  def should_web_hook_on_exception?(exception, status_cd = nil, verbose = false)
+    environment_is_noisy? && notification_level_sends_web_hooks? && !ExceptionNotification::Notifier.config[:web_hooks].blank? && should_notify_on_exception?(exception, status_cd, verbose)
+  end
+
+  # Relies on the base class to define be_silent_for_exception?
+  def should_notify_on_exception?(exception, status_cd = nil, verbose = false)
+    # don't notify (email or web hooks) on exceptions raised locally
+    verbose && ExceptionNotification::Notifier.config[:skip_local_notification] && is_local? ?
+        "[NOTIFY LOCALLY] NO" :
+         nil
+    return false if ExceptionNotification::Notifier.config[:skip_local_notification] && is_local?
+    # don't notify (email or web hooks) exceptions raised that match ExceptionNotifiable.notifiable_silent_exceptions
+    return false if self.be_silent_for_exception?(exception)
+    return true if ExceptionNotification::Notifier.config[:notify_error_classes].include?(exception.class)
+    return true if !status_cd.nil? && ExceptionNotification::Notifier.config[:notify_error_codes].include?(status_cd)
+    return ExceptionNotification::Notifier.config[:notify_other_errors]
+  end
+end

data/lib/exception_notification/notified_task.rb

@@ -0,0 +1,15 @@
+class NotifiedTask < Rake::TaskLib
+  attr_accessor :name, :block
+
+  def initialize(name, &block)
+    @name = name
+    @block = block
+    define
+  end
+
+  def define
+    task name do |t|
+      notifiable { block.call }
+    end
+  end
+end

data/lib/exception_notification/notifier.rb

@@ -0,0 +1,174 @@
+require 'pathname'
+
+class ExceptionNotification::Notifier < 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 << ExceptionNotification::Notifier.filenamify(e)
+
+    last_colon = e.rindex(':')
+    unless last_colon.nil?
+      filenames << ExceptionNotification::Notifier.filenamify(e[(last_colon + 1)..(e.length - 1)])
+    end
+    filenames
+  end
+
+  def self.sections_for_email(rejected_sections, request)
+    rejected_sections = rejected_sections.nil? ? request.nil? ? %w(request session) : [] : rejected_sections
+    rejected_sections.empty? ? config[:sections] : config[:sections].reject{|s| rejected_sections.include?(s) }
+  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 = ExceptionNotification::Notifier.get_view_path(status_cd, verbose)
+    file_name.nil? ? self.catch_all(verbose) : file_name
+  end
+
+#  def self.get_view_path_for_files(filenames = [])
+#    filepaths = filenames.map do |file|
+#      ExceptionNotification::Notifier.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(verbose) if exception.nil?
+    #return self.catch_all(verbose) 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 = ExceptionNotification::Notifier.exception_to_filenames(exception).map do |file|
+      ExceptionNotification::Notifier.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:A] #{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:B] #{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:C] #{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:D] #{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")
+      puts "[FOUND FILE:E] #{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, rejected_sections = nil)
+    body_hash = error_environment_data_hash(exception, class_name, method_name, request, data, the_blamed, rejected_sections)
+    #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, rejected_sections = %w(request session))
+    exception_notification(exception, nil, nil, nil, data, the_blamed, rejected_sections)
+  end
+
+  def rake_exception_notification(exception, task, data={}, the_blamed = nil, rejected_sections = %w(request session))
+    exception_notification(exception, "", "#{task.name}", nil, data, the_blamed, rejected_sections)
+  end
+
+  private
+
+    def error_environment_data_hash(exception, class_name = nil, method_name = nil, request = nil, data = {}, the_blamed = nil, rejected_sections = 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}"})
+      elsif method_name
+        data.merge!({:location => "#{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"])})
+      end
+      data.merge!({:sections => ExceptionNotification::Notifier.sections_for_email(rejected_sections, request)})
+      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_notification/notifier_helper.rb

@@ -0,0 +1,59 @@
+require 'pp'
+
+module ExceptionNotification::NotifierHelper
+  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)
+
+  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? ? @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 @controller.__send__(:filter_parameters, {env_key => env_value}).values[0]
+  end
+end

data/rails/init.rb

@@ -1,4 +1,3 @@
-puts "Begin Loading ExceptionNotification"
 require 'rake'
 require 'rake/tasklib'
 require "action_mailer"
@@ -10,8 +9,6 @@ require "exception_notification" unless defined?(ExceptionNotification)
 Object.class_eval do
   include ExceptionNotification::Notifiable
 end
-puts "Object test: #{Object.respond_to?(:notifiable_noisy_environments) ? 'Pass' : 'Fail'}"
-puts "Finished Loading ExceptionNotification"
 
 #It appears that the view path is auto-added by rails... hmmm.
 #if ActionController::Base.respond_to?(:append_view_path)

data/super_exception_notifier.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{super_exception_notifier}
-  s.version = "3.0.2"
+  s.version = "3.0.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Peter Boling", "Scott Windsor", "Ismael Celis", "Jacques Crocker", "Jamis Buck"]
@@ -39,6 +39,19 @@ Gem::Specification.new do |s|
      "VERSION.yml",
      "init.rb",
      "lib/exception_notification.rb",
+     "lib/exception_notification/consider_local.rb",
+     "lib/exception_notification/custom_exception_classes.rb",
+     "lib/exception_notification/custom_exception_methods.rb",
+     "lib/exception_notification/deprecated_methods.rb",
+     "lib/exception_notification/exception_notifiable.rb",
+     "lib/exception_notification/git_blame.rb",
+     "lib/exception_notification/helpful_hashes.rb",
+     "lib/exception_notification/hooks_notifier.rb",
+     "lib/exception_notification/notifiable.rb",
+     "lib/exception_notification/notifiable_helper.rb",
+     "lib/exception_notification/notified_task.rb",
+     "lib/exception_notification/notifier.rb",
+     "lib/exception_notification/notifier_helper.rb",
      "rails/app/views/exception_notifiable/400.html",
      "rails/app/views/exception_notifiable/403.html",
      "rails/app/views/exception_notifiable/404.html",

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 3
   - 0
-  - 2
-  version: 3.0.2
+  - 4
+  version: 3.0.4
 platform: ruby
 authors: 
 - Peter Boling
@@ -78,6 +78,19 @@ files:
 - VERSION.yml
 - init.rb
 - lib/exception_notification.rb
+- lib/exception_notification/consider_local.rb
+- lib/exception_notification/custom_exception_classes.rb
+- lib/exception_notification/custom_exception_methods.rb
+- lib/exception_notification/deprecated_methods.rb
+- lib/exception_notification/exception_notifiable.rb
+- lib/exception_notification/git_blame.rb
+- lib/exception_notification/helpful_hashes.rb
+- lib/exception_notification/hooks_notifier.rb
+- lib/exception_notification/notifiable.rb
+- lib/exception_notification/notifiable_helper.rb
+- lib/exception_notification/notified_task.rb
+- lib/exception_notification/notifier.rb
+- lib/exception_notification/notifier_helper.rb
 - rails/app/views/exception_notifiable/400.html
 - rails/app/views/exception_notifiable/403.html
 - rails/app/views/exception_notifiable/404.html