pboling-super_exception_notifier 1.6.7 → 1.6.8

data/README.rdoc

@@ -23,6 +23,8 @@ New features:
 * get error notification for errors that occur in the console, using notifiable method
 * Hooks into `git blame` output so you can get an idea of who (may) have introduced the bug
 * Hooks into other website services (e.g. you can send exceptions to to Switchub.com)
+* Specify which level of notification you would like with an array of optional styles of notification:
+ [:render, :email, :web_hooks]
 
 The email includes information about the current request, session, and
 environment, and also gives a backtrace of the exception.
@@ -54,7 +56,7 @@ Gem Using Git building from source:
   git clone git://github.com/pboling/exception_notification.git
   cd exception_notification
   gem build exception_notification.gemspec
-  sudo gem install super_exception_notification-1.6.7.gem # (Or whatever version gets built)
+  sudo gem install super_exception_notification-1.6.8.gem # (Or whatever version gets built)
 
 Then cd to your rails app to optionally freeze the gem into your app:
 
@@ -63,7 +65,7 @@ Then cd to your rails app to optionally freeze the gem into your app:
 Then in your environment.rb:
 
   config.gem 'super_exception_notifier',
-      :version => '~> 1.6.7',
+      :version => '~> 1.6.8',
       :lib => "exception_notifier"
 
 
@@ -75,7 +77,7 @@ Installing Gem from Github's Gem Server:
 Then in your environment.rb:
 
   config.gem 'pboling-super_exception_notifier',
-      :version => '~> 1.6.7',
+      :version => '~> 1.6.9',
       :lib => "exception_notifier",
       :source => 'http://gems.github.com'
 
@@ -109,8 +111,9 @@ to generate error emails (typically ApplicationController):
 
 4. That's it!  The defaults take care of the rest.
 
-== Basic Configuration
+== Basic Environment Configuration
 
+These are settings that are global for SEN wherever it is used in your project.
 You can tweak other values to your liking, as well. In your environment file,
 just set any or all of the following values (defaults are shown):
 
@@ -118,6 +121,8 @@ just set any or all of the following values (defaults are shown):
     # If left empty web hooks will not be engaged
     config[:web_hooks]                = []
     config[:app_name]                 = "[MYAPP]"
+    # NOTE: THERE IS A BUG IN RAILS 2.3.3 which forces us to NOT use anything but a simple email address string for the sender address.
+    # https://rails.lighthouseapp.com/projects/8994/tickets/2340
     config[:sender_address]           = %("#{(defined?(Rails) ? Rails.env : RAILS_ENV).capitalize} Error" <super.exception.notifier@example.com>)
     config[:exception_recipients]     = []
     # Customize the subject line
@@ -127,21 +132,95 @@ just set any or all of the following values (defaults are shown):
     config[:sections]                 = %w(request session environment backtrace)
     # Only use this gem to render, never email
     #defaults to false - meaning by default it sends email.  Setting true will cause it to only render the error pages, and NOT email.
