hoptoad_notifier 2.1.0

data/lib/hoptoad_notifier/sender.rb

@@ -0,0 +1,63 @@
+module HoptoadNotifier
+  # Sends out the notice to Hoptoad
+  class Sender
+
+    NOTICES_URI = '/notifier_api/v2/notices/'.freeze
+
+    def initialize(options = {})
+      [:proxy_host, :proxy_port, :proxy_user, :proxy_pass, :protocol,
+        :host, :port, :secure, :http_open_timeout, :http_read_timeout].each do |option|
+        instance_variable_set("@#{option}", options[option])
+      end
+    end
+
+    # Sends the notice data off to Hoptoad for processing.
+    #
+    # @param [String] data The XML notice to be sent off
+    def send_to_hoptoad(data)
+      logger.debug { "Sending request to #{url.to_s}:\n#{data}" } if logger
+
+      http =
+        Net::HTTP::Proxy(proxy_host, proxy_port, proxy_user, proxy_pass).
+        new(url.host, url.port)
+
+      http.read_timeout = http_read_timeout
+      http.open_timeout = http_open_timeout
+      http.use_ssl      = secure
+
+      response = begin
+                   http.post(url.path, data, 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
+
+    private
+
+    attr_reader :proxy_host, :proxy_port, :proxy_user, :proxy_pass, :protocol,
+      :host, :port, :secure, :http_open_timeout, :http_read_timeout
+
+    def url
+      URI.parse("#{protocol}://#{host}:#{port}").merge(NOTICES_URI)
+    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 logger
+      HoptoadNotifier.logger
+    end
+
+  end
+end

data/lib/hoptoad_notifier/tasks.rb

@@ -0,0 +1,91 @@
+require 'hoptoad_notifier'
+
+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'],
+                        :api_key        => ENV['API_KEY'])
+  end
+
+  task :log_stdout do
+    require 'logger'
+    RAILS_DEFAULT_LOGGER = Logger.new(STDOUT)
+  end
+
+  desc "Verify your gem installation by sending a test exception to the hoptoad service"
+  task :test => ['hoptoad:log_stdout', :environment] do
+    RAILS_DEFAULT_LOGGER.level = Logger::DEBUG
+
+    require 'action_controller/test_process'
+    require 'app/controllers/application' if File.exists?('app/controllers/application.rb')
+
+    request = ActionController::TestRequest.new
+    response = ActionController::TestResponse.new
+
+    class HoptoadTestingException < RuntimeError; end
+
+    unless HoptoadNotifier.configuration.api_key
+      puts "Hoptoad needs an API key configured! Check the README to see how to add it."
+      exit
+    end
+
+    HoptoadNotifier.configuration.development_environments = []
+
+    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
+
+    puts "Configuration:"
+    HoptoadNotifier.configuration.to_hash.each do |key, value|
+      puts sprintf("%25s: %s", key.to_s, value.inspect.slice(0, 55))
+    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
+
+      # Ensure we actually have an action to go to.
+      def verify; end
+
+      def consider_all_requests_local
+        false
+      end
+
+      def local_request?
+        false
+      end
+
+      def exception_class
+        exception_name = ENV['EXCEPTION'] || "HoptoadTestingException"
+        Object.const_get(exception_name)
+      rescue
+        Object.const_set(exception_name, Class.new(Exception))
+      end
+
+      def logger
+        nil
+      end
+    end
+
+    puts 'Processing request.'
+    class HoptoadVerificationController < ApplicationController; end
+    HoptoadVerificationController.new.process(request, response)
+  end
+end
+

data/lib/hoptoad_notifier/version.rb

@@ -0,0 +1,3 @@
+module HoptoadNotifier
+  VERSION = "2.1.0".freeze
+end

data/lib/hoptoad_notifier.rb

