super_exception_notifier 2.0.8 → 3.0.1

data/test/test_helper.rb

@@ -1,8 +1,9 @@
 require 'test/unit'
 require 'rubygems'
 
-require 'active_support'
-require 'actionmailer'
+require 'rake'
+require 'rake/tasklib'
+require 'action_mailer'
 require 'active_record'
 
 #just requiring active record wasn't loading classes soon enough for SILENT_EXCEPTIONS
@@ -20,9 +21,10 @@ RAILS_ENV = 'test' unless defined?(RAILS_ENV)
 RAILS_DEFAULT_LOGGER = Logger.new(StringIO.new) unless defined?(RAILS_DEFAULT_LOGGER)
 #$:.unshift File.join(File.dirname(__FILE__), '../lib')
 
-require File.join(File.dirname(__FILE__), "..", "init")
+#require File.join(File.dirname(__FILE__), "..", "init")
+require "init"
 
-ExceptionNotifier.configure_exception_notifier do |config|
+ExceptionNotification::Notifier.configure_exception_notifier do |config|
   # If left empty web hooks will not be engaged
   config[:web_hooks]                = []
   config[:exception_recipients]     = ["test.errors@example.com"]

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: super_exception_notifier
 version: !ruby/object:Gem::Version 
-  version: 2.0.8
+  prerelease: false
+  segments: 
+  - 3
+  - 0
+  - 1
+  version: 3.0.1
 platform: ruby
 authors: 
 - Peter Boling
@@ -13,19 +18,33 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-28 00:00:00 -05:00
+date: 2010-05-13 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: actionmailer
+  name: action_mailer
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
   type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :runtime
+  version_requirements: *id002
 description: |-
   Allows customization of:
   * Specify which level of notification you would like with an array of optional styles of notification (email, webhooks)
@@ -52,23 +71,13 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- README.rdoc
+- README
 files: 
 - MIT-LICENSE
-- README.rdoc
+- README
 - VERSION.yml
 - init.rb
-- lib/exception_notifiable.rb
-- lib/exception_notifier.rb
-- lib/exception_notifier_helper.rb
-- lib/notifiable.rb
-- lib/super_exception_notifier/custom_exception_classes.rb
-- lib/super_exception_notifier/custom_exception_methods.rb
-- lib/super_exception_notifier/deprecated_methods.rb
-- lib/super_exception_notifier/git_blame.rb
-- lib/super_exception_notifier/helpful_hashes.rb
-- lib/super_exception_notifier/hooks_notifier.rb
-- lib/super_exception_notifier/notifiable_helper.rb
+- lib/exception_notification.rb
 - rails/app/views/exception_notifiable/400.html
 - rails/app/views/exception_notifiable/403.html
 - rails/app/views/exception_notifiable/404.html
@@ -82,18 +91,9 @@ files:
 - rails/app/views/exception_notifiable/503.html
 - rails/app/views/exception_notifiable/method_disabled.html.erb
 - rails/init.rb
-- tasks/notified_task.rake
-- views/exception_notifier/_backtrace.html.erb
-- views/exception_notifier/_environment.html.erb
-- views/exception_notifier/_inspect_model.html.erb
-- views/exception_notifier/_request.html.erb
-- views/exception_notifier/_session.html.erb
-- views/exception_notifier/_title.html.erb
-- views/exception_notifier/background_exception_notification.text.plain.erb
-- views/exception_notifier/exception_notification.text.plain.erb
-- views/exception_notifier/rake_exception_notification.text.plain.erb
+- super_exception_notifier.gemspec
 has_rdoc: true
-homepage: http://github.com/pboling/exception_notification
+homepage: http://github.com/pboling/exception_notifiable
 licenses: []
 
 post_install_message: 
@@ -105,18 +105,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Allows unhandled (and handled!) exceptions to be captured and sent via email

data/lib/exception_notifiable.rb

