super_exception_notifier 3.0.6 → 3.0.7

data/CHANGELOG.txt

@@ -0,0 +1,15 @@
+2009-01-28 v2.0.8
+- improve readme
+
+2009-12-30 v2.0.7
+- cite /rails/app/views/exception_notifiable/500.html in Rakefile (oops!)
+
+2009-12-30 v2.0.6
+- cite /rails/app/views/exception_notifiable/500.html in gemspec (oops!)
+
+2009-12-30 v2.0.5
+- use blank? instead of empty? so nils won't cause an error
+
+2009-11-04
+* Fixing Typos in Comments and Readme
+* General Readme cleanup

data/README

@@ -22,13 +22,10 @@ allowing programmers to customize (settings are per environment or per class):
 * 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]
-
-New features for 2.0.x:
-
 * 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.
 The email includes information about the current request, session, and
 environment, and also gives a backtrace of the exception.
 
@@ -54,105 +51,57 @@ This fork of Exception Notifier is in production use on several large websites (
 
   [sudo] gem install super_exception_notifier
 
-== Installation as RubyGem from source
-
-Use Git to build from source:
-
-  mkdir -p ~/src
-  cd ~/src
-  git clone git://github.com/pboling/exception_notification.git
-  cd exception_notification
-  gem build exception_notification.gemspec
-  sudo gem install super_exception_notification-2.0.0.gem # (Or whatever version gets built)
-
-Then cd to your rails app to optionally freeze the gem into your app:
-
-  rake gems:freeze GEM=super_exception_notifier
+More Installation Options are here: http://wiki.github.com/pboling/exception_notification/installation
 
-== Installation as Plugin from source:
+== Configuration as RubyGem
 
-Plugin using Git (let me know if you find any bugs, as I don't ever run it this way.):
+  config.gem 'super_exception_notifier', :lib => "exception_notification"
 
-  ./script/plugin install git://github.com/pboling/exception_notification.git
+More Configuration Options are here: http://wiki.github.com/pboling/exception_notification/configuration
 
-== Config.gem
-
-If installed as a gem, in your environment.rb:
-
-  config.gem 'super_exception_notifier',
-      :version => '~> 2.0.0',
-      :lib => "exception_notifier" #The :lib declaration is required!
-
-== 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 or initializer,
-just set any or all of the following values (defaults are shown):
+== Configuration In Environment (Initializer)
 
   ExceptionNotification::Notifier.configure_exception_notifier do |config|
-    # If left empty web hooks will not be engaged
-    config[:web_hooks]                = []
     config[:app_name]                 = "[MYAPP]"
     config[:sender_address]           = "super.exception.notifier@example.com"
-    config[:exception_recipients]     = []
-    # Customize the subject line
-    config[:subject_prepend]          = "[#{(defined?(Rails) ? Rails.env : RAILS_ENV).capitalize} ERROR] "
-    config[:subject_append]           = nil
-    # Include which sections of the exception email?
-    config[:sections]                 = %w(request session environment backtrace)
+    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
-    # 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[:notify_error_codes]   = %W( 405 500 503 )
-    # Error Notification will be sent if the error class matches one of the following error error classes
+    # 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
-    #This is the template root for the exception notification emails.  If you want to use your own set your own path.
-    #config[:template_root]            = "#{File.dirname(__FILE__)}/../views"
   end
 
-== Exceptions Without a Controller
-
-You may use SEN to send information about exceptions that
-occur while running application scripts without a controller. Simply wrap the
-code you want to watch with the notifiable method:
-
-  /PATH/TO/APP/script/runner -e production "notifiable { run_billing }"
-
-Or from the console:
+More Configuration Options: http://wiki.github.com/pboling/exception_notification/advanced-environment-configuration
 
-  >> notifiable { Rails.this_method_does_not_exist }
+== Handling Errors in Request Cycle
 
-== Exceptions in Rake Tasks
-
-Use 'NotifiedTask.new' instead of 'task':
-
-  NotifiedTask.new :sometask => :environment do
-    puts "I'm a task"
-  end
-
-== Exceptions Within a Controller
-
-1. Include the ExceptionNotifiable mixin in whichever controller you want
-to generate error emails (typically ApplicationController):
+1. Include the ExceptionNotification::ExceptionNotifiable mixin in whichever controller you want to generate error emails (typically ApplicationController):
 
   class ApplicationController < ActionController::Base
-    include ExceptionNotifiable
+    ############################################################
+    # 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_silent_exceptions = [MethodDisabled, ActionController::RoutingError ]
+    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:
+  
+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)
@@ -160,385 +109,12 @@ to generate error emails (typically ApplicationController):
 
 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.
-
-== Basic Controller 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 available configuration options are shown with their default settings, pulled from the gem's source:
-
-    #  HTTP status codes and what their 'English' status message is
-    self.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"
-    }
-
-    # 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.error_class_status_codes = {
-      # 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 version of rails, so we're very protective about these'
-    self.error_class_status_codes.merge!({ ActionView::TemplateError => "500"})             if defined?(ActionView)       && ActionView.const_defined?(:TemplateError)
-    self.error_class_status_codes.merge!({ ActiveRecord::RecordNotFound => "400" })         if defined?(ActiveRecord)     && ActiveRecord.const_defined?(:RecordNotFound)
-    self.error_class_status_codes.merge!({ ActiveResource::ResourceNotFound => "404" })     if defined?(ActiveResource)   && ActiveResource.const_defined?(:ResourceNotFound)
-
-    if defined?(ActionController)
-      self.error_class_status_codes.merge!({ ActionController::UnknownController => "404" })          if ActionController.const_defined?(:UnknownController)
-      self.error_class_status_codes.merge!({ ActionController::MissingTemplate => "404" })            if ActionController.const_defined?(:MissingTemplate)
-      self.error_class_status_codes.merge!({ ActionController::MethodNotAllowed => "405" })           if ActionController.const_defined?(:MethodNotAllowed)
-      self.error_class_status_codes.merge!({ ActionController::UnknownAction => "501" })              if ActionController.const_defined?(:UnknownAction)
-      self.error_class_status_codes.merge!({ ActionController::RoutingError => "404" })               if ActionController.const_defined?(:RoutingError)
-      self.error_class_status_codes.merge!({ ActionController::InvalidAuthenticityToken => "405" })   if ActionController.const_defined?(:InvalidAuthenticityToken)
-    end
-
-    # Verbosity of the gem (true or false) mainly useful for debugging
-    self.exception_notifiable_verbose = false
-
-    # Do Not Ever send error notification emails for these Error Classes
-    self.exception_notifiable_silent_exceptions = []
-    self.exception_notifiable_silent_exceptions << ActiveRecord::RecordNotFound if defined?(ActiveRecord)
-    if defined?(ActionController)
-      self.exception_notifiable_silent_exceptions << ActionController::UnknownController
-      self.exception_notifiable_silent_exceptions << ActionController::UnknownAction
-      self.exception_notifiable_silent_exceptions << ActionController::RoutingError
-      self.exception_notifiable_silent_exceptions << ActionController::MethodNotAllowed
-    end
-
-    # 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.exception_notifiable_notification_level = [:render, :email, :web_hooks]
-
-== Environmental Behavior
-
-Email notifications will only occur when the IP address is determined not to
-be local. You can specify certain addresses to always be local so that you'll
-get a detailed error instead of the generic error page. You do this in your
-controller (or even per-controller):
-
-  consider_local "64.72.18.143", "14.17.21.25"
-
-You can specify subnet masks as well, so that all matching addresses are
-considered local:
-
-  consider_local "64.72.18.143/24"
-
-The address "127.0.0.1" is always considered local. If you want to completely
-reset the list of all addresses (for instance, if you wanted "127.0.0.1" to
-NOT be considered local), you can simply do, somewhere in your controller:
-
-  local_addresses.clear
-
-== Error Layout Customization
-
-SEN allows you to specify the layout for errors at several levels:
-
-  * all errors use same layout site-wide
-  * customize a single controller
-  * can use the same layout as the controller
-  * no layout at all
-
-By default it will render the error with the layout the controller is using. You just need to set in application.rb (assuming you included ExceptionNotifiable in applicaiton.rb) (or per-controller):
-
-  # All Same site-wide (in application.rb)
-  self.error_layout = 'my_error_layout'
-  # customize a single controller
-  self.error_layout = 'example_controller_error_layout'
-  # Same layout as the current controller is using
-  self.error_layout = true
-  # No layout at all
-  self.error_layout = false
-
-SuperExceptionNotifier allows customization of the error classes that will be handled, and which HTTP status codes they will be handled as: (default values are shown)
-Example in application.rb or on a per-controller basis:
-
-  self.http_status_codes = { "200" => "OK"
-          "400" => "Bad Request",
-          "403" => "Forbidden",
-          "404" => "Not Found",
-          "405" => "Method Not Allowed",
-          "410" => "Gone",
-          "500" => "Internal Server Error",
-          "501" => "Not Implemented",
-          "503" => "Service Unavailable" }
-
-Q: Why is "200" listed as an error code?
-
-A: You may want to have multiple custom errors that the standard HTTP status codes weren't designed to accommodate, and for which you need to render customized pages. Explanation and examples are a little further down...
-
-Then you can specify which of those should send out emails!
-By default, the email notifier will only notify on critical errors (405 500 503 statuses).
-For example, ActiveRecord::RecordNotFound and ActionController::UnknownAction errors will simply render the contents of #{this gem's root}/rails/app/views/exception_notifiable/###.html file, where ### is 400 and 501 respectively.
-
-  ExceptionNotification::Notifier.config[:send_email_error_codes] = %w( 400 405 500 503 )
-
-You can also configure the text of the HTTP request's response status code: (by default only the last 6 will be handled, the first 6 are made up error classes)
-Example in application.rb or on a per-controller basis:
-
-  self.error_class_status_codes = {
-    NameError => "503",
-    TypeError => "503",
-    ActiveRecord::RecordNotFound => "400",
-	}
-
-To make up your own error classes, you can define them in environment.rb, or in application.rb, or wherever you need them.
-These are defined by the gem and are available to you in controllers once ExceptionNotifiable is included in application.rb or the current controller:
-
-    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
-
-Methods like this are also defined by the gem in super_exception_notifier/custom_exception_methods.rb:
-  def access_denied
-    raise AccessDenied
-  end
-
-They can be used like this in a controller:
-  before_filter :owner_required
-  protected
-    def owner_required
-      access_denied unless current_user.id == @photo.user_id
-    end
-  public
-  #... rest of controller
-   
-You may also configure which HTTP status codes will send out email: (by default = [], email sending is defined by status code only)
-
-  ExceptionNotification::Notifier.config[:send_email_error_classes] = [
-    NameError, 
-    TypeError, 
-    ActionController::RoutingError 
-  ]
-
-Email will be sent if the error matches one of the error classes to send email for OR if the error's assigned HTTP status code is configured to send email!
-
-You can also customize what is rendered. SuperExceptionNotifier will render the first file it finds in this order:
-
-  #{RAILS_ROOT}/public/###.html
-  #{RAILS_ROOT}/#{ExceptionNotification::Notifier.config[:view_path]}/###.html
-  #{this gem's root}/rails/app/views/exception_notifiable/#{status_cd}.html
-
-And if none of those paths has a valid file to render, this one wins:
-
-  #{this gem's root}/rails/app/views/exception_notifiable/500.html
-
-You can configure ExceptionNotification::Notifier.config[:view_path] in your environment file like this:
-
-  ExceptionNotification::Notifier.config[:view_path] = 'app/views/error'
-
-So public trumps your custom path which trumps the gem's default path.
-
-== Custom Error Pages
-
-You can render CUSTOM error pages! Here's how:
-
-  1. Make sure 200 is one of your status codes (optional)
-    * self.http_status_codes = { "200" => "OK" }
-  2. Setup your custom error class, e.g. in config/environment.rb:
-    * class InsufficientFundsForWithdrawal < StandardError; end
-  3. Setup SuperExceptionNotifier to handle the error, in app/controllers/application.rb:
-    * self.error_class_status_codes = { InsufficientFundsForWithdrawal => "200" }
-  4. Set your custom error's view path:
-    * ExceptionNotification::Notifier.config[:view_path] = 'app/views/error'
-  5. Create a view for the error. SuperExceptionNotifier munges the error's class by converting to a string and then replacing consecutive ':' with '' and then downcases it:
-    * touch app/views/error/insufficient_funds_for_withdrawal.html
-  6. If you want a custom layout (by default it will render the error with the layout the controller is using) you just need to set, in application.rb (or per-controller):
-    * self.error_layout = 'my_error_layout' #or = true for the same layout as the controller, or = false for no layout
-  7. That's it! All errors that are set to be handled with a status of "200" will render a custom page.
-  8. If you want to have errors that render custom pages also send emails then you'll need to:
-    * ExceptionNotification::Notifier.config[:send_email_error_classes] = [ InsufficientFundsForWithdrawal ]
-
-== Customization
-
-By default, the notification email includes four parts: request, session,
-environment, and backtrace (in that order). You can customize how each of those
-sections are rendered by placing a partial named for that part in your
-app/views/exception_notifier directory (e.g., _session.rhtml). Each partial has
-access to the following variables:
-
-* @controller: the controller that caused the error
-* @request: the current request object
-* @exception: the exception that was raised
-* @host: the name of the host that made the request
-* @backtrace: a sanitized version of the exception's backtrace
-* @rails_root: a sanitized version of RAILS_ROOT
-* @data: a hash of optional data values that were passed to the notifier
-* @sections: the array of sections to include in the email
-
-You can reorder the sections, or exclude sections completely, by altering the
-ExceptionNotification::Notifier.config[:sections] variable.
-
-== Not working due to nature of gem vs plugin
-
-This might work if you install the gem as a plugin.
-
-You can even add new sections that describe application-specific data --
-just add the section's name to the list (wherever you'd like), and define the
-corresponding partial. Then, if your new section requires information that isn't
-available by default, make sure it is made available to the email using the
-exception_data macro:
-
-  class ApplicationController < ActionController::Base
-    ...
-    protected
-      exception_data :additional_data
-
-      def additional_data
-        { :document => @document,
-          :person => @person }
-      end
-    ...
-  end
-
-In the above case, @document and @person would be made available to the email
-renderer, allowing your new section(s) to access and display them. See the
-existing sections defined by the gem for examples of how to write your own.
-
-== Advanced Customization
-
-If you want to seriously modify the rules for the notification, you will need to implement your 
-own rescue_action_in_public method. You can look at the default implementation
-in ExceptionNotifiable for an example of how to go about that.
-
-== HTTP Error Codes Used by SEN by default
-
-  For reference these are the error codes that SEN can inherently handle, and they were gleaned from the following two websites.
-  Official w3.org HTTP 1.1 Error Codes:
-  http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
-  Not all the error codes in use today are on that list, so here's Apache's list:
-  http://www.askapache.com/htaccess/apache-status-code-headers-errordocument.html#apache-response-codes-57
-
-  400 Bad Request
-    * The request could not be understood by the server due to malformed syntax. 
-    * The client SHOULD NOT repeat the request without modifications.
-  403 Forbidden
-    * The server understood the request, but is refusing to fulfill it
-  404 Not Found
-    * The server has not found anything matching the Request-URI
-  405 Method Not Allowed
-    * The method specified in the Request-Line is not allowed for the resource identified by the Request-URI
-    * This is not implemented entirely as the response is supposed to contain a list of accepted methods.
-  410 Gone
-    * The requested resource is no longer available at the server and no forwarding address is known. This condition is expected to be considered permanent
-  418 I'm a teapot
-    * ErrorDocument I'm a teapot | Sample 418 I'm a teapot
-    * The HTCPCP server is a teapot. The responding entity MAY be short and stout. Defined by the April Fools specification RFC 2324. See Hyper Text Coffee Pot Control Protocol for more information.
-  422 Unprocessable Entity
-    * ErrorDocument Unprocessable Entity | Sample 422 Unprocessable Entity
-    * (WebDAV) (RFC 4918 ) - The request was well-formed but was unable to be followed due to semantic errors.
-  423 Locked
-    * ErrorDocument Locked | Sample 423 Locked
-    * (WebDAV) (RFC 4918 ) - The resource that is being accessed is locked
-  500 Internal Server Error
-    * The server encountered an unexpected condition which prevented it from fulfilling the request.
-  501 Not Implemented
-    * The server does not support the functionality required to fulfill the request.
-  503 Service Unavailable
-    * The server is currently unable to handle the request due to a temporary overloading or maintenance of the server.
-
-== CSS
-
-All the standard error pages that come in the gem render a div with a class of "dialog",
-so put this in a stylesheet you are including in your app to get you started (like standard rails error style):
-
-<style type="text/css">
-  div.dialog {
-    width: 25em;
-    padding: 0 4em;
-    margin: 4em auto 0 auto;
-    border: 1px solid #ccc;
-    border-right-color: #999;
-    border-bottom-color: #999;
-  }
-  h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
-</style>
-
-== Authors
-
-  Jamis Buck and Peter Boling
-
-== Contributors
-
-  I've merged many other people's forks into my fork.  Thanks to all of you who contributed good ideas that I have ripped off!
-
-  If I fail to mention you below, please let me know.
-
-  jamescook, ismasan, sentientmonkey
-    
-== jamescook changes
-
-Hooks into `git blame` output so you can get an idea of who (may) have introduced the bug :)
--- Usage: set ExceptionNotification::Notifier.config[:git_repo_path] to the path of your git repo.
-
-== ismasan changes
-
-POST exception data in JSON format to the specified services for processing
--- Usage:
-  ExceptionNotification::Notifier.configure_exception_notifier do |config|
-      config[:web_hooks]            = %w(http://some-hook-service.example.com http://another-hook-service.example.com) # defaults to []
-      config[:app_name]             = "[APP]" # defaults to [MYAPP]
-      config[:exception_recipients] = %w(my@example.com another@example.com) # defaults to []
-      config[:sender_address]       = %("Application Error" <app.error@myapp.com>) # defaults to super.exception.notifier@example.com
-  end
-
-== sentientmonkey changes
-
-Now you can get notifications from rake tasks!  Use 'NotifiedTask.new' instead of 'task':
--- Usage:
-  NotifiedTask.new :sometask => :environment do
-    puts "I'm a task"
-  end
-
-== Bugs
-
-  # NOTE: Some people (myself included) experience a bug in rails versions > 2.3.3
-  #   which forces us to use a simple email address string for the sender address.
-  #   https://rails.lighthouseapp.com/projects/8994/tickets/2340
-  config[:sender_address]           = "super.exception.notifier@example.com"
+4. That’s it! The defaults take care of the rest.
 
-== History
+http://wiki.github.com/pboling/exception_notification/exceptions-inside-request-cycle
 
-  The old, crusty , buggy, original verison of the plugin:
-  http://super-exception-notifier.googlecode.com
+== Advanced Configuration
 
-== Copyright
+There is a lot more you can configure, and do:
 
-  Copyright (c) 2008-9 Peter H. Boling, released under the MIT license
-  Portions Copyright (c) 2005 Jamis Buck, released under the MIT license
+http://wiki.github.com/pboling/exception_notification/

data/VERSION.yml

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

data/lib/exception_notification/deprecated_methods.rb

@@ -53,6 +53,6 @@ module ExceptionNotification::DeprecatedMethods
   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}"