@@ -0,0 +1,146 @@
+require 'net/http'
+require 'net/https'
+require 'rubygems'
+require 'active_support'
+require 'hoptoad_notifier/version'
+require 'hoptoad_notifier/configuration'
+require 'hoptoad_notifier/notice'
+require 'hoptoad_notifier/sender'
+require 'hoptoad_notifier/catcher'
+require 'hoptoad_notifier/backtrace'
+
+# Gem for applications to automatically post errors to the Hoptoad of their choice.
+module HoptoadNotifier
+
+  API_VERSION = "2.0"
+  LOG_PREFIX = "** [Hoptoad] "
+
+  HEADERS = {
+    'Content-type'             => 'text/xml',
+    'Accept'                   => 'text/xml, application/xml'
+  }
+
+  class << self
+    # The sender object is responsible for delivering formatted data to the Hoptoad server.
+    # Must respond to #send_to_hoptoad. See HoptoadNotifier::Sender.
+    attr_accessor :sender
+
+    # A Hoptoad configuration object. Must act like a hash and return sensible
+    # values for all Hoptoad configuration options. See HoptoadNotifier::Configuration.
+    attr_accessor :configuration
+
+    # Tell the log that the Notifier is good to go
+    def report_ready
+      write_verbose_log("Notifier #{VERSION} ready to catch errors")
+    end
+
+    # Prints out the environment info to the log for debugging help
+    def report_environment_info
+      write_verbose_log("Environment Info: #{environment_info}")
+    end
+
+    # Prints out the response body from Hoptoad for debugging help
+    def report_response_body(response)
+      write_verbose_log("Response from Hoptoad: \n#{response}")
+    end
+
+    # Returns the Ruby version, Rails version, and current Rails environment
+    def environment_info
+      info = "[Ruby: #{RUBY_VERSION}]"
+      info << " [Rails: #{::Rails::VERSION::STRING}]" if defined?(Rails)
+      info << " [Env: #{configuration.environment_name}]"
+    end
+
+    # Writes out the given message to the #logger
+    def write_verbose_log(message)
+      logger.info LOG_PREFIX + message if logger
+    end
+
+    # Look for the Rails logger currently defined
+    def logger
+      self.configuration.logger
+    end
+
+    # Call this method to modify defaults in your initializers.
+    #
+    # @example
+    #   HoptoadNotifier.configure do |config|
+    #     config.api_key = '1234567890abcdef'
+    #     config.secure  = false
+    #   end
+    def configure(silent = false)
+      self.configuration ||= Configuration.new
+      yield(configuration)
+      self.sender = Sender.new(configuration)
+      report_ready unless silent
+    end
+
+    # Sends an exception manually using this method, even when you are not in a controller.
+    #
+    # @param [Exception] exception The exception you want to notify Hoptoad about.
+    # @param [Hash] opts Data that will be sent to Hoptoad.
+    #
+    # @option opts [String] :api_key The API key for this project. The API key is a unique identifier that Hoptoad uses for identification.
+    # @option opts [String] :error_message The error returned by the exception (or the message you want to log).
+    # @option opts [String] :backtrace A backtrace, usually obtained with +caller+.
+    # @option opts [String] :request The controller's request object.
+    # @option opts [String] :session The contents of the user's session.
+    # @option opts [String] :environment ENV merged with the contents of the request's environment.
+    def notify(exception, opts = {})
+      send_notice(build_notice_for(exception, opts))
+    end
+
+    # Sends the notice unless it is one of the default ignored exceptions
+    # @see HoptoadNotifier.notify
+    def notify_or_ignore(exception, opts = {})
+      notice = build_notice_for(exception, opts)
+      send_notice(notice) unless notice.ignore?
+    end
+
+    def build_lookup_hash_for(exception, options = {})
+      notice = build_notice_for(exception, options)
+
+      result = {}
+      result[:action]           = notice.action      rescue nil
+      result[:component]        = notice.component   rescue nil
+      result[:error_class]      = notice.error_class if notice.error_class
+      result[:environment_name] = 'production'
+
+      unless notice.backtrace.lines.empty?
+        result[:file]        = notice.backtrace.lines.first.file
+        result[:line_number] = notice.backtrace.lines.first.number
+      end
+
+      result
+    end
+
+    private
+
+    def send_notice(notice)
+      if configuration.public?
+        sender.send_to_hoptoad(notice.to_xml)
+      end
+    end
+
+    def build_notice_for(exception, opts = {})
+      exception = unwrap_exception(exception)
+      if exception.respond_to?(:to_hash)
+        opts = opts.merge(exception)
+      else
+        opts = opts.merge(:exception => exception)
+      end
+      Notice.new(configuration.merge(opts))
+    end
+
+    def unwrap_exception(exception)
+      if exception.respond_to?(:original_exception)
+        exception.original_exception
+      elsif exception.respond_to?(:continued_exception)
+        exception.continued_exception
+      else
+        exception
+      end
+    end
+  end
+end
+

