super_exception_notifier 3.0.13 → 3.0.14

data/README

@@ -1,120 +0,0 @@
-= Super Exception Notifier
-
-The Super Exception Notifier (SEN) gem provides a mailer object and a default set of templates 
-for sending email notifications when errors occur in a Rails application, as well as a default 
-set of error page templates to render based on the status code assigned to an error.  The gem 
-is configurable, allowing programmers to customize (settings are per environment or per class):
-
-* the sender address of the email
-* the recipient addresses
-* text used to prepend and append 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
-* fine-grained customization of error layouts (or no layout)
-* 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]
-* Can notify of errors occurring in any method in any class in Ruby by wrapping the method call like this:
- notifiable { method }
-* Can notify of errors in Rake tasks using 'NotifiedTask.new' instead of 'task' when writing tasks
-* Works with Hoptoad Notifier, so you can notify via SEN and/or Hoptoad for any particular errors.
-* Tested with Rails 2.3.x, should work with Rails 2.2.x, and is apparently not yet compatible with Rails 3.
-
-The email includes information about the current request, session, and
-environment, and also gives a backtrace of the exception.
-
-This gem is based on the wonderful exception_notification plugin created by Jamis Buck. I have 
-modified it extensively and merged many of the improvements from a dozen or so other forks.  
-It remains a (mostly) drop in replacement with greatly extended functionality and customization 
-options.  I keep it up to date with the work on the core team's
-branch.
-
-The venerable original is here:
- 
-  http://github.com/rails/exception_notification
-
-The current version of this gem is a git fork of the original and has been updated to include 
-the latest improvements from the original, and many improvements from the other forks on github.  
-I merge them in when I have time, and when the changes fit nicely with the enhancements I have 
-already made.
-
-This fork of Exception Notifier is in production use on several large websites (top 5000).
-
-== Installation as RubyGem
-
-  [sudo] gem install super_exception_notifier
-
-More Installation Options are here: http://wiki.github.com/pboling/exception_notification/installation
-
-== Configuration as RubyGem
-
-  config.gem 'super_exception_notifier', :lib => "exception_notification"
-
-More Configuration Options are here: http://wiki.github.com/pboling/exception_notification/configuration
-
-== Configuration In Environment (Initializer)
-
-  ExceptionNotification::Notifier.configure_exception_notifier do |config|
-    config[:app_name]                 = "[MYAPP]"
-    config[:sender_address]           = "super.exception.notifier@example.com"
-    config[:exception_recipients]     = [] # You need to set at least one recipient if you want to get the notifications
-    # In a local environment 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[:skip_local_notification]  = 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 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 attempt to use git blame to discover the person who made the last change to the problem code
-    config[:git_repo_path]            = nil # ssh://git@blah.example.com/repo/webapp.git
-  end
-
-More Configuration Options: http://wiki.github.com/pboling/exception_notification/advanced-environment-configuration
-
-== Handling Errors in Request Cycle
-
-1. Include the ExceptionNotification::ExceptionNotifiable mixin in whichever controller you want to generate error emails (typically ApplicationController):
-
-  class ApplicationController < ActionController::Base
-    ############################################################
-    # ERROR HANDLING et Foo
-    include ExceptionNotification::ExceptionNotifiable
-    #Comment out the line below if you want to see the normal rails errors in normal development.
-    alias :rescue_action_locally :rescue_action_in_public if Rails.env == 'development'
-    #self.error_layout = 'errors'
-    self.exception_notifiable_verbose = true #SEN uses logger.info, so won't be verbose in production
-    self.exception_notifiable_pass_through = :hoptoad # requires the standard hoptoad gem to be installed, and setup normally
-    self.exception_notifiable_silent_exceptions = [Acl9::AccessDenied, MethodDisabled, ActionController::RoutingError ]
-    #specific errors can be handled by something else:
-    rescue_from 'Acl9::AccessDenied', :with => :access_denied
-    # END ERROR HANDLING
-    ############################################################
-    ...
-  end
-  
-2. Specify the email recipients in your environment (You should have already done this in the "Configuration in Environment (Initializer)" step above):
-
-  ExceptionNotification::Notifier.configure_exception_notifier do |config|
-    config[:exception_recipients] = %w(joe@example.com bill@example.com)
-  end
-
-3. Make sure you have your ActionMailer server settings correct if you are using the e-mail features.
-
-4. That’s it! The defaults take care of the rest.
-
-http://wiki.github.com/pboling/exception_notification/exceptions-inside-request-cycle
-
-== Advanced Configuration
-
-There is a lot more you can configure, and do:
-
-http://wiki.github.com/pboling/exception_notification/

