pzingg-hoptoad_notifier 1.1.1

data/INSTALL

@@ -0,0 +1,64 @@
+HoptoadNotifier
+===============
+
+This is the notifier plugin for integrating apps with Hoptoad.
+
+When an uncaught exception occurs, HoptoadNotifier will POST the relevant data 
+to the Hoptoad server specified in your environment.
+
+
+INSTALLATION
+------------
+
+REMOVE EXCEPTION_NOTIFIER
+
+In your ApplicationController, REMOVE this line:
+
+  include ExceptionNotifiable
+
+In your config/environment* files, remove all references to ExceptionNotifier
+
+Remove the vendor/plugins/exception_notifier directory.
+
+INSTALL HOPTOAD_NOTIFIER
+
+From your project's RAILS_ROOT, run:
+
+  script/plugin install git://github.com/thoughtbot/hoptoad_notifier.git
+
+CONFIGURATION
+
+You should have something like this in config/initializers/hoptoad.rb.
+
+  HoptoadNotifier.configure do |config|
+    config.api_key = '1234567890abcdef'
+  end
+  
+(Please note that this configuration should be in a global configuration, and
+is *not* enrivonment-specific. Hoptoad is smart enough to know what errors are
+caused by what environments, so your staging errors don't get mixed in with
+your production errors.)
+
+To enable hoptoad in your application, you must modify your application.rb to 
+include the module HoptoadNotifier::Catcher into your application controller.
+
+Example...
+
+  class ApplicationController < ActionController::Base
+    include HoptoadNotifier::Catcher
+  end
+
+After this is in place, all exceptions will be logged to Hoptoad where they can 
+be aggregated, filtered, sorted, analyzed, massaged, and searched.
+
+** NOTE FOR RAILS 1.2.* USERS: **
+You will need to copy the hoptoad_notifier_tasks.rake file into your
+RAILS_ROOT/lib/tasks directory in order for the following to work:
+
+You can test that hoptoad is working in your production environment by using 
+this rake task (from RAILS_ROOT):
+
+  rake hoptoad:test
+
+If everything is configured properly, that task will send a notice to hoptoad 
+which will be visible immediately.

data/README

