super_exception_notifier 2.0.8 → 3.0.1

data/lib/exception_notifier_helper.rb

@@ -1,60 +0,0 @@
-require 'pp'
-
-module ExceptionNotifierHelper
-  VIEW_PATH = "views/exception_notifier" unless defined?(VIEW_PATH)
-  APP_PATH = "#{RAILS_ROOT}/app/#{VIEW_PATH}" unless defined?(APP_PATH)
-  PARAM_FILTER_REPLACEMENT = "[FILTERED]" unless defined?(PARAM_FILTER_REPLACEMENT)
-  COMPAT_MODE = defined?(RAILS_GEM_VERSION) ? RAILS_GEM_VERSION < '2' : false unless defined?(COMPAT_MODE)
-
-  def render_section(section)
-    RAILS_DEFAULT_LOGGER.info("rendering section #{section.inspect}")
-    summary = render_overridable(section).strip
-    unless summary.blank?
-      title = render_overridable(:title, :locals => { :title => section }).strip
-      "#{title}\n\n#{summary.gsub(/^/, "  ")}\n\n"
-    end
-  end
-
-  def render_overridable(partial, options={})
-    if File.exist?(path = "#{APP_PATH}/_#{partial}.html.erb") ||
-        File.exist?(path = "#{File.dirname(__FILE__)}/../#{VIEW_PATH}/_#{partial}.html.erb") ||
-        File.exist?(path = "#{APP_PATH}/_#{partial}.rhtml") ||
-        File.exist?(path = "#{APP_PATH}/_#{partial}.erb")
-      render(options.merge(:file => path, :use_full_path => false))
-    else
-      ""
-    end
-  end
-
-  def inspect_model_object(model, locals={})
-    render_overridable(:inspect_model,
-      :locals => { :inspect_model => model,
-                   :show_instance_variables => true,
-                   :show_attributes => true }.merge(locals))
-  end
-
-  def inspect_value(value)
-    len = 512
-    result = object_to_yaml(value).gsub(/\n/, "\n  ").strip
-    result = result[0,len] + "... (#{result.length-len} bytes more)" if result.length > len+20
-    result
-  end
-
-  def object_to_yaml(object)
-    object.to_yaml.sub(/^---\s*/m, "")
-  end
-
-  def exclude_raw_post_parameters?
-    @controller && @controller.respond_to?(:filter_parameters)
-  end
-
-  def filter_sensitive_post_data_parameters(parameters)
-    exclude_raw_post_parameters? ? COMPAT_MODE ? @controller.filter_parameters(parameters) : @controller.__send__(:filter_parameters, parameters) : parameters
-  end
-
-  def filter_sensitive_post_data_from_env(env_key, env_value)
-    return env_value unless exclude_raw_post_parameters?
-    return PARAM_FILTER_REPLACEMENT if (env_key =~ /RAW_POST_DATA/i)
-    return COMPAT_MODE ? @controller.filter_parameters({env_key => env_value}).values[0] : @controller.__send__(:filter_parameters, {env_key => env_value}).values[0]
-  end
-end

data/lib/notifiable.rb