@@ -1,177 +0,0 @@
-require 'ipaddr'
-
-module ExceptionNotifiable
-  include SuperExceptionNotifier::NotifiableHelper
-
-  def self.included(base)
-    base.extend ClassMethods
-
-    # Adds the following class attributes to the classes that include ExceptionNotifiable
-    #  HTTP status codes and what their 'English' status message is
-    base.cattr_accessor :http_status_codes
-    base.http_status_codes = HTTP_STATUS_CODES
-    # error_layout:
-    #   can be defined at controller level to the name of the desired error layout,
-    #   or set to true to render the controller's own default layout,
-    #   or set to false to render errors with no layout
-    base.cattr_accessor :error_layout
-    base.error_layout = nil
-    # Rails error classes to rescue and how to rescue them (which error code to use)
-    base.cattr_accessor :error_class_status_codes
-    base.error_class_status_codes = self.codes_for_error_classes
-    # Verbosity of the gem
-    base.cattr_accessor :exception_notifiable_verbose
-    base.exception_notifiable_verbose = false
-    # Do Not Ever send error notification emails for these Error Classes
-    base.cattr_accessor :exception_notifiable_silent_exceptions
-    base.exception_notifiable_silent_exceptions = SILENT_EXCEPTIONS
-    # Notification Level
-    base.cattr_accessor :exception_notifiable_notification_level
-    base.exception_notifiable_notification_level = [:render, :email, :web_hooks]
-  end
-  
-  module ClassMethods
-    include SuperExceptionNotifier::DeprecatedMethods
-
-    # specifies ip addresses that should be handled as though local
-    def consider_local(*args)
-      local_addresses.concat(args.flatten.map { |a| IPAddr.new(a) })
-    end
-
-    def local_addresses
-      addresses = read_inheritable_attribute(:local_addresses)
-      unless addresses
-        addresses = [IPAddr.new("127.0.0.1")]
-        write_inheritable_attribute(:local_addresses, addresses)
-      end
-      addresses
-    end
-
-    # set the exception_data deliverer OR retrieve the exception_data
-    def exception_data(deliverer = nil)
-      if deliverer
-        write_inheritable_attribute(:exception_data, deliverer)
-      else
-        read_inheritable_attribute(:exception_data)
-      end
-    end
-
-    def be_silent_for_exception?(exception)
-      self.exception_notifiable_silent_exceptions.respond_to?(:any?) && self.exception_notifiable_silent_exceptions.any? {|klass| klass === exception }
-    end
-
-  end
-
-  def be_silent_for_exception?(exception)
-    self.class.be_silent_for_exception?(exception)
-  end
-
-
-  private
-
-    def notification_level_sends_email?
-      self.class.exception_notifiable_notification_level.include?(:email)
-    end
-
-    def notification_level_sends_web_hooks?
-      self.class.exception_notifiable_notification_level.include?(:web_hooks)
-    end
-
-    def notification_level_renders?
-      self.class.exception_notifiable_notification_level.include?(:render)
-    end
-
-    # overrides Rails' local_request? method to also check any ip
-    # addresses specified through consider_local.
-    def local_request?
-      remote = IPAddr.new(request.remote_ip)
-      !self.class.local_addresses.detect { |addr| addr.include?(remote) }.nil?
-    end
-
-    # When the action being executed has its own local error handling (rescue)
-    # Or when the error accurs somewhere without a subsequent render (eg. method calls in console)
-    def rescue_with_handler(exception)
-      to_return = super
-      if to_return
-        verbose = self.class.exception_notifiable_verbose
-        puts "[RESCUE STYLE] rescue_with_handler" if verbose
-        data = get_exception_data
-        status_code = status_code_for_exception(exception)
-        #We only send email if it has been configured in environment
-        send_email = should_email_on_exception?(exception, status_code, verbose)
-        #We only send web hooks if they've been configured in environment
-        send_web_hooks = should_web_hook_on_exception?(exception, status_code, verbose)
-        the_blamed = ExceptionNotifier.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
-        HooksNotifier.deliver_exception_to_web_hooks(ExceptionNotifier.config, exception, self, request, data, the_blamed) if send_web_hooks
-      end
-      to_return
-    end
-
-    # When the action being executed is letting SEN handle the exception completely
-    def rescue_action_in_public(exception)
-      # If the error class is NOT listed in the rails_errror_class hash then we get a generic 500 error:
-      # OTW if the error class is listed, but has a blank code or the code is == '200' then we get a custom error layout rendered
-      # OTW the error class is listed!
-      verbose = self.class.exception_notifiable_verbose
-      puts "[RESCUE STYLE] rescue_action_in_public" if verbose
-      status_code = status_code_for_exception(exception)
-      if status_code == '200'
-        notify_and_render_error_template(status_code, request, exception, 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, verbose), verbose)
-      end
-    end
-
-    def notify_and_render_error_template(status_cd, request, exception, file_path, verbose = false)
-      status = self.class.http_status_codes[status_cd] ? status_cd + " " + self.class.http_status_codes[status_cd] : status_cd
-      data = get_exception_data
-      #We only send email if it has been configured in environment
-      send_email = should_email_on_exception?(exception, status_cd, verbose)
-      #We only send web hooks if they've been configured in environment
-      send_web_hooks = should_web_hook_on_exception?(exception, status_cd, verbose)
-      the_blamed = ExceptionNotifier.config[:git_repo_path].nil? ? nil : lay_blame(exception)
-      rejected_sections = request.nil? ? %w(request session) : []
-      # Debugging output
-      verbose_output(exception, status_cd, file_path, send_email, send_web_hooks, request, the_blamed, rejected_sections) if verbose
-      #TODO: is _rescue_action something from rails 3?
-      #if !(self.controller_name == 'application' && self.action_name == '_rescue_action')
-      # Send the exception notification email
-      perform_exception_notify_mailing(exception, data, request, the_blamed, verbose, rejected_sections) if send_email
-      # Send Web Hook requests
-      HooksNotifier.deliver_exception_to_web_hooks(ExceptionNotifier.config, exception, self, request, data, the_blamed) if send_web_hooks
-
-      # We put the render call after the deliver call to ensure that, if the
-      # deliver raises an exception, we don't call render twice.
-      # Render the error page to the end user
-      render_error_template(file_path, status)
-    end
-
-    def is_local?
-      (consider_all_requests_local || local_request?)
-    end
-
-    def status_code_for_exception(exception)
-      self.class.error_class_status_codes[exception.class].nil? ? 
-              '500' :
-              self.class.error_class_status_codes[exception.class].blank? ?
-                      '200' :
-                      self.class.error_class_status_codes[exception.class]
-    end
-
-    def render_error_template(file, status)
-      respond_to do |type|
-        type.html { render :file => file,
-                            :layout => self.class.error_layout,
-                            :status => status }
-        type.all  { render :nothing => true,
-                            :status => status}
-      end
-    end
-
-end