data/lib/hoptoad_tasks.rb

@@ -0,0 +1,37 @@
+require 'net/http'
+require 'uri'
+require 'active_support'
+
+# Capistrano tasks for notifying Hoptoad of deploys
+module HoptoadTasks
+
+  # Alerts Hoptoad of a deploy.
+  #
+  # @param [Hash] opts Data about the deploy that is set to Hoptoad
+  #
+  # @option opts [String] :rails_env Environment of the deploy (production, staging)
+  # @option opts [String] :scm_revision The given revision/sha that is being deployed
+  # @option opts [String] :scm_repository Address of your repository to help with code lookups
+  # @option opts [String] :local_username Who is deploying
+  def self.deploy(opts = {})
+    if HoptoadNotifier.configuration.api_key.blank?
+      puts "I don't seem to be configured with an API key.  Please check your configuration."
+      return false
+    end
+
+    if opts[:rails_env].blank?
+      puts "I don't know to which Rails environment you are deploying (use the TO=production option)."
+      return false
+    end
+
+    params = {'api_key' => opts.delete(:api_key) ||
+                             HoptoadNotifier.configuration.api_key}
+    opts.each {|k,v| params["deploy[#{k}]"] = v }
+
+    url = URI.parse("http://#{HoptoadNotifier.configuration.host || 'hoptoadapp.com'}/deploys.txt")
+    response = Net::HTTP.post_form(url, params)
+    puts response.body
+    return Net::HTTPSuccess === response
+  end
+end
+

data/rails/init.rb

@@ -0,0 +1 @@
+require 'hoptoad_notifier/rails'

data/tasks/hoptoad_notifier_tasks.rake

@@ -0,0 +1,89 @@
+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'],
+                        :api_key        => ENV['API_KEY'])
+  end
+
+  task :log_stdout do
+    require 'logger'
+    RAILS_DEFAULT_LOGGER = Logger.new(STDOUT)
+  end
+
+  desc "Verify your gem installation by sending a test exception to the hoptoad service"
+  task :test => ['hoptoad:log_stdout', :environment] do
+    RAILS_DEFAULT_LOGGER.level = Logger::DEBUG
+
+    require 'action_controller/test_process'
+    require 'app/controllers/application' if File.exists?('app/controllers/application.rb')
+
+    request = ActionController::TestRequest.new
+    response = ActionController::TestResponse.new
+
+    class HoptoadTestingException < RuntimeError; end
+
+    unless HoptoadNotifier.configuration.api_key
+      puts "Hoptoad needs an API key configured! Check the README to see how to add it."
+      exit
+    end
+
+    HoptoadNotifier.configuration.development_environments = []
+
+    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
+
+    puts "Configuration:"
+    HoptoadNotifier.configuration.to_hash.each do |key, value|
+      puts sprintf("%25s: %s", key.to_s, value.inspect.slice(0, 55))
+    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
+
+      # Ensure we actually have an action to go to.
+      def verify; end
+
+      def consider_all_requests_local
+        false
+      end
+
+      def local_request?
+        false
+      end
+
+      def exception_class
+        exception_name = ENV['EXCEPTION'] || "HoptoadTestingException"
+        Object.const_get(exception_name)
+      rescue
+        Object.const_set(exception_name, Class.new(Exception))
+      end
+
+      def logger
+        nil
+      end
+    end
+
+    puts 'Processing request.'
+    class HoptoadVerificationController < ApplicationController; end
+    HoptoadVerificationController.new.process(request, response)
+  end
+end
+

data/test/backtrace_test.rb

