vendor/plugins/hoptoad_notifier/MIT-LICENSE vendor/plugins/hoptoad_notifier/TESTING vendor/plugins/hoptoad_notifier/ginger_scenarios.rb vendor/plugins/hoptoad_notifier/lib/hoptoad_tasks.rb vendor/plugins/hoptoad_notifier/recipes/hoptoad.rb vendor/plugins/hoptoad_notifier/test/configuration_test.rb vendor/plugins/hoptoad_notifier/test/controller_test.rb vendor/plugins/hoptoad_notifier/test/helper.rb vendor/plugins/hoptoad_notifier/test/hoptoad_tasks_test.rb vendor/plugins/hoptoad_notifier/test/logger_test.rb vendor/plugins/hoptoad_notifier/test/notifier_test.rb vendor/plugins/hoptoad_notifier/vendor/ginger/.gitignore vendor/plugins/hoptoad_notifier/vendor/ginger/LICENCE vendor/plugins/hoptoad_notifier/vendor/ginger/README.textile vendor/plugins/hoptoad_notifier/vendor/ginger/Rakefile vendor/plugins/hoptoad_notifier/vendor/ginger/bin/ginger vendor/plugins/hoptoad_notifier/vendor/ginger/ginger.gemspec vendor/plugins/hoptoad_notifier/vendor/ginger/lib/ginger.rb vendor/plugins/hoptoad_notifier/vendor/ginger/lib/ginger/configuration.rb vendor/plugins/hoptoad_notifier/vendor/ginger/lib/ginger/kernel.rb vendor/plugins/hoptoad_notifier/vendor/ginger/lib/ginger/scenario.rb vendor/plugins/hoptoad_notifier/vendor/ginger/spec/ginger/configuration_spec.rb vendor/plugins/hoptoad_notifier/vendor/ginger/spec/ginger/kernel_spec.rb vendor/plugins/hoptoad_notifier/vendor/ginger/spec/ginger/scenario_spec.rb vendor/plugins/hoptoad_notifier/vendor/ginger/spec/ginger_spec.rb vendor/plugins/hoptoad_notifier/vendor/ginger/spec/spec_helper.rb @@ -39,13 +39,8 @@ 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 appication, include this code... - - include HoptoadNotifier::Catcher - -...at the top of your ApplicationController, and all exceptions will be logged -to Hoptoad where they can be aggregated, filtered, sorted, analyzed, massaged, -and searched. +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 vendor/plugins/hoptoad_notifier/INSTALL @@ -32,19 +32,19 @@ 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 +is *not* environment-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 +After adding to your config/initializers like this you must restart your +server. This will not affect the rake task but it bears stating. -...in your ApplicationController, and all exceptions will be logged to Hoptoad -where they can be aggregated, filtered, sorted, analyzed, massaged, and -searched. +That should be it! Now all exceptions will be logged to Hoptoad where they can +be aggregated, filtered, sorted, analyzed, massaged, and searched. In previous +releases you had to include HoptoadNotifier::Catcher into your +ApplicationController, but the plugin takes care of that now. ** NOTE FOR RAILS 1.2.* USERS: ** You will need to copy the hoptoad_notifier_tasks.rake file into your @@ -59,10 +59,11 @@ 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. +in your ApplicationController (which is now done automatically by the plugin), +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: @@ -77,7 +78,25 @@ controller, you can do something like this: The #notify_hoptoad call will send the notice over to hoptoad for later analysis. +To perform custom error processing after Hoptoad has been notified, define the instance method #rescue_action_in_public_without_hoptoad(exception) in your controller. + +TRACKING DEPLOYMENTS IN HOPTOAD +------------------------------- + +Paying Hoptoad plans support the ability to track deployments of your application in Hoptoad. +By notifying Hoptoad of your application deployments, all errors are resolved when a deploy occurs, +so that you'll be notified again about any errors that reoccur after a deployment. + +Additionally, it's possible to review the errors in Hoptoad that occurred before and after a deploy. + +When Hoptoad is installed as a plugin this functionality is loaded automatically (if you have Capistrano version 2.0.0 or greater). + +When Hoptoad installed as a gem, you need to add + require 'hoptoad_notifier/recipes/hoptoad' +to your deploy.rb + 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: @@ -116,6 +135,7 @@ Hoptoad merges the hash you pass with these default options: 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 @@ -128,8 +148,9 @@ Hoptoad ignores the following exceptions by default: ActiveRecord::RecordNotFound ActionController::RoutingError ActionController::InvalidAuthenticityToken + ActionController::UnknownAction CGI::Session::CookieStore::TamperedWithCookie - + To ignore errors in addition to those, specify their names in your Hoptoad configuration block. @@ -146,7 +167,39 @@ To ignore *only* certain errors (and override the defaults), use the config.ignore_only = [ActiveRecord::IgnoreThisError] end +To ignore certain user agents, add in the #ignore_user_agent attribute as a +string or regexp: + + HoptoadNotifier.configure do |config| + config.api_key = '1234567890abcdef' + config.ignore_user_agent << /Ignored/ + config.ignore_user_agent << 'IgnoredUserAgent' + end + +To ignore exceptions based on other conditions, use #ignore_by_filter: + + HoptoadNotifier.configure do |config| + config.api_key = '1234567890abcdef' + config.ignore_by_filter do |exception_data| + true if exception_data[:error_class] == "RuntimeError" + end + end + +To replace sensitive information sent to the hoptoad service with [FILTERED] use #environment_filters or #params_filters: + + HoptoadNotifier.configure do |config| + config.api_key = '1234567890abcdef' + + config.environment_filters << "AWS_SECRET" + config.environment_filters << "EC2_PRIVATE_KEY" + config.environment_filters << "AWS_ACCESS" + config.environment_filters << "EC2_CERT" + + config.params_filters << "credit_card_number" + 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 @@ -159,7 +212,22 @@ errors are not reported while running tests. end end +SUPPORTED RAILS VERSIONS +------------------------ + +The notifier currently supports the following versions of Rails: + +* 1.2.6 +* 2.0.2 +* 2.1.2 +* 2.2.2 +* 2.3.2 +* 2.3.4 + +Please open up a support ticket on Tender ( http://help.hoptoadapp.com ) if you're using a version of Rails that is not listed above and the notifier is not working properly. + THANKS +------ Thanks to Eugene Bolshakov for the excellent write-up on GOING BEYOND EXCEPTIONS, which we have included above. vendor/plugins/hoptoad_notifier/README @@ -20,3 +20,11 @@ Rake::RDocTask.new(:rdoc) do |rdoc| rdoc.rdoc_files.include('README') rdoc.rdoc_files.include('lib/**/*.rb') end + +desc 'Run ginger tests' +task :ginger do + $LOAD_PATH << File.join(*%w[vendor ginger lib]) + ARGV.clear + ARGV << 'test' + load File.join(*%w[vendor ginger bin ginger]) +end vendor/plugins/hoptoad_notifier/Rakefile @@ -9,22 +9,51 @@ module HoptoadNotifier IGNORE_DEFAULT = ['ActiveRecord::RecordNotFound', 'ActionController::RoutingError', 'ActionController::InvalidAuthenticityToken', - 'CGI::Session::CookieStore::TamperedWithCookie'] + 'CGI::Session::CookieStore::TamperedWithCookie', + 'ActionController::UnknownAction'] # 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 - + + IGNORE_USER_AGENT_DEFAULT = [] + + VERSION = "1.2.4" + LOG_PREFIX = "** [Hoptoad] " + + HEADERS = { + 'Content-type' => 'application/x-yaml', + 'Accept' => 'text/xml, application/xml', + 'X-Hoptoad-Client-Name' => 'Hoptoad Notifier', + 'X-Hoptoad-Client-Version' => VERSION + } + class << self - attr_accessor :host, :port, :secure, :api_key - attr_reader :backtrace_filters + attr_accessor :host, :port, :secure, :api_key, :http_open_timeout, :http_read_timeout, + :proxy_host, :proxy_port, :proxy_user, :proxy_pass, :output + + def backtrace_filters + @backtrace_filters ||= [] + end + + def ignore_by_filters + @ignore_by_filters ||= [] + end + + # Takes a block and adds it to the list of ignore filters. When the filters + # run, the block will be handed the exception. If the block yields a value + # equivalent to "true," the exception will be ignored, otherwise it will be + # processed by hoptoad. + def ignore_by_filter &block + self.ignore_by_filters << block + end # 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 + self.backtrace_filters << block end # The port on which your Hoptoad server runs. @@ -36,30 +65,83 @@ module HoptoadNotifier 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 the list of user agents that are being ignored. The array can be appended to. + def ignore_user_agent + @ignore_user_agent ||= (HoptoadNotifier::IGNORE_USER_AGENT_DEFAULT.dup) + @ignore_user_agent.flatten! + @ignore_user_agent + end + + # Sets the list of ignored user agents to only what is passed in here. This method + # can be passed a single user agent or a list of user agents. + def ignore_user_agent_only=(names) + @ignore_user_agent = [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) + @params_filters ||= %w(password password_confirmation) end def environment_filters @environment_filters ||= %w() end - + + def report_ready + write_verbose_log("Notifier #{VERSION} ready to catch errors") + end + + def report_environment_info + write_verbose_log("Environment Info: #{environment_info}") + end + + def report_response_body(response) + write_verbose_log("Response from Hoptoad: \n#{response}") + end + + def environment_info + info = "[Ruby: #{RUBY_VERSION}]" + info << " [Rails: #{::Rails::VERSION::STRING}] [RailsEnv: #{RAILS_ENV}]" if defined?(Rails) + end + + def write_verbose_log(message) + logger.info LOG_PREFIX + message if logger + end + + # Checking for the logger in hopes we can get rid of the ugly syntax someday + def logger + if defined?(Rails.logger) + Rails.logger + elsif defined?(RAILS_DEFAULT_LOGGER) + RAILS_DEFAULT_LOGGER + end + end + # Call this method to modify defaults in your initializers. # # HoptoadNotifier.configure do |config| @@ -69,17 +151,22 @@ module HoptoadNotifier # # NOTE: secure connections are not yet supported. def configure + add_default_filters yield self + if defined?(ActionController::Base) && !ActionController::Base.include?(HoptoadNotifier::Catcher) + ActionController::Base.send(:include, HoptoadNotifier::Catcher) + end + report_ready 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, @@ -90,7 +177,7 @@ module HoptoadNotifier :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: @@ -104,20 +191,28 @@ module HoptoadNotifier def notify notice = {} Sender.new.notify_hoptoad( notice ) end - end - filter_backtrace do |line| - line.gsub(/#{RAILS_ROOT}/, "[RAILS_ROOT]") - end + def add_default_filters + self.backtrace_filters.clear - filter_backtrace do |line| - line.gsub(/^\.\//, "") - end + filter_backtrace do |line| + line.gsub(/#{RAILS_ROOT}/, "[RAILS_ROOT]") + end - filter_backtrace do |line| - if defined?(Gem) - Gem.path.inject(line) do |line, path| - line.gsub(/#{path}/, "[GEM_ROOT]") + 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 + + filter_backtrace do |line| + line if line !~ /lib\/#{File.basename(__FILE__)}/ end end end @@ -126,21 +221,22 @@ module HoptoadNotifier 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' + if base.instance_methods.map(&:to_s).include? 'rescue_action_in_public' and !base.instance_methods.map(&:to_s).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) + base.hide_action(:notify_hoptoad, :inform_hoptoad) if base.respond_to?(:hide_action) 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) + notify_hoptoad(exception) unless ignore?(exception) || ignore_user_agent? rescue_action_in_public_without_hoptoad(exception) - end - + end + # This method should be used for sending manual notifications while you are still - # inside the controller. Otherwise it works like HoptoadNotifier.notify. + # inside the controller. Otherwise it works like HoptoadNotifier.notify. def notify_hoptoad hash_or_exception if public_environment? notice = normalize_notice(hash_or_exception) @@ -149,8 +245,6 @@ module HoptoadNotifier 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 @@ -160,14 +254,20 @@ module HoptoadNotifier 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) + ignore_these.include?(exception.class) || ignore_these.include?(exception.class.name) || HoptoadNotifier.ignore_by_filters.find {|filter| filter.call(exception_to_data(exception))} + end + + def ignore_user_agent? #:nodoc: + # Rails 1.2.6 doesn't have request.user_agent, so check for it here + user_agent = request.respond_to?(:user_agent) ? request.user_agent : request.env["HTTP_USER_AGENT"] + HoptoadNotifier.ignore_user_agent.flatten.any? { |ua| ua === user_agent } end def exception_to_data exception #:nodoc: @@ -191,7 +291,9 @@ module HoptoadNotifier if self.respond_to? :session data[:session] = { :key => session.instance_variable_get("@session_id"), - :data => session.instance_variable_get("@data") + :data => session.respond_to?(:to_hash) ? + session.to_hash : + session.instance_variable_get("@data") } end @@ -220,43 +322,53 @@ module HoptoadNotifier clean_non_serializable_data(notice) end + def log(level, message, response = nil) + logger.send level, LOG_PREFIX + message if logger + HoptoadNotifier.report_environment_info + HoptoadNotifier.report_response_body(response.body) if response && response.respond_to?(:body) + end + def send_to_hoptoad data #:nodoc: url = HoptoadNotifier.url - Net::HTTP.start(url.host, url.port) do |http| - headers = { - 'Content-type' => 'application/x-yaml', - 'Accept' => 'text/xml, application/xml' - } - http.read_timeout = 5 # seconds - http.open_timeout = 2 # seconds - 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 + 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 + log :error, "Timeout while contacting the Hoptoad server." + nil + end + + case response + when Net::HTTPSuccess then + log :info, "Success: #{response.class}", response + else + log :error, "Failure: #{response.class}", response 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| + + filtered = backtrace.to_a.map do |line| HoptoadNotifier.backtrace_filters.inject(line) do |line, proc| proc.call(line) end end + + filtered.compact end - + def clean_hoptoad_params params #:nodoc: params.each do |k, v| params[k] = "[FILTERED]" if HoptoadNotifier.params_filters.any? do |filter| @@ -264,7 +376,7 @@ module HoptoadNotifier end end end - + def clean_hoptoad_environment env #:nodoc: env.each do |k, v| env[k] = "[FILTERED]" if HoptoadNotifier.environment_filters.any? do |filter| @@ -273,17 +385,19 @@ module HoptoadNotifier end end - def clean_non_serializable_data(notice) #:nodoc: - notice.select{|k,v| serialzable?(v) }.inject({}) do |h, pair| - h[pair.first] = pair.last.is_a?(Hash) ? clean_non_serializable_data(pair.last) : pair.last - h + def clean_non_serializable_data(data) #:nodoc: + case data + when Hash + data.inject({}) do |result, (key, value)| + result.update(key => clean_non_serializable_data(value)) + end + when Fixnum, Array, String, Bignum + data + else + data.to_s end end - def serialzable?(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 @@ -301,3 +415,4 @@ module HoptoadNotifier include HoptoadNotifier::Catcher end end + vendor/plugins/hoptoad_notifier/lib/hoptoad_notifier.rb @@ -1,9 +1,7 @@ #!/usr/bin/env ruby -# This file must _not_ end in test.rb, or it will get run every time. require File.join(File.dirname(__FILE__), "..", "lib", "hoptoad_notifier") -#fail ARGV.inspect fail "Please supply an API Key as the first argument" if ARGV.empty? RAILS_ENV = "production" @@ -12,17 +10,19 @@ RAILS_ROOT = "./" host = ARGV[1] host ||= "hoptoadapp.com" -HoptoadNotifier.configure do |config| - config.host = host - config.api_key = ARGV.first -end +secure = (ARGV[2] == "secure") exception = begin - raise 'Testing hoptoad notifier. If you can see this, it works.' + raise "Testing hoptoad notifier with secure = #{secure}. If you can see this, it works." rescue => foo foo end -puts "Sending notification to project with key #{ARGV.first}" +HoptoadNotifier.configure do |config| + config.secure = secure + config.host = host + config.api_key = ARGV.first +end +puts "Sending #{secure ? "" : "in"}secure notification to project with key #{ARGV.first}" HoptoadNotifier.notify(exception) vendor/plugins/hoptoad_notifier/script/integration_test.rb @@ -1,21 +1,32 @@ namespace :hoptoad do + desc "Notify Hoptoad of a new deploy." + task :deploy => :environment do + require 'hoptoad_tasks' + HoptoadTasks.deploy(:rails_env => ENV['TO'], + :scm_revision => ENV['REVISION'], + :scm_repository => ENV['REPO'], + :local_username => ENV['USER']) + end + 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' - - request = ActionController::TestRequest.new({ - 'action' => 'verify', - 'controller' => 'hoptoad_verification', - '_method' => 'GET' - }) + require 'app/controllers/application' if File.exists?('app/controllers/application.rb') + request = ActionController::TestRequest.new response = ActionController::TestResponse.new class HoptoadTestingException < RuntimeError; end - unless ApplicationController.ancestors.include? HoptoadNotifier::Catcher - puts "You have not included HoptoadNotifier::Catcher in your ApplicationController!" + unless HoptoadNotifier.api_key + puts "Hoptoad needs an API key configured! Check the README to see how to add it." + exit + end + + in_controller = ApplicationController.included_modules.include? HoptoadNotifier::Catcher + in_base = ActionController::Base.included_modules.include? HoptoadNotifier::Catcher + if !in_controller || !in_base + puts "HoptoadNotifier::Catcher must be included inside your ApplicationController class." exit end vendor/plugins/hoptoad_notifier/tasks/hoptoad_notifier_tasks.rake vendor/plugins/hoptoad_notifier/.gitignore vendor/plugins/hoptoad_notifier/test/hoptoad_notifier_test.rb 168feff232570ed10366078cfcb1481824dab0b0 David Demaree david@practical.cc http://github.com/ddemaree/stoppayingattention/commit/76621d6e29b1ec89d39f44044ac4a70f9b79515b 76621d6e29b1ec89d39f44044ac4a70f9b79515b 2009-10-13T10:20:18-07:00 2009-10-13T10:20:18-07:00 Updated to latest hoptoad notifier c55d2c2cec9b2902c51e6b6154d25b8a255e188e David Demaree david@practical.cc