data/VERSION.yml

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

data/init.rb

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

data/super_exception_notifier.gemspec

@@ -1,113 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{super_exception_notifier}
-  s.version = "3.0.13"
-
-  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"]
-  s.date = %q{2010-06-30}
-  s.description = %q{Allows customization of:
-* Specify which level of notification you would like with an array of optional styles of notification (email, webhooks)
-* the sender address of the email
-* the recipient addresses
-* the text used to prefix the subject line
-* the HTTP status codes to notify for
-* the error classes to send emails for
-* alternatively, the error classes to not notify 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)
-* Can notify of errors occurring in any class/method using notifiable { method }
-* Can notify of errors in Rake tasks using NotifiedTask.new instead of task
-* Works with Hoptoad Notifier, so you can notify via SEN and/or Hoptoad for any particular errors.
-* Tested with Rails 2.3.x, should work with rails 2.2.x, and is apparently not yet compatible with rails 3.}
-  s.email = %q{peter.boling@gmail.com}
-  s.extra_rdoc_files = [
-    "README"
-  ]
-  s.files = [
-    "CHANGELOG.txt",
-     "MIT-LICENSE",
-     "README",
-     "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",
-     "lib/views/exception_notification/notifier/_backtrace.html.erb",
-     "lib/views/exception_notification/notifier/_environment.html.erb",
-     "lib/views/exception_notification/notifier/_inspect_model.html.erb",
-     "lib/views/exception_notification/notifier/_request.html.erb",
-     "lib/views/exception_notification/notifier/_session.html.erb",
-     "lib/views/exception_notification/notifier/_title.html.erb",
-     "lib/views/exception_notification/notifier/background_exception_notification.text.plain.erb",
-     "lib/views/exception_notification/notifier/exception_notification.text.plain.erb",
-     "lib/views/exception_notification/notifier/rake_exception_notification.text.plain.erb",
-     "rails/app/views/exception_notifiable/400.html",
-     "rails/app/views/exception_notifiable/403.html",
-     "rails/app/views/exception_notifiable/404.html",
-     "rails/app/views/exception_notifiable/405.html",
-     "rails/app/views/exception_notifiable/410.html",
-     "rails/app/views/exception_notifiable/418.html",
-     "rails/app/views/exception_notifiable/422.html",
-     "rails/app/views/exception_notifiable/423.html",
-     "rails/app/views/exception_notifiable/500.html",
-     "rails/app/views/exception_notifiable/501.html",
-     "rails/app/views/exception_notifiable/503.html",
-     "rails/app/views/exception_notifiable/method_disabled.html.erb",
-     "rails/init.rb",
-     "super_exception_notifier.gemspec"
-  ]
-  s.homepage = %q{http://github.com/pboling/exception_notification}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{Allows unhandled (and handled!) exceptions to be captured and sent via email}
-  s.test_files = [
-    "test/exception_notifiable_test.rb",
-     "test/exception_notifier_helper_test.rb",
-     "test/exception_notifier_test.rb",
-     "test/exception_notify_functional_test.rb",
-     "test/mocks/controllers.rb",
-     "test/notifiable_test.rb",
-     "test/test_helper.rb"
-  ]
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<actionmailer>, [">= 0"])
-      s.add_runtime_dependency(%q<rake>, [">= 0"])
-    else
-      s.add_dependency(%q<actionmailer>, [">= 0"])
-      s.add_dependency(%q<rake>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<actionmailer>, [">= 0"])
-    s.add_dependency(%q<rake>, [">= 0"])
-  end
-end
-