@@ -0,0 +1,118 @@
+require File.dirname(__FILE__) + '/helper'
+
+class BacktraceTest < Test::Unit::TestCase
+
+  should "parse a backtrace into lines" do
+    array = [
+      "app/models/user.rb:13:in `magic'",
+      "app/controllers/users_controller.rb:8:in `index'"
+    ]
+
+    backtrace = HoptoadNotifier::Backtrace.parse(array)
+
+    line = backtrace.lines.first
+    assert_equal '13', line.number
+    assert_equal 'app/models/user.rb', line.file
+    assert_equal 'magic', line.method
+
+    line = backtrace.lines.last
+    assert_equal '8', line.number
+    assert_equal 'app/controllers/users_controller.rb', line.file
+    assert_equal 'index', line.method
+  end
+
+  should "be equal with equal lines" do
+    one = build_backtrace_array
+    two = one.dup
+    assert_equal one, two
+
+    assert_equal HoptoadNotifier::Backtrace.parse(one), HoptoadNotifier::Backtrace.parse(two)
+  end
+
+  should "parse massive one-line exceptions into multiple lines" do
+    original_backtrace = HoptoadNotifier::Backtrace.
+      parse(["one:1:in `one'\n   two:2:in `two'\n      three:3:in `three`"])
+    expected_backtrace = HoptoadNotifier::Backtrace.
+      parse(["one:1:in `one'", "two:2:in `two'", "three:3:in `three`"])
+
+    assert_equal expected_backtrace, original_backtrace
+  end
+
+  context "with a project root" do
+    setup do
+      @project_root = '/some/path'
+      HoptoadNotifier.configure {|config| config.project_root = @project_root }
+    end
+
+    teardown do
+      reset_config
+    end
+
+    should "filter out the project root" do
+      backtrace_with_root = HoptoadNotifier::Backtrace.parse(
+        ["#{@project_root}/app/models/user.rb:7:in `latest'",
+         "#{@project_root}/app/controllers/users_controller.rb:13:in `index'",
+         "/lib/something.rb:41:in `open'"],
+        :filters => default_filters)
+      backtrace_without_root = HoptoadNotifier::Backtrace.parse(
+        ["[PROJECT_ROOT]/app/models/user.rb:7:in `latest'",
+         "[PROJECT_ROOT]/app/controllers/users_controller.rb:13:in `index'",
+         "/lib/something.rb:41:in `open'"])
+
+      assert_equal backtrace_without_root, backtrace_with_root
+    end
+  end
+
+  context "with a blank project root" do
+    setup do
+      HoptoadNotifier.configure {|config| config.project_root = '' }
+    end
+
+    teardown do
+      reset_config
+    end
+
+    should "not filter line numbers with respect to any project root" do
+      backtrace = ["/app/models/user.rb:7:in `latest'",
+                   "/app/controllers/users_controller.rb:13:in `index'",
+                   "/lib/something.rb:41:in `open'"]
+
+      backtrace_with_root =
+        HoptoadNotifier::Backtrace.parse(backtrace, :filters => default_filters)
+
+      backtrace_without_root =
+        HoptoadNotifier::Backtrace.parse(backtrace)
+
+      assert_equal backtrace_without_root, backtrace_with_root
+    end
+  end
+
+  should "remove notifier trace" do
+    inside_notifier  = ['lib/hoptoad_notifier.rb:13:in `voodoo`']
+    outside_notifier = ['users_controller:8:in `index`']
+
+    without_inside = HoptoadNotifier::Backtrace.parse(outside_notifier)
+    with_inside    = HoptoadNotifier::Backtrace.parse(inside_notifier + outside_notifier,
+                                                      :filters => default_filters)
+
+    assert_equal without_inside, with_inside
+  end
+
+  should "run filters on the backtrace" do
+    filters = [lambda { |line| line.sub('foo', 'bar') }]
+    input = HoptoadNotifier::Backtrace.parse(["foo:13:in `one'", "baz:14:in `two'"],
+                                             :filters => filters)
+    expected = HoptoadNotifier::Backtrace.parse(["bar:13:in `one'", "baz:14:in `two'"])
+    assert_equal expected, input
+  end
+
+  def build_backtrace_array
+    ["app/models/user.rb:13:in `magic'",
+      "app/controllers/users_controller.rb:8:in `index'"]
+  end
+
+  def default_filters
+    HoptoadNotifier::Configuration::DEFAULT_BACKTRACE_FILTERS
+  end
+
+end