@@ -1,92 +0,0 @@
-module Notifiable
-  include SuperExceptionNotifier::NotifiableHelper
-  
-  def self.included(base)
-    base.extend ClassMethods
-
-    # Verbosity of the gem
-    base.cattr_accessor :notifiable_verbose
-    base.notifiable_verbose = false
-    # Do Not Ever send error notification emails for these Error Classes
-    base.cattr_accessor :notifiable_silent_exceptions
-    base.notifiable_silent_exceptions = SILENT_EXCEPTIONS
-    # Notification Level
-    base.cattr_accessor :notifiable_notification_level
-    base.notifiable_notification_level = [:email, :web_hooks]
-
-    # Since there is no concept of locality from a request here allow user to explicitly define which env's are noisy (send notifications)
-    base.cattr_accessor :notifiable_noisy_environments
-    base.notifiable_noisy_environments = [:production]
-  end
-
-  module ClassMethods
-    # 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.notifiable_silent_exceptions.respond_to?(:any?) && self.notifiable_silent_exceptions.any? {|klass| klass === exception }
-    end
-
-  end
-
-  # Usage:
-  #   notifiable { Klass.some_method }
-  # This will rescue any errors that occur within Klass.some_method
-  def notifiable(&block)
-    yield
-  rescue => exception
-    rescue_with_hooks(exception)
-    raise
-  end
-
-  def be_silent_for_exception?(exception)
-    self.class.be_silent_for_exception?(exception)
-  end
-
-  private
-
-  def notification_level_sends_email?
-    self.class.notifiable_notification_level.include?(:email)
-  end
-
-  def notification_level_sends_web_hooks?
-    self.class.notifiable_notification_level.include?(:web_hooks)
-  end
-  
-  def rescue_with_hooks(exception)
-    verbose = self.class.notifiable_verbose
-    puts "[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,
-    #   the errors you want to be notified of need to be specified either positively or negatively
-    # 1. positive eg. set ExceptionNotifier.config[:notify_error_classes] to an array of classes
-    #               set ExceptionNotifier.config[:notify_other_errors] to false
-    # 1. negative eg. set Klass.silent_exceptions to the ones to keep quiet
-    #               set ExceptionNotifier.config[:notify_other_errors] to true
-    status_code = nil
-    #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)
-    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
-
-  def is_local? #like asking is_silent?
-    eenv = defined?(Rails) ? Rails.env : RAILS_ENV
-    !self.notifiable_noisy_environments.include?(eenv)
-  end
-
-end

data/lib/super_exception_notifier/custom_exception_classes.rb

@@ -1,16 +0,0 @@
-#Copyright (c) 2008-2009 Peter H. Boling of 9thBit LLC
-#Released under the MIT license
-
-module SuperExceptionNotifier
-  module CustomExceptionClasses
-
-    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
-    
-  end
-end

data/lib/super_exception_notifier/custom_exception_methods.rb

@@ -1,50 +0,0 @@
-#Copyright (c) 2008-2009 Peter H. Boling of 9thBit LLC
-#Released under the MIT license
-
-module SuperExceptionNotifier
-  module CustomExceptionMethods
-
-    protected
-    
-    #For a while after disabling a route/URL that had been functional we should set it to resource gone to inform people to remove bookmarks.
-    def resource_gone
-      raise ResourceGone
-    end
-    #Then for things that have never existed or have not for a long time we call not_implemented
-    def not_implemented
-      raise NotImplemented
-    end
-    #Resources that must be requested with a specific HTTP Method (GET, PUT, POST, DELETE, AJAX, etc) but are requested otherwise should:
-    def invalid_method
-      raise InvalidMethod
-    end
-    #If your ever at a spot in the code that should never get reached, but corrupt data might get you there anyways then this is for you:
-    def corrupt_data
-      raise CorruptData
-    end
-    def page_not_found
-      raise PageNotFound
-    end
-    def record_not_found
-      raise ActiveRecord::RecordNotFound
-    end
-    def method_disabled
-      raise MethodDisabled
-    end
-    #The current user does not have enough privileges to access the requested resource
-    def access_denied
-      raise AccessDenied
-    end
-
-    def generic_error
-      error_stickie("Sorry, an error has occurred.")
-      corrupt_data
-    end
-
-    def invalid_page
-      error_stickie("Sorry, the page number you requested was not valid.")
-      page_not_found
-    end
-
-  end
-end

data/lib/super_exception_notifier/deprecated_methods.rb

