pboling-super_exception_notifier 1.6.5

data/init.rb

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

data/lib/exception_notifiable.rb

@@ -0,0 +1,278 @@
+require 'ipaddr'
+
+module ExceptionNotifiable
+  include SuperExceptionNotifier::CustomExceptionClasses
+  include SuperExceptionNotifier::CustomExceptionMethods
+  include HooksNotifier
+
+  unless defined?(SILENT_EXCEPTIONS)
+    SILENT_EXCEPTIONS = []
+    SILENT_EXCEPTIONS << ActiveRecord::RecordNotFound if defined?(ActiveRecord)
+    SILENT_EXCEPTIONS << [
+      ActionController::UnknownController,
+      ActionController::UnknownAction,
+      ActionController::RoutingError,
+      ActionController::MethodNotAllowed
+    ] if defined?(ActionController)
+  end
+
+  HTTP_ERROR_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_ERROR_CODES)
+  
+  def self.codes_for_rails_error_classes
+    classes = {
+      # These are standard errors in rails / ruby
+      NameError => "503",
+      TypeError => "503",
+      RuntimeError => "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
+  
+  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
+    #  Rails error classes to rescue and how to rescue them
+    #  error_layout:
+    #     can be defined at controller level to the name of the 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 :http_error_codes
+    base.http_error_codes = HTTP_ERROR_CODES
+    base.cattr_accessor :error_layout
+    base.error_layout = nil
+    base.cattr_accessor :rails_error_classes
+    base.rails_error_classes = self.codes_for_rails_error_classes
+    base.cattr_accessor :exception_notifier_verbose
+    base.exception_notifier_verbose = false
+    base.cattr_accessor :silent_exceptions
+    base.silent_exceptions = SILENT_EXCEPTIONS
+  end
+  
+  module ClassMethods
+    # 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
+  end
+
+  private
+
+    # 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)
+    def rescue_with_handler(exception)
+      to_return = super
+      if to_return
+        data = get_exception_data
+        send_email = should_notify_on_exception?(exception)
+        send_web_hooks = !ExceptionNotifier.config[:web_hooks].empty?
+        the_blamed = ExceptionNotifier.config[:git_repo_path].nil? ? nil : lay_blame(exception)
+        verbose_output(exception, "N/A", "rescued by handler", send_email, send_web_hooks, nil, the_blamed) if self.class.exception_notifier_verbose
+        # Send the exception notificaiton email
+        perform_exception_notify_mailing(exception, data, nil, the_blamed) 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!
+      status_code = status_code_for_exception(exception)
+      if status_code == '200'
+        notify_and_render_error_template(status_code, request, exception, exception_to_filename(exception))
+      else
+        notify_and_render_error_template(status_code, request, exception)
+      end
+    end
+
+    def notify_and_render_error_template(status_cd, request, exception, file_path = nil)
+      status = self.class.http_error_codes[status_cd] ? status_cd + " " + self.class.http_error_codes[status_cd] : status_cd
+      file = file_path ? ExceptionNotifier.get_view_path(file_path) : ExceptionNotifier.get_view_path(status_cd)
+      data = get_exception_data
+      send_email = should_notify_on_exception?(exception, status_cd)
+      send_web_hooks = !ExceptionNotifier.config[:web_hooks].empty?
+      the_blamed = ExceptionNotifier.config[:git_repo_path].nil? ? nil : lay_blame(exception)
+
+      # Debugging output
+      verbose_output(exception, status_cd, file, send_email, send_web_hooks, request, the_blamed) if self.class.exception_notifier_verbose
+      # Send the email before rendering to avert possible errors on render preventing the email from being sent.
+      perform_exception_notify_mailing(exception, data, request, the_blamed) 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
+      # Render the error page to the end user
+      render_error_template(file, status)
+    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 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
+
+    def verbose_output(exception, status_cd, file, send_email, send_web_hooks, request = nil, the_blamed = 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.error_layout
+      puts "[ERROR VIEW PATH] #{ExceptionNotifier.config[:view_path]}" if !ExceptionNotifier.nil? && !ExceptionNotifier.config[:view_path].nil?
+      puts "[ERROR RENDER] #{file}"
+      puts "[ERROR EMAIL] #{send_email ? "YES" : "NO"}"
+      puts "[ERROR WEB HOOKS] #{send_web_hooks ? "YES" : "NO"}"
+      puts "[COMPAT MODE] #{ExceptionNotifierHelper::COMPAT_MODE ? "Yes" : "No"}"
+      puts "[THE BLAMED] #{the_blamed}"
+      req = request ? " for request_uri=#{request.request_uri} and env=#{request.env.inspect}" : ""
+      logger.error("render_error(#{status_cd}, #{self.class.http_error_codes[status_cd]}) invoked#{req}") if !logger.nil?
+    end
+
+    def perform_exception_notify_mailing(exception, data, request = nil, the_blamed = nil)
+      if !ExceptionNotifier.config[:exception_recipients].blank?
+        # Send email with ActionMailer
+        ExceptionNotifier.deliver_exception_notification(exception, self,
+          request, data, the_blamed)
+      end
+    end
+
+    def should_notify_on_exception?(exception, status_cd = nil)
+      # First honor the custom settings from environment
+      return false if ExceptionNotifier.config[:render_only]
+      # don't mail exceptions raised locally
+      return false if ExceptionNotifier.config[:skip_local_notification] && is_local?
+      # don't mail exceptions raised that match ExceptionNotifiable.silent_exceptions
+      return false if self.class.silent_exceptions.any? {|klass| klass === exception }
+      return true if ExceptionNotifier.config[:send_email_error_classes].include?(exception)
+      return true if !status_cd.nil? && ExceptionNotifier.config[:send_email_error_codes].include?(status_cd)
+      return ExceptionNotifier.config[:send_email_other_errors]
+    end
+
+    def is_local?
+      (consider_all_requests_local || local_request?)
+    end
+
+    def status_code_for_exception(exception)
+      self.class.rails_error_classes[exception.class].nil? ? '500' : self.class.rails_error_classes[exception.class].blank? ? '200' : self.class.rails_error_classes[exception.class]
+    end
+
+    def exception_to_filename(exception)
+      exception.to_s.delete(':').gsub( /([A-Za-z])([A-Z])/, '\1' << '_' << '\2' ).downcase
+    end
+
+    def lay_blame(exception)
+      error = {}
+      unless(ExceptionNotifier.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 ExceptionNotifier.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.include?(RAILS_ROOT))
+        path
+      else
+        nil
+      end
+    end
+
+end

data/lib/exception_notifier.rb

@@ -0,0 +1,108 @@
+require 'pathname'
+
+class ExceptionNotifier < ActionMailer::Base
+
+  @@config = {
+    # If left empty web hooks will not be engaged
+    :web_hooks                => [],
+    :app_name                 => "[MYAPP]",
+    :version                  => "0.0.0",
+    :sender_address           => %("#{(defined?(Rails) ? Rails.env : RAILS_ENV).capitalize} Error" <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),
+    # Only use this gem to render, never email
+    :render_only              => false,
+    :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
+    :send_email_error_codes   => %W( 405 500 503 ),
+    #Error Notification will be sent if the error class matches one of the following error error classes
+    :send_email_error_classes => %W( ),
+    :send_email_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
+
+  # What is the path of the file we will render to the user?
+  def self.get_view_path(status_cd)
+    if File.exist?("#{RAILS_ROOT}/public/#{status_cd}.html")
+      "#{RAILS_ROOT}/public/#{status_cd}.html"
+    elsif !config[:view_path].nil? && File.exist?("#{RAILS_ROOT}/#{config[:view_path]}/#{status_cd}.html")
+      "#{RAILS_ROOT}/#{config[:view_path]}/#{status_cd}.html"
+    elsif File.exist?("#{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/#{status_cd}.html")
+      "#{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/#{status_cd}.html"
+    else 
+      "#{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/500.html"
+    end
+  end
+
+  def exception_notification(exception, controller = nil, request = nil, data={}, the_blamed=nil)
+    body_hash = error_environment_data_hash(exception, controller, 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
+
+  private
+
+    def error_environment_data_hash(exception, controller = 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
+      })
+
+      if controller && request
+        data.merge!({
+          :location => "#{controller.controller_name}##{controller.action_name}",
+          :controller => controller,
+          :request => request,
+          :host => (request.env['HTTP_X_REAL_IP'] || request.env["HTTP_X_FORWARDED_HOST"] || request.env["HTTP_HOST"]),
+          :sections => config[:sections]
+        })
+      else
+        # TODO: with refactoring, the environment section could show useful ENV data even without a request
+        data.merge!({
+          :location => sanitize_backtrace([exception.backtrace.first]).first,
+          :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,58 @@
+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 = "#{File.dirname(__FILE__)}/../#{VIEW_PATH}/_#{partial}.rhtml")
+      render(options.merge(:file => path, :use_full_path => false))
+    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