-    config[:render_only]              = false
-    config[:skip_local_notification   = true
+    config[:skip_local_notification]   = true
     # Example:
     #config[:view_path]               = 'app/views/error'
     config[:view_path]                = nil
-    #Error Notification will be sent if the HTTP response code for the error matches one of the following error codes
-    config[: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
-    config[:send_email_error_classes] = %W( )
-    config[:send_email_other_errors]  = true
+    # Error Notification will be sent if the HTTP response code for the error matches one of the following error codes
+    config[:notify_error_codes]   = %W( 405 500 503 )
+    # Error Notification will be sent if the error class matches one of the following error error classes
+    config[:notify_error_classes] = %W( )
+    # What should we do for errors not listed?
+    config[:notify_other_errors]  = true
     # If you set this SEN will
     config[:git_repo_path]            = nil
     config[:template_root]            = "#{File.dirname(__FILE__)}/../views"
   end
 
+== Basic Object Configuration
+
+In any controller you do this:
+    include ExceptionNotifiable
+
+Then that controller (or all of them if you put it in the application controller) will have its errors handled by SEN.
+You can customize how each controller handles exceptions on a per controller basis, or all together in the application controller.
+The availalbe configuration options are shown with their default settings:
+
+    #  HTTP status codes and what their 'English' status message is
+    self.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"
+    }
+    # 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
+    #   syntax is the same as the rails 'layout' method (which is to say a string)
+    self.error_layout = nil
+    # Rails error classes to rescue and how to rescue them (which error code to use)
+    self.rails_error_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'
+    self.rails_error_classes.merge!({ ActionView::TemplateError => "500"})             if defined?(ActionView)       && ActionView.const_defined?(:TemplateError)
+    self.rails_error_classes.merge!({ ActiveRecord::RecordNotFound => "400" })         if defined?(ActiveRecord)     && ActiveRecord.const_defined?(:RecordNotFound)
+    self.rails_error_classes.merge!({ ActiveResource::ResourceNotFound => "404" })     if defined?(ActiveResource)   && ActiveResource.const_defined?(:ResourceNotFound)
+
+    if defined?(ActionController)
+      self.rails_error_classes.merge!({ ActionController::UnknownController => "404" })          if ActionController.const_defined?(:UnknownController)
+      self.rails_error_classes.merge!({ ActionController::MissingTemplate => "404" })            if ActionController.const_defined?(:MissingTemplate)
+      self.rails_error_classes.merge!({ ActionController::MethodNotAllowed => "405" })           if ActionController.const_defined?(:MethodNotAllowed)
+      self.rails_error_classes.merge!({ ActionController::UnknownAction => "501" })              if ActionController.const_defined?(:UnknownAction)
+      self.rails_error_classes.merge!({ ActionController::RoutingError => "404" })               if ActionController.const_defined?(:RoutingError)
+      self.rails_error_classes.merge!({ ActionController::InvalidAuthenticityToken => "405" })   if ActionController.const_defined?(:InvalidAuthenticityToken)
+    end
+    # Verbosity of the gem (true or false) mainly useful for debugging
+    self.exception_notifier_verbose = false
+    # Do Not Ever send error notification emails for these Error Classes
+    self.silent_exceptions = []
+    self.silent_exceptions << ActiveRecord::RecordNotFound if defined?(ActiveRecord)
+    self.silent_exceptions << [
+      ActionController::UnknownController,
+      ActionController::UnknownAction,
+      ActionController::RoutingError,
+      ActionController::MethodNotAllowed
+    ] if defined?(ActionController)
+    # Notification Level
+    # Web Hooks, even though they are turned on by default, only get used if you actually configure them in the environment (see above)
+    # Email, even though it is turned on by default, only gets used if you actually configure recipients in the environment (see above)
+    self.notification_level = [:render, :email, :web_hooks]
+
 == Environmental Behavior
 
 Email notifications will only occur when the IP address is determined not to

data/VERSION.yml

@@ -1,4 +1,4 @@
 ---
 :major: 1
 :minor: 6
-:patch: 7
+:patch: 8

data/exception_notification.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name = 'super_exception_notifier'
-  s.version = '1.6.7'
-  s.date = '2009-08-14'
+  s.version = '1.6.8'
+  s.date = '2009-08-15'
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
 
   s.summary = %q{Allows unhandled (and handled!) exceptions to be captured and sent via email}
@@ -18,7 +18,10 @@ Gem::Specification.new do |s|
 * custom errors, with custom error templates
 * define error layouts at application or controller level, or use the controller's own default layout, or no layout at all
 * get error notification for errors that occur in the console, using notifiable method
-* Override the gem's handling and rendering with explicit rescue statements inline.}
+* Override the gem's handling and rendering with explicit rescue statements inline.
+* Hooks into `git blame` output so you can get an idea of who (may) have introduced the bug
+* Hooks into other website services (e.g. you can send exceptions to to Switchub.com)
+* Specify which level of notification you would like with an array of optional styles of notification}
   
   s.authors = ['Peter Boling', 'Jacques Crocker', 'Jamis Buck']
   s.email = 'peter.boling@gmail.com'

data/lib/exception_notifiable.rb

@@ -37,6 +37,7 @@ module ExceptionNotifiable
       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",