@@ -1,60 +0,0 @@
-#Copyright (c) 2008-2009 Peter H. Boling of 9thBit LLC
-#Released under the MIT license
-
-module SuperExceptionNotifier
-  module DeprecatedMethods
-    @@namespacing = "Better namespacing to allow for Notifiable and ExceptionNotifiable to have similar APIs"
-    @@rails2ruby = "An effort to make this a 'Ruby' Gem and not a strictly 'Rails' Gem"
-    
-    def http_error_codes
-      deprecation_warning("http_error_codes", "error_class_status_codes")
-      error_class_status_codes
-    end
-
-    def http_error_codes=(arg)
-      deprecation_warning("http_error_codes", "error_class_status_codes")
-      error_class_status_codes=(arg)
-    end
-
-    def rails_error_codes
-      deprecation_warning("rails_error_codes", "error_class_status_codes", @@rails2ruby)
-      error_class_status_codes
-    end
-
-    def rails_error_codes=(arg)
-      deprecation_warning("rails_error_codes=", "error_class_status_codes=", @@rails2ruby)
-      error_class_status_codes=(arg)
-    end
-
-    # Now defined in Object class by init.rb & Notifiable module,
-    #   so we need to override them for with the controller settings
-    def exception_notifier_verbose
-      deprecation_warning("exception_notifier_verbose", "exception_notifiable_verbose", @@namespacing)
-      exception_notifiable_verbose
-    end
-    def silent_exceptions
-      deprecation_warning("silent_exceptions", "exception_notifiable_silent_exceptions", @@namespacing)
-      exception_notifiable_silent_exceptions
-    end
-    def notification_level
-      deprecation_warning("notification_level", "exception_notifiable_notification_level", @@namespacing)
-      exception_notifiable_notification_level
-    end
-    def exception_notifier_verbose=(arg)
-      deprecation_warning("exception_notifier_verbose=", "exception_notifiable_verbose=", @@namespacing)
-      exception_notifiable_verbose = arg
-    end
-    def silent_exceptions=(arg)
-      deprecation_warning("silent_exceptions=", "exception_notifiable_silent_exceptions=", @@namespacing)
-      exception_notifiable_silent_exceptions = arg
-    end
-    def notification_level=(arg)
-      deprecation_warning("notification_level=", "exception_notifiable_notification_level=", @@namespacing)
-      exception_notifiable_notification_level = arg
-    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}"
-    end
-  end
-end

data/lib/super_exception_notifier/git_blame.rb

@@ -1,52 +0,0 @@
-#Copyright (c) 2008-2009 Peter H. Boling of 9thBit LLC
-#Released under the MIT license
-
-module SuperExceptionNotifier
-  module GitBlame
-
-    def lay_blame(exception)
-      error = {}
-      unless(ExceptionNotifier.config[:git_repo_path].nil?)
-        if(exception.class == ActionView::TemplateError)
-            blame = blame_output(exception.line_number, "app/views/#{exception.file_name}")
-            error[:author] = blame[/^author\s.+$/].gsub(/author\s/,'')
-            error[:line]   = exception.line_number
-            error[:file]   = exception.file_name
-        else
-          exception.backtrace.each do |line|
-            file = exception_in_project?(line[/^.+?(?=:)/])
-            unless(file.nil?)
-              line_number = line[/:\d+:/].gsub(/[^\d]/,'')
-              # Use relative path or weird stuff happens
-              blame = blame_output(line_number, file.gsub(Regexp.new("#{RAILS_ROOT}/"),''))
-              error[:author] = blame[/^author\s.+$/].sub(/author\s/,'')
-              error[:line]   = line_number
-              error[:file]   = file
-              break
-            end
-          end
-        end
-      end
-      error
-    end
-
-    def blame_output(line_number, path)
-      app_directory = Dir.pwd
-      Dir.chdir ExceptionNotifier.config[:git_repo_path]
-      blame = `git blame -p -L #{line_number},#{line_number} #{path}`
-      Dir.chdir app_directory
-
-      blame
-    end
-
-    def exception_in_project?(path) # should be a path like /path/to/broken/thingy.rb
-      dir = File.split(path).first rescue ''
-      if(File.directory?(dir) and !(path =~ /vendor\/plugins/) and !(path =~ /vendor\/gems/) and path.include?(RAILS_ROOT))
-        path
-      else
-        nil
-      end
-    end
-
-  end
-end

data/lib/super_exception_notifier/helpful_hashes.rb