+    logger.info("[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

@@ -112,48 +112,47 @@ module ExceptionNotification::ExceptionNotifiable
 
     #No Request present
     # 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_action_locally_with_sen_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)
-      #rescue_action_locally_without_sen_handler(exception)
-      #to_return
+    # Or when the error occurs 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 && respond_to?(:logger) && !logger.nil?
+        logger.info("[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
+        pass_it_on(exception, ENV)
+      end
+      to_return
     end
 
     # Overrides the rescue_action method in ActionController::Base, but does not inhibit
     # any custom processing that is defined with Rails 2's exception helpers.
     # 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:
+      # If the error class is NOT listed in the rails_error_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
+      verbose = self.class.exception_notifiable_verbose && respond_to?(:logger) && !logger.nil?
+      logger.info("[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
-      pass_it_on(exception, request)
+      pass_it_on(exception, ENV, request, params, session)
     end
 
     def notify_and_render_error_template(status_cd, request, exception, file_path, verbose = false)
@@ -183,19 +182,59 @@ module ExceptionNotification::ExceptionNotifiable
     # some integration with hoptoad or other exception handler
     # is done by tha alias method chain on:
     #    rescue_action_locally
-    def pass_it_on(exception, request = nil)
+    def pass_it_on(exception, env, request = {:params => {}}, params = {}, session = {})
       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
+            HoptoadNotifier.notify(exception, sen_hoptoad_request_data(env, request, params, session))
+            logger.info("[PASS-IT-ON] HOPTOAD NOTIFIED") if verbose
           else
-            puts "[PASS-IT-ON] NO" if verbose
-            #nothing
+            logger.info("[PASS-IT-ON] NO") if verbose
+            #Do Nothing
         end
       rescue
-        #nothing
+        #Do Nothing
+        logger.info("[PASS-IT-ON] FAILED") if verbose
+      end
+    end
+
+    def sen_hoptoad_request_data(env, request, params, session)
+      { :parameters       => sen_hoptoad_filter_if_filtering(params.to_hash),
+        :session_data     => sen_hoptoad_session_data(session),
+        :controller       => params[:controller],
+        :action           => params[:action],
+        :url              => sen_hoptoad_request_url(request),
+        :cgi_data         => request.respond_to?(:env) ? sen_hoptoad_filter_if_filtering(request.env) : nil,
+        :environment_vars => sen_hoptoad_filter_if_filtering(env),
+        :request          => request }
+    end
+
+    def sen_hoptoad_filter_if_filtering(hash)
+      if respond_to?(:filter_parameters)
+        filter_parameters(hash) rescue hash
+      else
+        hash
+      end
+    end
+
+    def sen_hoptoad_session_data(session)
+      if session.respond_to?(:to_hash)
+        session.to_hash
+      elsif session.respond_to?(:data)
+        session.data
+      end
+    end
+
+    def sen_hoptoad_request_url(request)
+      if request.respond_to?(:protocol)
+        url = "#{request.protocol}#{request.host}"
+
+        unless [80, 443].include?(request.port)
+          url << ":#{request.port}"
+        end
+
+        url << request.request_uri
+        url
       end
     end
 

data/lib/exception_notification/notifiable.rb

@@ -67,8 +67,8 @@ module ExceptionNotification::Notifiable
   end
 
   def rescue_with_hooks(exception)
-    verbose = self.class.notifiable_verbose
-    puts "[RESCUE STYLE] rescue_with_hooks" if verbose
+    verbose = self.class.notifiable_verbose && respond_to?(:logger) && !logger.nil?
+    logger.info("[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,
@@ -98,13 +98,14 @@ module ExceptionNotification::Notifiable
       case self.class.notifiable_pass_through
         when :hoptoad then
           HoptoadNotifier.notify(exception, {:request => request})
-          puts "[PASS-IT-ON] HOPTOAD NOTIFIED" if verbose
+          logger.info("[PASS-IT-ON] HOPTOAD NOTIFIED") if verbose
         else
-          puts "[PASS-IT-ON] NO" if verbose
-          #nothing
+          logger.info("[PASS-IT-ON] NO") if verbose
+          #Do Nothing
       end
     rescue
-      #nothing
+      #Do Nothing
+      logger.info("[PASS-IT-ON] FAILED") if verbose
     end
   end
 

data/lib/exception_notification/notifiable_helper.rb

@@ -27,29 +27,29 @@ module ExceptionNotification::NotifiableHelper
   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?
+    logger.info("[EXCEPTION] #{exception}")
+    logger.info("[EXCEPTION CLASS] #{exception.class}")
+    logger.info("[EXCEPTION STATUS_CD] #{status_cd}")
+    logger.info("[ERROR LAYOUT] #{self.class.error_layout}") if self.class.respond_to?(:error_layout)
+    logger.info("[ERROR VIEW PATH] #{ExceptionNotification::Notifier.config[:view_path]}") if !ExceptionNotification::Notifier.nil? && !ExceptionNotification::Notifier.config[:view_path].nil?
+    logger.info("[ERROR FILE PATH] #{file_path.inspect}")
+    logger.info("[ERROR EMAIL] #{send_email ? "YES" : "NO"}")
+    logger.info("[ERROR WEB HOOKS] #{send_web_hooks ? "YES" : "NO"}")
+    logger.info("[THE BLAMED] #{the_blamed}") unless the_blamed.blank?
+    logger.info("[SECTIONS] #{ExceptionNotification::Notifier.sections_for_email(rejected_sections, request).inspect}")
+    req = request ? " for request_uri=#{request.request_uri}" : ""
+    logger.error("render_error(#{status_cd}, #{self.class.http_status_codes[status_cd]}) invoked#{req}") if self.class.respond_to?(:http_status_codes)
   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
+      logger.info("[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
+      logger.info("[EMAIL NOTIFICATION] Sent") if verbose
     end
   end
 
@@ -65,8 +65,8 @@ module ExceptionNotification::NotifiableHelper
   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
+      logger.info("[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)

data/lib/exception_notification/notifier.rb

@@ -87,26 +87,26 @@ class ExceptionNotification::Notifier < ActionMailer::Base
   end
 
   def self.catch_all(verbose = false)
-    puts "[CATCH ALL INVOKED] #{File.dirname(__FILE__)}/../../rails/app/views/exception_notifiable/500.html" if verbose
+    logger.info("[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
+      logger.info("[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
+      logger.info("[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
+      logger.info("[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
+      logger.info("[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
+      logger.info("[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

data/lib/views/exception_notification/notifier/_backtrace.html.erb

@@ -0,0 +1 @@
+<%= @backtrace.join "\n" %>

data/lib/views/exception_notification/notifier/_environment.html.erb

@@ -0,0 +1,14 @@
+<% if @request -%>
+<% max = @request.env.keys.max { |a,b| a.length <=> b.length } -%>
+<% @request.env.keys.sort.each do |key| -%>
+* <%= "%-*s: %s" % [max.length, key, filter_sensitive_post_data_from_env(key, @request.env[key].to_s.strip)] %>
+<% end -%>
+<% end -%>
+<% if @data -%>
+<% @data.each do |key, value| -%>
+* <%= key %>: <%= value %>
+<% end -%>
+<% end -%>
+
+* Process: <%= $$ %>
+* Server : <%= `hostname -s`.chomp %>

data/lib/views/exception_notification/notifier/_inspect_model.html.erb

@@ -0,0 +1,16 @@
+<% if show_attributes -%>
+[attributes]
+<% attrs = inspect_model.attributes -%>
+<% max = attrs.keys.max { |a,b| a.length <=> b.length } -%>
+<% attrs.keys.sort.each do |attr| -%>
+* <%= "%*-s: %s" % [max.length, attr, object_to_yaml(attrs[attr]).gsub(/\n/, "\n  ").strip] %>
+<% end -%>
+<% end -%>
+
+<% if show_instance_variables -%>
+[instance variables]
+<% inspect_model.instance_variables.sort.each do |variable| -%>
+<%- next if variable == "@attributes" -%>
+* <%= variable %>: <%= inspect_value(inspect_model.instance_variable_get(variable)) %>
+<% end -%>
+<% end -%>

data/lib/views/exception_notification/notifier/_request.html.erb

@@ -0,0 +1,8 @@
+<% if @request -%>
+* URL       : <%= @request.protocol %><%= @host %><%= @request.request_uri %>
+* Method    : <%= @request.method.to_s.upcase %>
+* IP address: <%= @request.env['HTTP_X_REAL_IP'] ||@request.env["HTTP_X_FORWARDED_FOR"] || @request.env["REMOTE_ADDR"] %>
+* Parameters: <%= filter_sensitive_post_data_parameters(@request.parameters).inspect %>
+<% end -%>
+* Rails root: <%= @rails_root %>
+

data/lib/views/exception_notification/notifier/_session.html.erb

@@ -0,0 +1,6 @@
+<%
+  @request.session.instance_variable_set(:@session_id, @request.session_options[:id]) if @request.session.instance_variable_get(:@session_id).nil?
+  @request.session.instance_variable_set(:@data, @request.session.to_hash) if @request.session.instance_variable_get(:@data).nil?
+%>
+* session id: <%= @request.session.instance_variable_get(:@session_id).inspect %>
+* data: <%= PP.pp(@request.session.instance_variable_get(:@data),"").gsub(/\n/, "\n  ").strip %>

data/lib/views/exception_notification/notifier/_title.html.erb

@@ -0,0 +1,3 @@
+-------------------------------
+<%= title.to_s.humanize %>:
+-------------------------------

data/lib/views/exception_notification/notifier/background_exception_notification.text.plain.erb

@@ -0,0 +1,10 @@
+A <%= @exception.class %> occurred in <%= @controller_name %>#<%= @controller_action_name %>:
+
+  <%= @exception.message %>
+  <%= @backtrace.first %>
+
+<% if @data[:info] -%>
+  <%=@data[:info].to_yaml%>
+<% end -%>
+
+<%= @sections.map { |section| render_section(section) }.join %>

data/lib/views/exception_notification/notifier/rake_exception_notification.text.plain.erb

@@ -0,0 +1,6 @@
+A <%= @exception.class %> occurred in <%= @location %>:
+
+  <%= @exception.message %>
+  <%= @backtrace.first %>
+
+<%= @sections.map { |section| render_section(section) }.join %>

data/super_exception_notifier.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{super_exception_notifier}
-  s.version = "3.0.6"
+  s.version = "3.0.7"
 
   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-05-14}
+  s.date = %q{2010-06-12}
   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
@@ -34,7 +34,8 @@ Gem::Specification.new do |s|
     "README"
   ]
   s.files = [
-    "MIT-LICENSE",
+    "CHANGELOG.txt",
+     "MIT-LICENSE",
      "README",
      "VERSION.yml",
      "init.rb",
@@ -52,6 +53,14 @@ Gem::Specification.new do |s|
      "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/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",
@@ -70,7 +79,7 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/pboling/exception_notifiable}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.6}
+  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",
@@ -86,7 +95,7 @@ Gem::Specification.new do |s|
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    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

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: super_exception_notifier
 version: !ruby/object:Gem::Version 
+  hash: 9
   prerelease: false
   segments: 
   - 3
   - 0
-  - 6
-  version: 3.0.6
+  - 7
+  version: 3.0.7
 platform: ruby
 authors: 
 - Peter Boling
@@ -18,16 +19,18 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-14 00:00:00 -04:00
+date: 2010-06-12 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: actionmailer
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
@@ -37,9 +40,11 @@ dependencies:
   name: rake
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
@@ -73,6 +78,7 @@ extensions: []
 extra_rdoc_files: 
 - README
 files: 
+- CHANGELOG.txt
 - MIT-LICENSE
 - README
 - VERSION.yml
@@ -91,6 +97,14 @@ files:
 - 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/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
@@ -105,6 +119,13 @@ files:
 - rails/app/views/exception_notifiable/method_disabled.html.erb
 - rails/init.rb
 - super_exception_notifier.gemspec
+- 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
 has_rdoc: true
 homepage: http://github.com/pboling/exception_notifiable
 licenses: []
@@ -115,23 +136,27 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Allows unhandled (and handled!) exceptions to be captured and sent via email