@@ -67,21 +68,26 @@ module ExceptionNotifiable
 
     # 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
+    # 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 :rails_error_classes
     base.rails_error_classes = self.codes_for_rails_error_classes
+    # Verbosity of the gem
     base.cattr_accessor :exception_notifier_verbose
     base.exception_notifier_verbose = false
+    # Do Not Ever send error notification emails for these Error Classes
     base.cattr_accessor :silent_exceptions
     base.silent_exceptions = SILENT_EXCEPTIONS
+    # Notification Level
+    base.cattr_accessor :notification_level
+    base.notification_level = [:render, :email, :web_hooks]
   end
   
   module ClassMethods
@@ -111,6 +117,16 @@ module ExceptionNotifiable
 
   private
 
+    def notification_level_renders?
+      self.class.notification_level.include?(:render)
+    end
+    def notification_level_sends_email?
+      self.class.notification_level.include?(:email)
+    end
+    def notification_level_sends_web_hooks?
+      self.class.notification_level.include?(:web_hooks)
+    end
+
     # overrides Rails' local_request? method to also check any ip
     # addresses specified through consider_local.
     def local_request?
@@ -123,10 +139,13 @@ module ExceptionNotifiable
       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?
+        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, self.class.exception_notifier_verbose)
+        #We only send web hooks if they've been configured in environment
+        send_web_hooks = should_web_hook_on_exception?(exception, status_code, self.class.exception_notifier_verbose)
         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
+        verbose_output(exception, status_code, "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
@@ -140,23 +159,26 @@ module ExceptionNotifiable
       # 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_notifier_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, self.class.exception_notifier_verbose))
+        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, self.class.exception_notifier_verbose))
+        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)
+    def notify_and_render_error_template(status_cd, request, exception, file_path, verbose = false)
       status = self.class.http_error_codes[status_cd] ? status_cd + " " + self.class.http_error_codes[status_cd] : status_cd
       data = get_exception_data
-      send_email = should_notify_on_exception?(exception, status_cd)
-      send_web_hooks = !ExceptionNotifier.config[:web_hooks].empty?
+      #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 self.class.exception_notifier_verbose
+      verbose_output(exception, status_cd, file_path, send_email, send_web_hooks, request, the_blamed) if 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
@@ -207,16 +229,28 @@ module ExceptionNotifiable
       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
+    def should_email_on_exception?(exception, status_cd = nil, verbose = false)
+      notification_level_sends_email? && !ExceptionNotifier.config[:exception_recipients].empty? && should_notify_on_exception?(exception, status_cd)
+    end
+
+    def should_web_hook_on_exception?(exception, status_cd = nil, verbose = false)
+      notification_level_sends_web_hooks? && !ExceptionNotifier.config[:web_hooks].empty? && should_notify_on_exception?(exception, status_cd)
+    end
+
+    def should_notify_on_exception?(exception, status_cd = nil, verbose = false)
+      puts "checking if should notify on exception E:#{exception} C: #{exception} SC: #{status_cd}" if verbose
+      # don't notify (email or web hooks) on exceptions raised locally
+      puts "skipping local notification" if verbose && ExceptionNotifier.config[:skip_local_notification] && is_local?
       return false if ExceptionNotifier.config[:skip_local_notification] && is_local?
-      # don't mail exceptions raised that match ExceptionNotifiable.silent_exceptions
+      # don't notify (email or web hooks) exceptions raised that match ExceptionNotifiable.silent_exceptions
+      puts "skipping silent exception notification: K:#{klass} E:#{exception} C:#{exception.class}" if verbose && self.class.silent_exceptions.any? {|klass| klass === exception }
       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]
+      puts "notifying for: E:#{exception} C:#{exception.class}" if verbose && ExceptionNotifier.config[:notify_error_classes].include?(exception)
+      return true if ExceptionNotifier.config[:notify_error_classes].include?(exception)
+      puts "notifying for status code: #{status_cd}" if verbose && !status_cd.nil? && ExceptionNotifier.config[:notify_error_codes].include?(status_cd)
+      return true if !status_cd.nil? && ExceptionNotifier.config[:notify_error_codes].include?(status_cd)
+      puts "Notify [#{ExceptionNotifier.config[:notify_other_errors] ? "YES" : "NO"}] Other Error: status code: #{status_cd} E:#{exception} C:#{exception.class}" if verbose
+      return ExceptionNotifier.config[:notify_other_errors]
     end
 
     def is_local?