data/test/exception_notifiable_test.rb

@@ -1,34 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-class ExceptionNotifiableTest < Test::Unit::TestCase
-
-  def setup
-    @controller = BasicController.new
-  end
-
-  #Tests for the default values when ExceptionNotifiable is included in a controller
-  def test_default_http_status_codes
-    assert(BasicController.http_status_codes == HTTP_STATUS_CODES, "Default http_status_codes is incorrect")
-  end
-
-  def test_default_error_layout
-    assert(BasicController.error_layout == nil, "Default error_layout is incorrect")
-  end
-
-  def test_default_error_class_status_codes
-    assert(BasicController.error_class_status_codes == BasicController.codes_for_error_classes, "Default error_class_status_codes is incorrect")
-  end
-
-  def test_default_exception_notifiable_verbose
-    assert(BasicController.exception_notifiable_verbose == false, "Default exception_notifiable_verbose is incorrect")
-  end
-
-  def test_default_exception_notifiable_silent_exceptions
-    assert(BasicController.exception_notifiable_silent_exceptions == SILENT_EXCEPTIONS, "Default exception_notifiable_silent_exceptions is incorrect")
-  end
-
-  def test_default_exception_notifiable_notification_level
-    assert(BasicController.exception_notifiable_notification_level == [:render, :email, :web_hooks], "Default exception_notifiable_notification_level is incorrect")
-  end
-
-end

data/test/exception_notifier_helper_test.rb

@@ -1,68 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-#require 'exception_notification/notifier_helper'
-
-class ExceptionNotifierHelperTest < Test::Unit::TestCase
-
-  class ExceptionNotifierHelperIncludeTarget
-    include ExceptionNotification::NotifierHelper
-  end
-
-  def setup
-    @helper = ExceptionNotifierHelperIncludeTarget.new
-  end
-
-  # No controller
-
-  def test_should_not_exclude_raw_post_parameters_if_no_controller
-    assert !@helper.exclude_raw_post_parameters?
-  end
-
-  # Controller, no filtering
-
-  class ControllerWithoutFilterParameters; end
-
-  def test_should_not_filter_env_values_for_raw_post_data_keys_if_controller_can_not_filter_parameters
-    stub_controller(ControllerWithoutFilterParameters.new)
-    assert @helper.filter_sensitive_post_data_from_env("RAW_POST_DATA", "secret").include?("secret")
-  end
-  def test_should_not_exclude_raw_post_parameters_if_controller_can_not_filter_parameters
-    stub_controller(ControllerWithoutFilterParameters.new)
-    assert !@helper.exclude_raw_post_parameters?
-  end
-  def test_should_return_params_if_controller_can_not_filter_parameters
-    stub_controller(ControllerWithoutFilterParameters.new)
-    assert_equal :params, @helper.filter_sensitive_post_data_parameters(:params)
-  end
-
-  # Controller with filter paramaters method, no params to filter
-
-  class ControllerWithFilterParametersThatDoesntFilter
-    def filter_parameters(params); params end
-  end
-
-  def test_should_filter_env_values_for_raw_post_data_keys_if_controller_can_filter_parameters
-    stub_controller(ControllerWithFilterParametersThatDoesntFilter.new)
-    assert !@helper.filter_sensitive_post_data_from_env("RAW_POST_DATA", "secret").include?("secret")
-    assert @helper.filter_sensitive_post_data_from_env("SOME_OTHER_KEY", "secret").include?("secret")
-  end
-  def test_should_exclude_raw_post_parameters_if_controller_can_filter_parameters
-    stub_controller(ControllerWithFilterParametersThatDoesntFilter.new)
-    assert @helper.exclude_raw_post_parameters?
-  end
-
-  # Controller with filter paramaters method, filtering a secret param
-
-  class ControllerWithFilterParametersThatDoesFilter
-    def filter_parameters(params); :filtered end
-  end
-
-  def test_should_delegate_param_filtering_to_controller_if_controller_can_filter_parameters
-    stub_controller(ControllerWithFilterParametersThatDoesFilter.new)
-    assert_equal :filtered, @helper.filter_sensitive_post_data_parameters(:secret)
-  end
-
-  private
-    def stub_controller(controller)
-      @helper.instance_variable_set(:@controller, controller)
-    end
-end