data/lib/exception_notifier.rb

@@ -1,176 +0,0 @@
-require 'pathname'
-
-class ExceptionNotifier < ActionMailer::Base
-
-  #andrewroth reported that @@config gets clobbered because rails loads this class twice when installed as a plugin, and adding the ||= fixed it.
-  @@config ||= {
-    # If left empty web hooks will not be engaged
-    :web_hooks                => [],
-    :app_name                 => "[MYAPP]",
-    :version                  => "0.0.0",
-    :sender_address           => "super.exception.notifier@example.com",
-    :exception_recipients     => [],
-    # Customize the subject line
-    :subject_prepend          => "[#{(defined?(Rails) ? Rails.env : RAILS_ENV).capitalize} ERROR] ",
-    :subject_append           => nil,
-    # Include which sections of the exception email? 
-    :sections                 => %w(request session environment backtrace),
-    :skip_local_notification  => true,
-    :view_path                => nil,
-    #Error Notification will be sent if the HTTP response code for the error matches one of the following error codes
-    :notify_error_codes   => %W( 405 500 503 ),
-    #Error Notification will be sent if the error class matches one of the following error error classes
-    :notify_error_classes => %W( ),
-    :notify_other_errors  => true,
-    :git_repo_path            => nil,
-    :template_root            => "#{File.dirname(__FILE__)}/../views"
-  }
-
-  cattr_accessor :config
-
-  def self.configure_exception_notifier(&block)
-    yield @@config
-  end
-  
-  self.template_root = config[:template_root]
-
-  def self.reloadable?() false end
-
-  # Returns an array of potential filenames to look for
-  # eg. For the Exception Class - SuperExceptionNotifier::CustomExceptionClasses::MethodDisabled
-  # the filename handles are:
-  #   super_exception_notifier_custom_exception_classes_method_disabled
-  #   method_disabled
-  def self.exception_to_filenames(exception)
-    filenames = []
-    e = exception.to_s
-    filenames << ExceptionNotifier.filenamify(e)
-
-    last_colon = e.rindex(':')
-    unless last_colon.nil?
-      filenames << ExceptionNotifier.filenamify(e[(last_colon + 1)..(e.length - 1)])
-    end
-    filenames
-  end
-
-  def self.sections_for_email(rejected_sections, request)
-    rejected_sections = rejected_sections.nil? ? request.nil? ? %w(request session) : [] : rejected_sections
-    rejected_sections.empty? ? config[:sections] : config[:sections].reject{|s| rejected_sections.include?(s) }
-  end
-
-  # Converts Stringified Class Names to acceptable filename handles with underscores
-  def self.filenamify(str)
-    str.delete(':').gsub( /([A-Za-z])([A-Z])/, '\1' << '_' << '\2').downcase
-  end
-
-  # What is the path of the file we will render to the user based on a given status code?
-  def self.get_view_path_for_status_code(status_cd, verbose = false)
-    file_name = ExceptionNotifier.get_view_path(status_cd, verbose)
-    #ExceptionNotifierHelper::COMPAT_MODE ? "#{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/500.html" : "500.html"
-    file_name.nil? ? self.catch_all(verbose) : file_name
-  end
-
-#  def self.get_view_path_for_files(filenames = [])
-#    filepaths = filenames.map do |file|
-#      ExceptionNotifier.get_view_path(file)
-#    end.compact
-#    filepaths.empty? ? "#{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/500.html" : filepaths.first
-#  end
-
-  # What is the path of the file we will render to the user based on a given exception class?
-  def self.get_view_path_for_class(exception, verbose = false)
-    return self.catch_all(verbose) if exception.nil?
-    #return self.catch_all(verbose) unless exception.is_a?(StandardError) || exception.is_a?(Class) # For some reason exception.is_a?(Class) works in console, but not when running in mongrel (ALWAYS returns false)?!?!?
-    filepaths = ExceptionNotifier.exception_to_filenames(exception).map do |file|
-      ExceptionNotifier.get_view_path(file, verbose)
-    end.compact
-    filepaths.empty? ? self.catch_all(verbose) : filepaths.first
-  end
-
-  def self.catch_all(verbose = false)
-    puts "[CATCH ALL INVOKED] #{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/500.html" if verbose
-    "#{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/500.html"
-  end
-
-  # Check the usual suspects
-  def self.get_view_path(file_name, verbose = false)
-    if File.exist?("#{RAILS_ROOT}/public/#{file_name}.html")
-      puts "[FOUND FILE:A] #{RAILS_ROOT}/public/#{file_name}.html" if verbose
-      "#{RAILS_ROOT}/public/#{file_name}.html"
-    elsif !config[:view_path].nil? && File.exist?("#{RAILS_ROOT}/#{config[:view_path]}/#{file_name}.html.erb")
-      puts "[FOUND FILE:B] #{RAILS_ROOT}/#{config[:view_path]}/#{file_name}.html.erb" if verbose
-      "#{RAILS_ROOT}/#{config[:view_path]}/#{file_name}.html.erb"
-    elsif !config[:view_path].nil? && File.exist?("#{RAILS_ROOT}/#{config[:view_path]}/#{file_name}.html")
-      puts "[FOUND FILE:C] #{RAILS_ROOT}/#{config[:view_path]}/#{file_name}.html" if verbose
-      "#{RAILS_ROOT}/#{config[:view_path]}/#{file_name}.html"
-    elsif File.exist?("#{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/#{file_name}.html.erb")
-      puts "[FOUND FILE:D] #{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/#{file_name}.html.erb" if verbose
-      "#{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/#{file_name}.html.erb"
-    elsif File.exist?("#{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/#{file_name}.html")
-      #ExceptionNotifierHelper::COMPAT_MODE ? "#{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/#{file_name}.html" : "#{status_cd}.html"
-      puts "[FOUND FILE:E] #{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/#{file_name}.html" if verbose
-      "#{File.dirname(__FILE__)}/../rails/app/views/exception_notifiable/#{file_name}.html"
-    else
-      nil
-    end
-  end
-
-  def exception_notification(exception, class_name = nil, method_name = nil, request = nil, data = {}, the_blamed = nil, rejected_sections = nil)
-    body_hash = error_environment_data_hash(exception, class_name, method_name, request, data, the_blamed, rejected_sections)
-    #Prefer to have custom, potentially HTML email templates available
-    #content_type  "text/plain"
-    recipients    config[:exception_recipients]
-    from          config[:sender_address]
-
-    request.session.inspect unless request.nil? # Ensure session data is loaded (Rails 2.3 lazy-loading)
-    
-    subject       "#{config[:subject_prepend]}#{body_hash[:location]} (#{exception.class}) #{exception.message.inspect}#{config[:subject_append]}"
-    body          body_hash
-  end
-  
-  def background_exception_notification(exception, data = {}, the_blamed = nil, rejected_sections = %w(request session))
-    exception_notification(exception, nil, nil, nil, data, the_blamed, rejected_sections)
-  end
-
-  def rake_exception_notification(exception, task, data={}, the_blamed = nil, rejected_sections = %w(request session))
-    exception_notification(exception, "", "#{task.name}", nil, data, the_blamed, rejected_sections)
-  end
-
-  private
-
-    def error_environment_data_hash(exception, class_name = nil, method_name = nil, request = nil, data = {}, the_blamed = nil, rejected_sections = nil)
-      data.merge!({
-        :exception => exception,
-        :backtrace => sanitize_backtrace(exception.backtrace),
-        :rails_root => rails_root,
-        :data => data,
-        :the_blamed => the_blamed
-      })
-
-      data.merge!({:class_name => class_name}) if class_name
-      data.merge!({:method_name => method_name}) if method_name
-      if class_name && method_name
-        data.merge!({:location => "#{class_name}##{method_name}"})
-      elsif method_name
-        data.merge!({:location => "#{method_name}"})
-      else
-        data.merge!({:location => sanitize_backtrace([exception.backtrace.first]).first})
-      end
-      if request
-        data.merge!({:request => request})
-        data.merge!({:host => (request.env['HTTP_X_REAL_IP'] || request.env["HTTP_X_FORWARDED_HOST"] || request.env["HTTP_HOST"])})
-      end
-      data.merge!({:sections => ExceptionNotifier.sections_for_email(rejected_sections, request)})
-      return data
-    end
-
-    def sanitize_backtrace(trace)
-      re = Regexp.new(/^#{Regexp.escape(rails_root)}/)
-      trace.map { |line| Pathname.new(line.gsub(re, "[RAILS_ROOT]")).cleanpath.to_s }
-    end
-
-    def rails_root
-      @rails_root ||= Pathname.new(RAILS_ROOT).cleanpath.to_s
-    end
-
-end