@@ -0,0 +1,165 @@
+HoptoadNotifier
+===============
+
+This is the notifier plugin for integrating apps with Hoptoad.
+
+When an uncaught exception occurs, HoptoadNotifier will POST the relevant data 
+to the Hoptoad server specified in your environment.
+
+INSTALLATION
+------------
+
+REMOVE EXCEPTION_NOTIFIER
+
+In your ApplicationController, REMOVE this line:
+
+  include ExceptionNotifiable
+
+In your config/environment* files, remove all references to ExceptionNotifier
+
+Remove the vendor/plugins/exception_notifier directory.
+
+INSTALL HOPTOAD_NOTIFIER
+
+From your project's RAILS_ROOT, run:
+
+  script/plugin install git://github.com/thoughtbot/hoptoad_notifier.git
+
+CONFIGURATION
+
+You should have something like this in config/initializers/hoptoad.rb.
+
+  HoptoadNotifier.configure do |config|
+    config.api_key = '1234567890abcdef'
+  end
+  
+(Please note that this configuration should be in a global configuration, and
+is *not* enrivonment-specific. Hoptoad is smart enough to know what errors are
+caused by what environments, so your staging errors don't get mixed in with
+your production errors.)
+
+Then, to enable hoptoad in your application, include this code...
+
+  include HoptoadNotifier::Catcher
+
+...in your ApplicationController, and all exceptions will be logged to Hoptoad
+where they can be aggregated, filtered, sorted, analyzed, massaged, and
+searched.
+
+** NOTE FOR RAILS 1.2.* USERS: **
+You will need to copy the hoptoad_notifier_tasks.rake file into your
+RAILS_ROOT/lib/tasks directory in order for the following to work:
+
+You can test that hoptoad is working in your production environment by using 
+this rake task (from RAILS_ROOT):
+
+  rake hoptoad:test
+
+If everything is configured properly, that task will send a notice to hoptoad 
+which will be visible immediately.
+
+USAGE
+
+For the most part, hoptoad works for itself.  Once you've included the notifier 
+in your ApplicationController, all errors will be rescued by the 
+#rescue_action_in_public provided by the plugin.
+
+If you want to log arbitrary things which you've rescued yourself from a 
+controller, you can do something like this:
+
+  ...
+  rescue => ex
+    notify_hoptoad(ex)
+    flash[:failure] = 'Encryptions could not be rerouted, try again.'
+  end
+  ...
+
+The #notify_hoptoad call will send the notice over to hoptoad for later 
+analysis.
+
+GOING BEYOND EXCEPTIONS
+
+You can also pass a hash to notify_hoptoad method and store whatever you want, not just an exception. And you can also use it anywhere, not just in controllers:
+
+  begin 
+    params = { 
+      # params that you pass to a method that can throw an exception 
+    }
+    my_unpredicable_method(params) 
+  rescue => e
+    HoptoadNotifier.notify(
+      :error_class => "Special Error", 
+      :error_message => "Special Error: #{e.message}", 
+      :request => { :params => params }
+    )
+  end
+
+While in your controllers you use the notify_hoptoad method, anywhere else in your code, use HoptoadNotifier.notify. Hoptoad will get all the information about the error itself. As for a hash, these are the keys you should pass:
+
+  * :error_class – Use this to group similar errors together. When Hoptoad catches an exception it sends the class name of that exception object.
+  * :error_message – This is the title of the error you see in the errors list. For exceptions it is "#{exception.class.name}: #{exception.message}"
+  * :request – While there are several ways to send additional data to Hoptoad, passing a Hash with :params key as :request as in the example above is the most common use case. When Hoptoad catches an exception in a controller, the actual HTTP client request is being sent using this key.
+
+Hoptoad merges the hash you pass with these default options:
+
+  def default_notice_options
+    { 
+      :api_key => HoptoadNotifier.api_key, 
+      :error_message => 'Notification', 
+      :backtrace => caller, 
+      :request => {}, 
+      :session => {}, 
+      :environment => ENV.to_hash 
+    } 
+  end
+
+You can override any of those parameters.
+
+FILTERING
+
+You can specify a whitelist of errors, that Hoptoad will not report on.  Use 
+this feature when you are so apathetic to certain errors that you don't want 
+them even logged.
+
+This filter will only be applied to automatic notifications, not manual 
+notifications (when #notify is called directly).
+
+Hoptoad ignores the following exceptions by default:
+  ActiveRecord::RecordNotFound
+  ActionController::RoutingError
+  ActionController::InvalidAuthenticityToken
+  CGI::Session::CookieStore::TamperedWithCookie
+  
+To ignore errors in addition to those, specify their names in your Hoptoad 
+configuration block.
+
+  HoptoadNotifier.configure do |config|
+    config.api_key      = '1234567890abcdef'
+    config.ignore       << ActiveRecord::IgnoreThisError
+  end
+
+To ignore *only* certain errors (and override the defaults), use the 
+#ignore_only attribute.
+
+  HoptoadNotifier.configure do |config|
+    config.api_key      = '1234567890abcdef'
+    config.ignore_only  = [ActiveRecord::IgnoreThisError]
+  end
+
+TESTING
+
+When you run your tests, you might notice that the hoptoad service is recording
+notices generated using #notify when you don't expect it to.  You can 
+use code like this in your test_helper.rb to redefine that method so those 
+errors are not reported while running tests.
+
+  module HoptoadNotifier::Catcher
+    def notify(thing)
+      # do nothing.
+    end
+  end
+
+THANKS
+
+Thanks to Eugene Bolshakov for the excellent write-up on GOING BEYOND EXCEPTIONS, which we have included above.
+

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the hoptoad_notifier plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the hoptoad_notifier plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'HoptoadNotifier'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/hoptoad_notifier.rb

@@ -0,0 +1,322 @@
+require 'net/http'
+require 'net/https'
+require 'rubygems'
+require 'active_support'
+
+# Plugin for applications to automatically post errors to the Hoptoad of their choice.
+module HoptoadNotifier
+
+  IGNORE_DEFAULT = ['ActiveRecord::RecordNotFound',
+                    'ActionController::RoutingError',
+                    'ActionController::InvalidAuthenticityToken',
+                    'CGI::Session::CookieStore::TamperedWithCookie']
+
+  # Some of these don't exist for Rails 1.2.*, so we have to consider that.
+  IGNORE_DEFAULT.map!{|e| eval(e) rescue nil }.compact!
+  IGNORE_DEFAULT.freeze
+  
+  class << self
+    attr_accessor :host, :port, :secure, :api_key, :http_open_timeout, :http_read_timeout,
+                  :proxy_host, :proxy_port, :proxy_user, :proxy_pass
+    attr_reader   :backtrace_filters
+
+    # Takes a block and adds it to the list of backtrace filters. When the filters
+    # run, the block will be handed each line of the backtrace and can modify
+    # it as necessary. For example, by default a path matching the RAILS_ROOT
+    # constant will be transformed into "[RAILS_ROOT]"
+    def filter_backtrace &block
+      (@backtrace_filters ||= []) << block
+    end
+
+    # The port on which your Hoptoad server runs.
+    def port
+      @port || (secure ? 443 : 80)
+    end
+
+    # The host to connect to.
+    def host
+      @host ||= 'hoptoadapp.com'
+    end
+    
+    # The HTTP open timeout (defaults to 2 seconds).
+    def http_open_timeout
+      @http_open_timeout ||= 2
+    end
+    
+    # The HTTP read timeout (defaults to 5 seconds).
+    def http_read_timeout
+      @http_read_timeout ||= 5
+    end
+    
+    # Returns the list of errors that are being ignored. The array can be appended to.
+    def ignore
+      @ignore ||= (HoptoadNotifier::IGNORE_DEFAULT.dup)
+      @ignore.flatten!
+      @ignore
+    end
+    
+    # Sets the list of ignored errors to only what is passed in here. This method
+    # can be passed a single error or a list of errors.
+    def ignore_only=(names)
+      @ignore = [names].flatten
+    end
+
+    # Returns a list of parameters that should be filtered out of what is sent to Hoptoad.
+    # By default, all "password" attributes will have their contents replaced.
+    def params_filters
+      @params_filters ||= %w(password)
+    end
+
+    def environment_filters
+      @environment_filters ||= %w()
+    end
+    
+    # Call this method to modify defaults in your initializers.
+    #
+    # HoptoadNotifier.configure do |config|
+    #   config.api_key = '1234567890abcdef'
+    #   config.secure  = false
+    # end
+    #
+    # NOTE: secure connections are not yet supported.
+    def configure
+      yield self
+    end
+    
+    def protocol #:nodoc:
+      secure ? "https" : "http"
+    end
+    
+    def url #:nodoc:
+      URI.parse("#{protocol}://#{host}:#{port}/notices/")
+    end
+    
+    def default_notice_options #:nodoc:
+      {
+        :api_key       => HoptoadNotifier.api_key,
+        :error_message => 'Notification',
+        :backtrace     => caller,
+        :request       => {},
+        :session       => {},
+        :environment   => ENV.to_hash
+      }
+    end
+    
+    # You can send an exception manually using this method, even when you are not in a
+    # controller. You can pass an exception or a hash that contains the attributes that
+    # would be sent to Hoptoad:
+    # * api_key: The API key for this project. The API key is a unique identifier that Hoptoad
+    #   uses for identification.
+    # * error_message: The error returned by the exception (or the message you want to log).
+    # * backtrace: A backtrace, usually obtained with +caller+.
+    # * request: The controller's request object.
+    # * session: The contents of the user's session.
+    # * environment: ENV merged with the contents of the request's environment.
+    def notify notice = {}
+      Sender.new.notify_hoptoad( notice )
+    end
+  end
+
+  filter_backtrace do |line|
+    line.gsub(/#{RAILS_ROOT}/, "[RAILS_ROOT]")
+  end
+
+  filter_backtrace do |line|
+    line.gsub(/^\.\//, "")
+  end
+
+  filter_backtrace do |line|
+    if defined?(Gem)
+      Gem.path.inject(line) do |line, path|
+        line.gsub(/#{path}/, "[GEM_ROOT]")
+      end
+    end
+  end
+
+  # Include this module in Controllers in which you want to be notified of errors.
+  module Catcher
+
+    def self.included(base) #:nodoc:
+      if base.instance_methods.include? 'rescue_action_in_public' and !base.instance_methods.include? 'rescue_action_in_public_without_hoptoad'
+        base.send(:alias_method, :rescue_action_in_public_without_hoptoad, :rescue_action_in_public)
+        base.send(:alias_method, :rescue_action_in_public, :rescue_action_in_public_with_hoptoad)
+      end
+    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.
+    def rescue_action_in_public_with_hoptoad exception
+      notify_hoptoad(exception) unless ignore?(exception)
+      rescue_action_in_public_without_hoptoad(exception)
+    end 
+        
+    # This method should be used for sending manual notifications while you are still
+    # inside the controller. Otherwise it works like HoptoadNotifier.notify. 
+    def notify_hoptoad hash_or_exception
+      if public_environment?
+        notice = normalize_notice(hash_or_exception)
+        notice = clean_notice(notice)
+        send_to_hoptoad(:notice => notice)
+      end
+    end
+
+    alias_method :inform_hoptoad, :notify_hoptoad
+
+    # Returns the default logger or a logger that prints to STDOUT. Necessary for manual
+    # notifications outside of controllers.
+    def logger
+      ActiveRecord::Base.logger
+    rescue
+      @logger ||= Logger.new(STDERR)
+    end
+
+    private
+    
+    def public_environment? #nodoc:
+      defined?(RAILS_ENV) and !['development', 'test'].include?(RAILS_ENV)
+    end
+    
+    def ignore?(exception) #:nodoc:
+      ignore_these = HoptoadNotifier.ignore.flatten
+      ignore_these.include?(exception.class) || ignore_these.include?(exception.class.name)
+    end
+
+    def exception_to_data exception #:nodoc:
+      data = {
+        :api_key       => HoptoadNotifier.api_key,
+        :error_class   => exception.class.name,
+        :error_message => "#{exception.class.name}: #{exception.message}",
+        :backtrace     => exception.backtrace,
+        :environment   => ENV.to_hash
+      }
+
+      if self.respond_to? :request
+        data[:request] = {
+          :params      => request.parameters.to_hash,
+          :rails_root  => File.expand_path(RAILS_ROOT),
+          :url         => "#{request.protocol}#{request.host}#{request.request_uri}"
+        }
+        data[:environment].merge!(request.env.to_hash)
+      end
+
+      if self.respond_to? :session
+        data[:session] = {
+          :key         => session.instance_variable_get("@session_id"),
+          :data        => session.instance_variable_get("@data")
+        }
+      end
+
+      data
+    end
+
+    def normalize_notice(notice) #:nodoc:
+      case notice
+      when Hash
+        HoptoadNotifier.default_notice_options.merge(notice)
+      when Exception
+        HoptoadNotifier.default_notice_options.merge(exception_to_data(notice))
+      end
+    end
+
+    def clean_notice(notice) #:nodoc:
+      notice[:backtrace] = clean_hoptoad_backtrace(notice[:backtrace])
+      if notice[:request].is_a?(Hash) && notice[:request][:params].is_a?(Hash)
+        notice[:request][:params] = filter_parameters(notice[:request][:params]) if respond_to?(:filter_parameters)
+        notice[:request][:params] = clean_hoptoad_params(notice[:request][:params])
+      end
+      if notice[:environment].is_a?(Hash)
+        notice[:environment] = filter_parameters(notice[:environment]) if respond_to?(:filter_parameters)
+        notice[:environment] = clean_hoptoad_environment(notice[:environment])
+      end
+      clean_non_serializable_data(notice)
+    end
+
+    def send_to_hoptoad data #:nodoc:
+      headers = {
+        'Content-type' => 'application/x-yaml',
+        'Accept' => 'text/xml, application/xml'
+      }
+
+      url = HoptoadNotifier.url
+      
+      http = Net::HTTP::Proxy(HoptoadNotifier.proxy_host, 
+                              HoptoadNotifier.proxy_port, 
+                              HoptoadNotifier.proxy_user, 
+                              HoptoadNotifier.proxy_pass).new(url.host, url.port)
+
+      http.use_ssl = true
+        http.read_timeout = HoptoadNotifier.http_read_timeout
+        http.open_timeout = HoptoadNotifier.http_open_timeout
+      http.use_ssl = !!HoptoadNotifier.secure 
+
+        response = begin
+          http.post(url.path, stringify_keys(data).to_yaml, headers)
+        rescue TimeoutError => e
+          logger.error "Timeout while contacting the Hoptoad server."
+          nil
+        end
+       
+      case response
+      when Net::HTTPSuccess then
+        logger.info "Hoptoad Success: #{response.class}"
+      else
+        logger.error "Hoptoad Failure: #{response.class}\n#{response.body if response.respond_to? :body}"
+      end
+    end
+    
+    def clean_hoptoad_backtrace backtrace #:nodoc:
+      if backtrace.to_a.size == 1
+        backtrace = backtrace.to_a.first.split(/\n\s*/)
+      end
+    
+      backtrace.to_a.map do |line|
+        HoptoadNotifier.backtrace_filters.inject(line) do |line, proc|
+          proc.call(line)
+        end
+      end
+    end
+    
+    def clean_hoptoad_params params #:nodoc:
+      params.each do |k, v|
+        params[k] = "[FILTERED]" if HoptoadNotifier.params_filters.any? do |filter|
+          k.to_s.match(/#{filter}/)
+        end
+      end
+    end
+    
+    def clean_hoptoad_environment env #:nodoc:
+      env.each do |k, v|
+        env[k] = "[FILTERED]" if HoptoadNotifier.environment_filters.any? do |filter|
+          k.to_s.match(/#{filter}/)
+        end
+      end
+    end
+
+    def clean_non_serializable_data(notice) #:nodoc:
+      notice.select{|k,v| serializable?(v) }.inject({}) do |h, pair|
+        h[pair.first] = pair.last.is_a?(Hash) ? clean_non_serializable_data(pair.last) : pair.last
+        h
+      end
+    end
+
+    def serializable?(value) #:nodoc:
+      !(value.is_a?(Module) || value.kind_of?(IO))
+    end
+
+    def stringify_keys(hash) #:nodoc:
+      hash.inject({}) do |h, pair|
+        h[pair.first.to_s] = pair.last.is_a?(Hash) ? stringify_keys(pair.last) : pair.last
+        h
+      end
+    end
+
+  end
+
+  # A dummy class for sending notifications manually outside of a controller.
+  class Sender
+    def rescue_action_in_public(exception)
+    end
+
+    include HoptoadNotifier::Catcher
+  end
+end

data/tasks/hoptoad_notifier_tasks.rake

@@ -0,0 +1,57 @@
+namespace :hoptoad do
+  desc "Verify your plugin installation by sending a test exception to the hoptoad service"
+  task :test => :environment do
+    require 'action_controller/test_process'
+    require 'application_controller'
+
+    request = ActionController::TestRequest.new
+    request.query_parameters = {
+      'action' => 'verify',
+      'controller' => 'hoptoad_verification'
+    }
+
+    response = ActionController::TestResponse.new
+
+    class HoptoadTestingException < RuntimeError; end
+
+    in_controller = ApplicationController.included_modules.include? HoptoadNotifier::Catcher
+    in_base = ActionController::Base.included_modules.include? HoptoadNotifier::Catcher
+    unless in_controller and not in_base
+      puts "HoptoadNotifier::Catcher must be included inside your ApplicationController class."
+      exit
+    end
+
+    puts 'Setting up the Controller.'
+    class ApplicationController
+      # This is to bypass any filters that may prevent access to the action.
+      prepend_before_filter :test_hoptoad
+      def test_hoptoad
+        puts "Raising '#{exception_class.name}' to simulate application failure."
+        raise exception_class.new, 'Testing hoptoad via "rake hoptoad:test". If you can see this, it works.'
+      end
+
+      def rescue_action exception
+        rescue_action_in_public exception
+      end
+
+      def public_environment?
+        true
+      end
+
+      # Ensure we actually have an action to go to.
+      def verify; end
+
+      def exception_class
+        exception_name = ENV['EXCEPTION'] || "HoptoadTestingException"
+        Object.const_get(exception_name)
+      rescue
+        Object.const_set(exception_name, Class.new(Exception))
+      end
+    end
+
+    puts 'Processing request.'
+    class HoptoadVerificationController < ApplicationController; end
+    HoptoadVerificationController.new.process(request, response)
+  end
+end
+

data/test/hoptoad_notifier_test.rb

@@ -0,0 +1,526 @@
+require 'test/unit'
+require 'rubygems'
+require 'mocha'
+gem 'thoughtbot-shoulda', ">= 2.0.0"
+require 'shoulda'
+require 'action_controller'
+require 'action_controller/test_process'
+require 'active_record'
+require 'active_record/base'
+require 'active_support/testing/core_ext/test/unit/assertions' 
+require File.join(File.dirname(__FILE__), "..", "lib", "hoptoad_notifier")
+
+RAILS_ROOT = File.join( File.dirname(__FILE__), "rails_root" )
+RAILS_ENV  = "test"
+
+class HoptoadController < ActionController::Base
+  def rescue_action e
+    raise e
+  end
+  
+  def do_raise
+    raise "Hoptoad"
+  end
+  
+  def do_not_raise
+    render :text => "Success"
+  end
+  
+  def do_raise_ignored
+    raise ActiveRecord::RecordNotFound.new("404")
+  end
+  
+  def do_raise_not_ignored
+    raise ActiveRecord::StatementInvalid.new("Statement invalid")
+  end
+  
+  def manual_notify
+    notify_hoptoad(Exception.new)
+    render :text => "Success"
+  end
+  
+  def manual_notify_ignored
+    notify_hoptoad(ActiveRecord::RecordNotFound.new("404"))
+    render :text => "Success"
+  end
+end
+
+class HoptoadNotifierTest < Test::Unit::TestCase
+  def request(action = nil, method = :get)
+    @request = ActionController::TestRequest.new
+    @request.action = action ? action.to_s : ""
+    @response = ActionController::TestResponse.new
+    @controller.process(@request, @response)
+  end
+  
+  context "Hoptoad inclusion" do
+    should "be able to occur even outside Rails controllers" do    
+      assert_nothing_raised do
+        class MyHoptoad
+          include HoptoadNotifier::Catcher
+        end
+      end
+      my = MyHoptoad.new
+      assert my.respond_to?(:notify_hoptoad)
+    end
+  end
+  
+  context "HoptoadNotifier configuration" do
+    setup do
+      @controller = HoptoadController.new
+      class ::HoptoadController
+        include HoptoadNotifier::Catcher
+        def rescue_action e
+          rescue_action_in_public e
+        end
+      end
+      assert @controller.methods.include?("notify_hoptoad")
+    end
+
+    should "be done with a block" do
+      HoptoadNotifier.configure do |config|
+        config.host = "host"
+        config.port = 3333
+        config.secure = true
+        config.api_key = "1234567890abcdef"
+        config.ignore << [ RuntimeError ]
+        config.proxy_host = 'proxyhost1'
+        config.proxy_port = '80'
+        config.proxy_user = 'user'
+        config.proxy_pass = 'secret'
+        config.http_open_timeout = 2
+        config.http_read_timeout = 5
+      end
+      
+      assert_equal "host",              HoptoadNotifier.host
+      assert_equal 3333,                HoptoadNotifier.port
+      assert_equal true,                HoptoadNotifier.secure
+      assert_equal "1234567890abcdef",  HoptoadNotifier.api_key
+      assert_equal 'proxyhost1',        HoptoadNotifier.proxy_host
+      assert_equal '80',                HoptoadNotifier.proxy_port
+      assert_equal 'user',              HoptoadNotifier.proxy_user
+      assert_equal 'secret',            HoptoadNotifier.proxy_pass
+      assert_equal 2,                   HoptoadNotifier.http_open_timeout
+      assert_equal 5,                   HoptoadNotifier.http_read_timeout
+      assert_equal (HoptoadNotifier::IGNORE_DEFAULT + [RuntimeError]), HoptoadNotifier.ignore
+    end
+
+    should "set a default host" do
+      HoptoadNotifier.instance_variable_set("@host",nil)
+      assert_equal "hoptoadapp.com", HoptoadNotifier.host
+    end
+    
+    should "add filters to the backtrace_filters" do
+      assert_difference "HoptoadNotifier.backtrace_filters.length" do
+        HoptoadNotifier.configure do |config|
+          config.filter_backtrace do |line|
+            line = "1234"
+          end
+        end
+      end
+      
+      assert_equal %w( 1234 1234 ), @controller.send(:clean_hoptoad_backtrace, %w( foo bar ))
+    end
+    
+    should "use standard rails logging filters on params and env" do
+      ::HoptoadController.class_eval do
+        filter_parameter_logging :ghi
+      end
+ 
+      expected = {"notice" => {"request" => {"params" => {"abc" => "123", "def" => "456", "ghi" => "[FILTERED]"}},
+                             "environment" => {"abc" => "123", "ghi" => "[FILTERED]"}}}
+      notice   = {"notice" => {"request" => {"params" => {"abc" => "123", "def" => "456", "ghi" => "789"}},
+                             "environment" => {"abc" => "123", "ghi" => "789"}}}
+      assert @controller.respond_to?(:filter_parameters)
+      assert_equal( expected[:notice], @controller.send(:clean_notice, notice)[:notice] )
+    end
+
+    should "add filters to the params filters" do
+      assert_difference "HoptoadNotifier.params_filters.length", 2 do
+        HoptoadNotifier.configure do |config|
+          config.params_filters << "abc"
+          config.params_filters << "def"
+        end
+      end
+
+      assert HoptoadNotifier.params_filters.include?( "abc" )
+      assert HoptoadNotifier.params_filters.include?( "def" )
+      
+      assert_equal( {:abc => "[FILTERED]", :def => "[FILTERED]", :ghi => "789"},
+                    @controller.send(:clean_hoptoad_params, :abc => "123", :def => "456", :ghi => "789" ) )
+    end
+
+    should "add filters to the environment filters" do
+      assert_difference "HoptoadNotifier.environment_filters.length", 2 do
+        HoptoadNotifier.configure do |config|
+          config.environment_filters << "secret"
+          config.environment_filters << "supersecret"
+        end
+      end
+
+      assert HoptoadNotifier.environment_filters.include?( "secret" )
+      assert HoptoadNotifier.environment_filters.include?( "supersecret" )
+      
+      assert_equal( {:secret => "[FILTERED]", :supersecret => "[FILTERED]", :ghi => "789"},
+                    @controller.send(:clean_hoptoad_environment, :secret => "123", :supersecret => "456", :ghi => "789" ) )
+    end
+
+    should "have at default ignored exceptions" do
+      assert HoptoadNotifier::IGNORE_DEFAULT.any?
+    end
+  end
+
+  context "The hoptoad test controller" do
+    setup do
+      @controller = ::HoptoadController.new
+      class ::HoptoadController
+        def rescue_action e
+          raise e
+        end
+      end
+    end
+
+    context "with no notifier catcher" do
+      should "not prevent raises" do
+        assert_raises RuntimeError do
+          request("do_raise")
+        end
+      end
+
+      should "allow a non-raising action to complete" do
+        assert_nothing_raised do
+          request("do_not_raise")
+        end
+      end
+    end
+    
+    context "with the notifier installed" do
+      setup do
+        class ::HoptoadController
+          include HoptoadNotifier::Catcher
+          def rescue_action e
+            rescue_action_in_public e
+          end
+        end
+        HoptoadNotifier.ignore_only = HoptoadNotifier::IGNORE_DEFAULT
+        @controller.stubs(:public_environment?).returns(true)
+        @controller.stubs(:send_to_hoptoad)
+      end
+      
+      should "have inserted its methods into the controller" do
+        assert @controller.methods.include?("inform_hoptoad")
+      end
+      
+      should "prevent raises and send the error to hoptoad" do
+        @controller.expects(:notify_hoptoad)
+        @controller.expects(:rescue_action_in_public_without_hoptoad)
+        assert_nothing_raised do
+          request("do_raise")
+        end
+      end
+
+      should "allow a non-raising action to complete" do
+        assert_nothing_raised do
+          request("do_not_raise")
+        end
+      end
+      
+      should "allow manual sending of exceptions" do
+        @controller.expects(:notify_hoptoad)
+        @controller.expects(:rescue_action_in_public_without_hoptoad).never
+        assert_nothing_raised do
+          request("manual_notify")
+        end
+      end
+      
+      should "disable manual sending of exceptions in a non-public (development or test) environment" do
+        @controller.stubs(:public_environment?).returns(false)
+        @controller.expects(:send_to_hoptoad).never
+        @controller.expects(:rescue_action_in_public_without_hoptoad).never
+        assert_nothing_raised do
+          request("manual_notify")
+        end
+      end
+      
+      should "send even ignored exceptions if told manually" do
+        @controller.expects(:notify_hoptoad)
+        @controller.expects(:rescue_action_in_public_without_hoptoad).never
+        assert_nothing_raised do
+          request("manual_notify_ignored")
+        end
+      end
+      
+      should "ignore default exceptions" do
+        @controller.expects(:notify_hoptoad).never
+        @controller.expects(:rescue_action_in_public_without_hoptoad)
+        assert_nothing_raised do
+          request("do_raise_ignored")
+        end
+      end
+
+      should "filter non-serializable data" do
+        File.open(__FILE__) do |file|
+          assert_equal( {:ghi => "789"},
+                       @controller.send(:clean_non_serializable_data, :ghi => "789", :class => Class.new, :file => file) )
+        end
+      end
+
+      should "apply all params, environment and technical filters" do
+        params_hash = {:abc => 123}
+        environment_hash = {:def => 456}
+        backtrace_data = :backtrace_data
+
+        raw_notice = {:request => {:params => params_hash}, 
+                      :environment => environment_hash,
+                      :backtrace => backtrace_data}
+
+        processed_notice = {:backtrace => :backtrace_data, 
+                            :request => {:params => :params_data}, 
+                            :environment => :environment_data}
+
+        @controller.expects(:clean_hoptoad_backtrace).with(backtrace_data).returns(:backtrace_data)
+        @controller.expects(:clean_hoptoad_params).with(params_hash).returns(:params_data)
+        @controller.expects(:clean_hoptoad_environment).with(environment_hash).returns(:environment_data)
+        @controller.expects(:clean_non_serializable_data).with(processed_notice).returns(:serializable_data)
+
+        assert_equal(:serializable_data, @controller.send(:clean_notice, raw_notice))
+      end
+      
+      context "and configured to ignore additional exceptions" do
+        setup do
+          HoptoadNotifier.ignore << ActiveRecord::StatementInvalid
+        end
+        
+        should "still ignore default exceptions" do
+          @controller.expects(:notify_hoptoad).never
+          @controller.expects(:rescue_action_in_public_without_hoptoad)
+          assert_nothing_raised do
+            request("do_raise_ignored")
+          end
+        end
+        
+        should "ignore specified exceptions" do
+          @controller.expects(:notify_hoptoad).never
+          @controller.expects(:rescue_action_in_public_without_hoptoad)
+          assert_nothing_raised do
+            request("do_raise_not_ignored")
+          end
+        end
+        
+        should "not ignore unspecified, non-default exceptions" do
+          @controller.expects(:notify_hoptoad)
+          @controller.expects(:rescue_action_in_public_without_hoptoad)
+          assert_nothing_raised do
+            request("do_raise")
+          end
+        end
+      end
+      
+      context "and configured to ignore only certain exceptions" do
+        setup do
+          HoptoadNotifier.ignore_only = [ActiveRecord::StatementInvalid]
+        end
+        
+        should "no longer ignore default exceptions" do
+          @controller.expects(:notify_hoptoad)
+          @controller.expects(:rescue_action_in_public_without_hoptoad)
+          assert_nothing_raised do
+            request("do_raise_ignored")
+          end
+        end
+        
+        should "ignore specified exceptions" do
+          @controller.expects(:notify_hoptoad).never
+          @controller.expects(:rescue_action_in_public_without_hoptoad)
+          assert_nothing_raised do
+            request("do_raise_not_ignored")
+          end
+        end
+        
+        should "not ignore unspecified, non-default exceptions" do
+          @controller.expects(:notify_hoptoad)
+          @controller.expects(:rescue_action_in_public_without_hoptoad)
+          assert_nothing_raised do
+            request("do_raise")
+          end
+        end
+      end
+    end
+  end
+  
+  context "Sending a notice" do
+    context "with an exception" do
+      setup do
+        @sender    = HoptoadNotifier::Sender.new
+        @backtrace = caller
+        @exception = begin
+          raise
+        rescue => caught_exception
+          caught_exception
+        end
+        @options   = {:error_message => "123",
+                      :backtrace => @backtrace}
+        HoptoadNotifier.instance_variable_set("@backtrace_filters", [])
+        HoptoadNotifier::Sender.expects(:new).returns(@sender)
+        @sender.stubs(:public_environment?).returns(true)
+      end
+      
+      context "when using an HTTP Proxy" do
+        setup do
+          @body = 'body'
+          @response = stub(:body => @body)
+          @http = stub(:post => @response, :read_timeout= => nil, :open_timeout= => nil, :use_ssl= => nil)
+          @sender.stubs(:logger).returns(stub(:error => nil, :info => nil))
+          @proxy = stub          
+          @proxy.stubs(:new).returns(@http)
+          
+          HoptoadNotifier.port = nil
+          HoptoadNotifier.host = nil
+          HoptoadNotifier.secure = false
+                    
+          Net::HTTP.expects(:Proxy).with(
+            HoptoadNotifier.proxy_host, 
+            HoptoadNotifier.proxy_port, 
+            HoptoadNotifier.proxy_user, 
+            HoptoadNotifier.proxy_pass
+          ).returns(@proxy)
+        end
+        
+        context "on notify" do
+          setup { HoptoadNotifier.notify(@exception) }
+
+          before_should "post to Hoptoad" do            
+            url = "http://hoptoadapp.com:80/notices/"
+            uri = URI.parse(url)
+            URI.expects(:parse).with(url).returns(uri)
+            @http.expects(:post).with(uri.path, anything, anything).returns(@response)
+          end
+        end  
+      end
+
+      context "when stubbing out Net::HTTP" do
+        setup do
+          @body = 'body'
+          @response = stub(:body => @body)
+          @http = stub(:post => @response, :read_timeout= => nil, :open_timeout= => nil, :use_ssl= => nil)
+          @sender.stubs(:logger).returns(stub(:error => nil, :info => nil))
+          Net::HTTP.stubs(:new).returns(@http)
+          HoptoadNotifier.port = nil
+          HoptoadNotifier.host = nil
+          HoptoadNotifier.proxy_host = nil
+        end
+
+        context "on notify" do
+          setup { HoptoadNotifier.notify(@exception) }
+
+          before_should "post to the right url for non-ssl" do
+            HoptoadNotifier.secure = false
+            url = "http://hoptoadapp.com:80/notices/"
+            uri = URI.parse(url)
+            URI.expects(:parse).with(url).returns(uri)
+            @http.expects(:post).with(uri.path, anything, anything).returns(@response)
+          end
+
+          before_should "post to the right path" do
+            @http.expects(:post).with("/notices/", anything, anything).returns(@response)
+          end
+
+          before_should "call send_to_hoptoad" do
+            @sender.expects(:send_to_hoptoad)
+          end
+
+          before_should "default the open timeout to 2 seconds" do
+            HoptoadNotifier.http_open_timeout = nil
+            @http.expects(:open_timeout=).with(2)
+          end
+
+          before_should "default the read timeout to 5 seconds" do
+            HoptoadNotifier.http_read_timeout = nil
+            @http.expects(:read_timeout=).with(5)
+          end
+          
+          before_should "allow override of the open timeout" do
+            HoptoadNotifier.http_open_timeout = 4
+            @http.expects(:open_timeout=).with(4)
+          end
+          
+          before_should "allow override of the read timeout" do
+            HoptoadNotifier.http_read_timeout = 10
+            @http.expects(:read_timeout=).with(10)
+          end
+
+          before_should "connect to the right port for ssl" do
+            HoptoadNotifier.secure = true
+            Net::HTTP.expects(:new).with("hoptoadapp.com", 443).returns(@http)
+          end
+
+          before_should "connect to the right port for non-ssl" do
+            HoptoadNotifier.secure = false
+            Net::HTTP.expects(:new).with("hoptoadapp.com", 80).returns(@http)
+          end
+
+          before_should "use ssl if secure" do
+            HoptoadNotifier.secure = true
+            HoptoadNotifier.host = 'example.org'
+            Net::HTTP.expects(:new).with('example.org', 443).returns(@http)            
+          end
+
+          before_should "not use ssl if not secure" do
+            HoptoadNotifier.secure = nil
+            HoptoadNotifier.host = 'example.org'
+            Net::HTTP.expects(:new).with('example.org', 80).returns(@http)
+          end
+        end
+      end
+
+      should "send as if it were a normally caught exception" do
+        @sender.expects(:notify_hoptoad).with(@exception)
+        HoptoadNotifier.notify(@exception)
+      end
+
+      should "make sure the exception is munged into a hash" do
+        options = HoptoadNotifier.default_notice_options.merge({
+          :backtrace     => @exception.backtrace,
+          :environment   => ENV.to_hash,
+          :error_class   => @exception.class.name,
+          :error_message => "#{@exception.class.name}: #{@exception.message}",
+          :api_key       => HoptoadNotifier.api_key,
+        })
+        @sender.expects(:send_to_hoptoad).with(:notice => options)
+        HoptoadNotifier.notify(@exception)
+      end
+      
+      should "parse massive one-line exceptions into multiple lines" do
+        @original_backtrace = "one big line\n   separated\n      by new lines\nand some spaces"
+        @expected_backtrace = ["one big line", "separated", "by new lines", "and some spaces"]
+        @exception.set_backtrace [@original_backtrace]
+        
+        options = HoptoadNotifier.default_notice_options.merge({
+          :backtrace     => @expected_backtrace,
+          :environment   => ENV.to_hash,
+          :error_class   => @exception.class.name,
+          :error_message => "#{@exception.class.name}: #{@exception.message}",
+          :api_key       => HoptoadNotifier.api_key,
+        })
+        
+        @sender.expects(:send_to_hoptoad).with(:notice => options)
+        HoptoadNotifier.notify(@exception)
+      end
+    end
+
+    context "without an exception" do
+      setup do
+        @sender    = HoptoadNotifier::Sender.new
+        @backtrace = caller
+        @options   = {:error_message => "123",
+                      :backtrace => @backtrace}
+        HoptoadNotifier::Sender.expects(:new).returns(@sender)
+      end
+
+      should "send sensible defaults" do
+        @sender.expects(:notify_hoptoad).with(@options)
+        HoptoadNotifier.notify(:error_message => "123", :backtrace => @backtrace)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+name: pzingg-hoptoad_notifier
+version: !ruby/object:Gem::Version 
+  version: 1.1.1
+platform: ruby
+authors: 
+- Thoughtbot
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-19 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Rails plugin that reports exceptions to Hoptoad.
+email: info@thoughtbot.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- INSTALL
+- lib/hoptoad_notifier.rb
+- Rakefile
+- README
+- tasks/hoptoad_notifier_tasks.rake
+has_rdoc: true
+homepage: http://github.com/thoughtbot/hoptoad_notifier
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Rails plugin that reports exceptions to Hoptoad.
+test_files: 
+- test/hoptoad_notifier_test.rb