@@ -1,66 +0,0 @@
-#Copyright (c) 2008-2009 Peter H. Boling of 9thBit LLC
-#Released under the MIT license
-
-module SuperExceptionNotifier
-  module HelpfulHashes
-    unless defined?(SILENT_EXCEPTIONS)
-      noiseless = []
-      noiseless << ActiveRecord::RecordNotFound if defined?(ActiveRecord)
-      if defined?(ActionController)
-        noiseless << ActionController::UnknownController
-        noiseless << ActionController::UnknownAction
-        noiseless << ActionController::RoutingError
-        noiseless << ActionController::MethodNotAllowed
-      end
-      SILENT_EXCEPTIONS = noiseless
-    end
-
-    # TODO: use ActionController::StatusCodes
-    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"
-    } unless defined?(HTTP_STATUS_CODES)
-
-    def codes_for_error_classes
-      #TODO: Format whitespace
-      classes = {
-        # These are standard errors in rails / ruby
-        NameError => "503",
-        TypeError => "503",
-        RuntimeError => "500",
-        ArgumentError => "500",
-        # These are custom error names defined in lib/super_exception_notifier/custom_exception_classes
-        AccessDenied => "403",
-        PageNotFound => "404",
-        InvalidMethod => "405",
-        ResourceGone => "410",
-        CorruptData => "422",
-        NoMethodError => "500",
-        NotImplemented => "501",
-        MethodDisabled => "200"
-      }
-      # Highly dependent on the verison of rails, so we're very protective about these'
-      classes.merge!({ ActionView::TemplateError => "500"})             if defined?(ActionView)       && ActionView.const_defined?(:TemplateError)
-      classes.merge!({ ActiveRecord::RecordNotFound => "400" })         if defined?(ActiveRecord)     && ActiveRecord.const_defined?(:RecordNotFound)
-      classes.merge!({ ActiveResource::ResourceNotFound => "404" })     if defined?(ActiveResource)   && ActiveResource.const_defined?(:ResourceNotFound)
-
-      if defined?(ActionController)
-        classes.merge!({ ActionController::UnknownController => "404" })          if ActionController.const_defined?(:UnknownController)
-        classes.merge!({ ActionController::MissingTemplate => "404" })            if ActionController.const_defined?(:MissingTemplate)
-        classes.merge!({ ActionController::MethodNotAllowed => "405" })           if ActionController.const_defined?(:MethodNotAllowed)
-        classes.merge!({ ActionController::UnknownAction => "501" })              if ActionController.const_defined?(:UnknownAction)
-        classes.merge!({ ActionController::RoutingError => "404" })               if ActionController.const_defined?(:RoutingError)
-        classes.merge!({ ActionController::InvalidAuthenticityToken => "405" })   if ActionController.const_defined?(:InvalidAuthenticityToken)
-      end
-    end
-  end
-end

data/lib/super_exception_notifier/hooks_notifier.rb

@@ -1,55 +0,0 @@
-require 'net/http'
-require 'uri'
-
-module SuperExceptionNotifier
-  module HooksNotifier
-    # Deliver exception data hash to web hooks, if any
-    #
-    def self.deliver_exception_to_web_hooks(config, exception, controller, request, data={}, the_blamed = nil)
-      params = build_web_hook_params(config, exception, controller, request, data, the_blamed)
-      # TODO: use threads here
-      config[:web_hooks].each do |address|
-        post_hook(params, address)
-      end
-    end
-
-
-    # Parameters hash based on Merb Exceptions example
-    #
-    def self.build_web_hook_params(config, exception, controller, request, data={}, the_blamed = nil)
-      host = (request.env["HTTP_X_FORWARDED_HOST"] || request.env["HTTP_HOST"])
-      p = {
-        'environment'              => (defined?(Rails) ? Rails.env : RAILS_ENV),
-        'exceptions'               => [{
-          :class      => exception.class.to_s,
-          :backtrace  => exception.backtrace,
-          :message    => exception.message
-          }],
-        'app_name'                 => config[:app_name],
-        'version'                  => config[:version],
-        'blame'                    => "#{the_blamed}"
-      }
-      if !request.nil?
-        p.merge!({'request_url'         => "#{request.protocol}#{host}#{request.request_uri}"})
-        p.merge!({'request_action'      => request.parameters['action']})
-        p.merge!({'request_params'      => request.parameters.inspect})
-      end
-      p.merge!({'request_controller'    => controller.class.name}) if !controller.nil?
-      p.merge!({'status'                => exception.status}) if exception.respond_to?(:status)
-      return p
-    end
-
-    def self.post_hook(params, address)
-      uri = URI.parse(address)
-      uri.path = '/' if uri.path=='' # set a path if one isn't provided to keep Net::HTTP happy
-
-      headers = { 'Content-Type' => 'text/x-json' }
-      data = params.to_json
-      Net::HTTP.start(uri.host, uri.port) do |http|
-        http.request_post(uri.path, data, headers)
-      end
-      data
-    end
-
-  end
-end