data/lib/exception_notifier.rb

@@ -2,7 +2,8 @@ require 'pathname'
 
 class ExceptionNotifier < ActionMailer::Base
 
-  @@config = {
+    #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]",
@@ -14,15 +15,13 @@ class ExceptionNotifier < ActionMailer::Base
     :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 ),
+    :notify_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,
+    :notify_error_classes => %W( ),
+    :notify_other_errors  => true,
     :git_repo_path            => nil,
     :template_root            => "#{File.dirname(__FILE__)}/../views"
   }

data/rails/init.rb

@@ -6,13 +6,15 @@ require File.join(File.dirname(__FILE__), '..', 'lib', "super_exception_notifier
 # Add this path to ruby load path
 $:.unshift "#{File.dirname(__FILE__)}/../lib"
 
-require "hooks_notifier"
-require "exception_notifier"
-require "exception_notifiable"
-require "exception_notifier_helper"
-require "notifiable"
+require "hooks_notifier" unless defined?(HooksNotifier)
+require "exception_notifier" unless defined?(ExceptionNotifier)
+require "exception_notifiable" unless defined?(ExceptionNotifiable)
+require "exception_notifier_helper" unless defined?(ExceptionNotifierHelper)
+require "notifiable" unless defined?(Notifiable)
 
-Object.class_eval do include Notifiable end
+Object.class_eval do
+  include Notifiable
+end
 
 #It appears that the view path is auto-added by rails... hmmm.
 #if ActionController::Base.respond_to?(:append_view_path)

data/views/exception_notifier/_session.html.erb

@@ -3,5 +3,5 @@
 * data: <%= PP.pp(@request.session.instance_variable_get(:@data),"").gsub(/\n/, "\n  ").strip %>
 <%else -%>
 * session id: <%= @request.session_options[:id] %>
-* data: <%= PP.pp(@request.session.data, "").gsub(/\n/, "\n  ").strip %>
+* data: <%= PP.pp(@request.session.to_hash, "").gsub(/\n/, "\n  ").strip %>
 <% end -%>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: pboling-super_exception_notifier
 version: !ruby/object:Gem::Version 
-  version: 1.6.7
+  version: 1.6.8
 platform: ruby
 authors: 
 - Peter Boling
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-14 00:00:00 -07:00
+date: 2009-08-15 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -24,7 +24,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "2.1"
     version: 
-description: "Allows customization of: * the sender address of the email * the recipient addresses * the text used to prefix the subject line * the HTTP status codes to send emails for * the error classes to send emails for * alternatively, the error classes to not send emails for * whether to send error emails or just render without sending anything * the HTTP status and status code that gets rendered with specific errors * the view path to the error page templates * custom errors, with custom error templates * define error layouts at application or controller level, or use the controller's own default layout, or no layout at all * get error notification for errors that occur in the console, using notifiable method * Override the gem's handling and rendering with explicit rescue statements inline."
+description: "Allows customization of: * the sender address of the email * the recipient addresses * the text used to prefix the subject line * the HTTP status codes to send emails for * the error classes to send emails for * alternatively, the error classes to not send emails for * whether to send error emails or just render without sending anything * the HTTP status and status code that gets rendered with specific errors * the view path to the error page templates * custom errors, with custom error templates * define error layouts at application or controller level, or use the controller's own default layout, or no layout at all * get error notification for errors that occur in the console, using notifiable method * Override the gem's handling and rendering with explicit rescue statements inline. * Hooks into `git blame` output so you can get an idea of who (may) have introduced the bug * Hooks into other website services (e.g. you can send exceptions to to Switchub.com) * Specify which level of notification you would like with an array of optional styles of notification"
 email: peter.boling@gmail.com
 executables: []