data/test/exception_notifier_test.rb

@@ -1,41 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-require 'action_controller/test_process'
-
-class ExceptionNotifierTest < Test::Unit::TestCase
-  
-  def setup
-    @controller = ActionController::Base.new
-    @controller.request = ActionController::TestRequest.new
-    @controller.response = ActionController::TestResponse.new
-    @controller.params = {}
-    @controller.send(:initialize_current_url)
-    ActionController::Base.consider_all_requests_local = false
-    @@delivered_mail = []
-    ActionMailer::Base.class_eval do
-      def deliver!(mail = @mail)
-        @@delivered_mail << mail
-      end
-    end
-  end
-
-  def test_should_generate_message_without_controller
-    begin
-      raise 'problem'
-    rescue RuntimeError => e
-      assert_nothing_raised do
-        ExceptionNotification::Notifier.deliver_exception_notification(e)
-      end
-    end
-  end
-
-  def test_should_generate_message_with_controller
-    begin
-      raise 'problem'
-    rescue RuntimeError => e
-      assert_nothing_raised do
-        ExceptionNotification::Notifier.deliver_exception_notification(e, @controller, @controller.request)
-      end
-    end
-  end
-
-end

data/test/exception_notify_functional_test.rb

@@ -1,139 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/test_helper')
-require 'test/unit'
-
-require File.join(File.dirname(__FILE__), 'mocks/controllers')
-
-ActionController::Routing::Routes.clear!
-ActionController::Routing::Routes.draw {|m| m.connect ':controller/:action/:id' }
-
-class ExceptionNotifyFunctionalTest < ActionController::TestCase
-  
-  def setup
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new    
-    ActionController::Base.consider_all_requests_local = false
-    @@delivered_mail = []
-    ActionMailer::Base.class_eval do
-      def deliver!(mail = @mail)
-        @@delivered_mail << mail
-      end
-    end    
-  end
-
-  def test_view_path_200; assert_view_path_for_status_cd_is_string("200"); end
-  def test_view_path_400; assert_view_path_for_status_cd_is_string("400"); end
-  def test_view_path_403; assert_view_path_for_status_cd_is_string("403"); end
-  def test_view_path_404; assert_view_path_for_status_cd_is_string("404"); end
-  def test_view_path_405; assert_view_path_for_status_cd_is_string("405"); end
-  def test_view_path_410; assert_view_path_for_status_cd_is_string("410"); end
-  def test_view_path_418; assert_view_path_for_status_cd_is_string("422"); end
-  def test_view_path_422; assert_view_path_for_status_cd_is_string("422"); end
-  def test_view_path_423; assert_view_path_for_status_cd_is_string("423"); end
-  def test_view_path_500; assert_view_path_for_status_cd_is_string("500"); end
-  def test_view_path_501; assert_view_path_for_status_cd_is_string("501"); end
-  def test_view_path_503; assert_view_path_for_status_cd_is_string("503"); end
-  def test_view_path_nil; assert_view_path_for_status_cd_is_string(nil); end
-  def test_view_path_empty; assert_view_path_for_status_cd_is_string(""); end
-  def test_view_path_nonsense; assert_view_path_for_status_cd_is_string("slartibartfarst"); end
-  def test_view_path_class;
-    exception = ExceptionNotification::CustomExceptionClasses::MethodDisabled
-    assert_view_path_for_class_is_string(exception);
-    assert ExceptionNotification::Notifier.get_view_path_for_class(exception).match("/rails/app/views/exception_notifiable/method_disabled.html.erb")
-  end
-  def test_view_path_class_nil; assert_view_path_for_class_is_string(nil); end
-  def test_view_path_class_empty; assert_view_path_for_class_is_string(""); end
-  def test_view_path_class_nonsense; assert_view_path_for_class_is_string("slartibartfarst"); end
-  def test_view_path_class_integer; assert_view_path_for_class_is_string(Integer); end
-
-  def test_exception_to_filenames
-    assert(["exception_notification_custom_exception_classes_method_disabled", "method_disabled"] == ExceptionNotification::Notifier.exception_to_filenames(ExceptionNotification::CustomExceptionClasses::MethodDisabled))
-  end
-
-  def test_old_style_where_requests_are_local
-    ActionController::Base.consider_all_requests_local = true
-    @controller = OldStyle.new
-    get "runtime_error"    
-    assert_nothing_mailed
-  end
-
-  def test_new_style_where_requests_are_local
-    ActionController::Base.consider_all_requests_local = true
-    @controller = NewStyle.new
-    ExceptionNotification::Notifier.config[:skip_local_notification] = true
-    get "runtime_error"
-    assert_nothing_mailed
-  end
-  
-  def test_old_style_runtime_error_sends_mail
-    @controller = OldStyle.new
-    get "runtime_error"
-    assert_error_mail_contains("This is a runtime error that we should be emailed about")
-  end
-  
-  def test_old_style_record_not_found_does_not_send_mail
-    @controller = OldStyle.new
-    get "ar_record_not_found"
-    assert_nothing_mailed
-  end
-  
-  def test_new_style_runtime_error_sends_mail
-    @controller = NewStyle.new
-    get "runtime_error"
-    assert_error_mail_contains("This is a runtime error that we should be emailed about")    
-  end
-  
-  def test_new_style_record_not_found_does_not_send_mail
-    @controller = NewStyle.new
-    get "ar_record_not_found"    
-    assert_nothing_mailed
-  end
-
-  def test_controller_with_custom_silent_exceptions
-    @controller = CustomSilentExceptions.new
-    get "runtime_error"
-    assert_nothing_mailed
-  end
-
-  def test_controller_with_empty_silent_exceptions
-    @controller = EmptySilentExceptions.new
-    get "ar_record_not_found"
-    assert_error_mail_contains("ActiveRecord::RecordNotFound")
-  end
-
-  def test_controller_with_nil_silent_exceptions
-    @controller = NilSilentExceptions.new
-    get "ar_record_not_found"
-    assert_error_mail_contains("ActiveRecord::RecordNotFound")
-  end
-
-  def test_controller_with_default_silent_exceptions
-    @controller = DefaultSilentExceptions.new
-    get "unknown_controller"
-    assert_nothing_mailed
-  end
-
-  private
-
-  def assert_view_path_for_status_cd_is_string(status)
-    assert(ExceptionNotification::Notifier.get_view_path_for_status_code(status).is_a?(String), "View Path is not a string for status code '#{status}'")
-  end
-
-  def assert_view_path_for_class_is_string(exception)
-    assert(ExceptionNotification::Notifier.get_view_path_for_class(exception).is_a?(String), "View Path is not a string for exception '#{exception}'")
-  end
-
-  def assert_error_mail_contains(text)
-    assert(mailed_error.index(text), 
-          "Expected mailed error body to contain '#{text}', but not found. \n actual contents: \n#{mailed_error}")
-  end
-  
-  def assert_nothing_mailed
-    assert @@delivered_mail.empty?, "Expected to have NOT mailed out a notification about an error occuring, but mailed: \n#{@@delivered_mail}"
-  end
-  
-  def mailed_error
-    assert @@delivered_mail.last, "Expected to have mailed out a notification about an error occuring, but none mailed"
-    @@delivered_mail.last.encoded
-  end
-  
-end