hatless-hoptoad_notifier 2.2.6

data/lib/hoptoad_notifier/rails/error_lookup.rb

@@ -0,0 +1,33 @@
+module HoptoadNotifier
+  module Rails
+    module ErrorLookup
+
+      # Sets up an alias chain to catch exceptions when Rails does
+      def self.included(base) #:nodoc:
+        base.send(:alias_method, :rescue_action_locally_without_hoptoad, :rescue_action_locally)
+        base.send(:alias_method, :rescue_action_locally, :rescue_action_locally_with_hoptoad)
+      end
+
+      private
+
+      def rescue_action_locally_with_hoptoad(exception)
+        result = rescue_action_locally_without_hoptoad(exception)
+
+        if HoptoadNotifier.configuration.development_lookup
+          path   = File.join(File.dirname(__FILE__), '..', '..', 'templates', 'rescue.erb')
+          notice = HoptoadNotifier.build_lookup_hash_for(exception, hoptoad_request_data)
+
+          result << @template.render(
+            :file          => path,
+            :use_full_path => false,
+            :locals        => { :host    => HoptoadNotifier.configuration.host,
+                                :api_key => HoptoadNotifier.configuration.api_key,
+                                :notice  => notice })
+        end
+
+        result
+      end
+    end
+  end
+end
+

data/lib/hoptoad_notifier/rails.rb

@@ -0,0 +1,37 @@
+require 'hoptoad_notifier'
+require 'hoptoad_notifier/rails/controller_methods'
+require 'hoptoad_notifier/rails/action_controller_catcher'
+require 'hoptoad_notifier/rails/error_lookup'
+
+module HoptoadNotifier
+  module Rails
+    def self.initialize
+      if defined?(ActionController::Base)
+        ActionController::Base.send(:include, HoptoadNotifier::Rails::ActionControllerCatcher)
+        ActionController::Base.send(:include, HoptoadNotifier::Rails::ErrorLookup)
+        ActionController::Base.send(:include, HoptoadNotifier::Rails::ControllerMethods)
+      end
+
+      rails_logger = if defined?(::Rails.logger)
+                       ::Rails.logger
+                     elsif defined?(RAILS_DEFAULT_LOGGER)
+                       RAILS_DEFAULT_LOGGER
+                     end
+
+      if defined?(::Rails.configuration) && ::Rails.configuration.respond_to?(:middleware)
+        ::Rails.configuration.middleware.insert_after 'ActionController::Failsafe',
+                                                      HoptoadNotifier::Rack
+      end
+
+      HoptoadNotifier.configure(true) do |config|
+        config.logger = rails_logger
+        config.environment_name = RAILS_ENV  if defined?(RAILS_ENV)
+        config.project_root     = RAILS_ROOT if defined?(RAILS_ROOT)
+        config.framework        = "Rails: #{::Rails::VERSION::STRING}" if defined?(::Rails::VERSION)
+      end
+    end
+  end
+end
+
+HoptoadNotifier::Rails.initialize
+

data/lib/hoptoad_notifier/rails3_tasks.rb

@@ -0,0 +1,90 @@
+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
+
+  desc "Verify your gem installation by sending a test exception to the hoptoad service"
+  task :test => [:environment] do
+    Rails.logger = Logger.new(STDOUT)
+    Rails.logger.level = Logger::DEBUG
+    HoptoadNotifier.configure(true) do |config|
+      config.logger = Rails.logger
+    end
+
+    require 'app/controllers/application_controller'
+
+    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 = []
+
+    puts "Configuration:"
+    HoptoadNotifier.configuration.to_hash.each do |key, value|
+      puts sprintf("%25s: %s", key.to_s, value.inspect.slice(0, 55))
+    end
+
+    unless defined?(ApplicationController)
+      puts "No ApplicationController found"
+      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
+
+      # 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
+    class HoptoadVerificationController < ApplicationController; end
+
+    Rails::Application.routes_reloader.reload_if_changed
+    Rails::Application.routes.draw do |map|
+      match 'verify' => 'application#verify', :as => 'verify'
+    end
+
+    puts 'Processing request.'
+    env = Rack::MockRequest.env_for("/verify")
+    Rails::Application.call(env)
+  end
+end
+

data/lib/hoptoad_notifier/railtie.rb

@@ -0,0 +1,23 @@
+require 'hoptoad_notifier'
+require 'rails'
+
+module HoptoadNotifier
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      require "hoptoad_notifier/rails3_tasks"
+    end
+
+    initializer "hoptoad.use_rack_middleware" do |app|
+      app.config.middleware.use "HoptoadNotifier::Rack"
+    end
+
+    config.after_initialize do
+      HoptoadNotifier.configure(true) do |config|
+        config.logger           = Rails.logger
+        config.environment_name = Rails.env
+        config.project_root     = Rails.root
+        config.framework        = "Rails: #{::Rails::VERSION::STRING}"
+      end
+    end
+  end
+end

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,97 @@
+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'
+
+    Dir["app/controllers/application*.rb"].each { |file| require(file) }
+
+    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 = []
+
+    catcher = HoptoadNotifier::Rails::ActionControllerCatcher
+    in_controller = ApplicationController.included_modules.include?(catcher)
+    in_base = ActionController::Base.included_modules.include?(catcher)
+    if !in_controller || !in_base
+      puts "Rails initialization did not occur"
+      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
+
+    unless defined?(ApplicationController)
+      puts "No ApplicationController found"
+      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
+
+      # 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
+    class HoptoadVerificationController < ApplicationController; end
+
+    puts 'Processing request.'
+    request = ActionController::TestRequest.new
+    response = ActionController::TestResponse.new
+    HoptoadVerificationController.new.process(request, response)
+  end
+end
+

data/lib/hoptoad_notifier/version.rb

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

data/lib/hoptoad_notifier.rb

@@ -0,0 +1,148 @@
+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/backtrace'
+require 'hoptoad_notifier/rack'
+
+require 'hoptoad_notifier/railtie' if defined?(Rails::Railtie)
+
+# 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 << " [#{configuration.framework}]"
+      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,40 @@
+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::Proxy(HoptoadNotifier.configuration.proxy_host,
+                                HoptoadNotifier.configuration.proxy_port,
+                                HoptoadNotifier.configuration.proxy_user,
+                                HoptoadNotifier.configuration.proxy_pass).post_form(url, params)
+    puts response.body
+    return Net::HTTPSuccess === response
+  end
+end
+

data/lib/rails/generators/hoptoad/hoptoad_generator.rb

@@ -0,0 +1,64 @@
+require 'rails/generators'
+
+class HoptoadGenerator < Rails::Generators::Base
+
+  class_option :api_key, :aliases => "-k", :type => :string, :desc => "Your Hoptoad API key"
+
+  def self.source_root
+    @_hoptoad_source_root ||= File.expand_path("../../../../../generators/hoptoad/templates", __FILE__)
+  end
+
+  def install
+    ensure_api_key_was_configured
+    ensure_plugin_is_not_present
+    append_capistrano_hook
+    generate_initializer unless api_key_configured?
+    test_hoptoad
+  end
+
+  private
+
+  def ensure_api_key_was_configured
+    if !options[:api_key] && !api_key_configured?
+      puts "Must pass --api-key or create config/initializers/hoptoad.rb"
+      exit
+    end
+  end
+
+  def ensure_plugin_is_not_present
+    if plugin_is_present?
+      puts "You must first remove the hoptoad_notifier plugin. Please run: script/plugin remove hoptoad_notifier"
+      exit
+    end
+  end
+
+  def append_capistrano_hook
+    if File.exists?('config/deploy.rb') && File.exists?('Capfile')
+      append_file('config/deploy.rb', <<-HOOK)
+
+        require 'config/boot'
+        require 'hoptoad_notifier/capistrano'
+      HOOK
+    end
+  end
+
+  def api_key
+    options[:api_key]
+  end
+
+  def generate_initializer
+    template 'initializer.rb', 'config/initializers/hoptoad.rb'
+  end
+
+  def api_key_configured?
+    File.exists?('config/initializers/hoptoad.rb')
+  end
+
+  def test_hoptoad
+    puts run("rake hoptoad:test --trace")
+  end
+
+  def plugin_is_present?
+    File.exists?('vendor/plugins/hoptoad_notifier')
+  end
+end

data/lib/templates/rescue.erb

@@ -0,0 +1,91 @@
+<script type="text/javascript">
+var Hoptoad = {
+  host    : <%= host.to_json %>,
+  api_key : <%= api_key.to_json %>,
+  notice  : <%= notice.to_json %>,
+  message : 'This error exists in production!',
+
+  initialize: function() {
+    if (this.initialized) {
+      return;
+    } else {
+      this.initialized = true;
+    }
+
+    var data = [];
+
+    for (var key in this.notice) {
+      data[data.length] = 'notice[' + key + ']=' + this.notice[key];
+    }
+
+    data[data.length] = 'notice[api_key]=' + this.api_key;
+    data[data.length] = 'callback=Hoptoad.onSuccess';
+    data[data.length] = '_=' + (new Date()).getTime();
+
+    var head = document.getElementsByTagName('head')[0];
+    var done = false;
+
+    var
+    script = document.createElement('script');
+    script.src  = 'http://' + this.host + '/notices_api/v1/notices/exist?' +
+                  data.join('&');
+    script.type = 'text/javascript';
+    script.onload = script.onreadystatechange = function(){
+      if (!done && (!this.readyState ||
+          this.readyState == 'loaded' || this.readyState == 'complete')) {
+
+        done = true;
+
+        // Handle memory leak in IE. (via jQuery)
+        script.onload = script.onreadystatechange = null;
+        head.removeChild(script);
+      }
+    };
+
+    head.appendChild(script);
+  },
+
+  onSuccess: function(error) {
+    var body    = document.getElementsByTagName('body')[0];
+    var text    = document.createTextNode(this.message);
+    var element = document.createElement('a');
+
+    element.id   = 'hoptoad';
+    element.href = 'http://' + error.subdomain + '.' + this.host +
+                   '/projects/' + error.project_id + '/errors/' + error.id;
+    element.appendChild(text);
+
+    body.insertBefore(element, body.firstChild);
+
+    var h1      = document.getElementsByTagName('h1')[0];
+    var pre     = document.getElementsByTagName('pre')[0];
+    var wrapper = document.createElement('div');
+
+    wrapper.id = 'wrapper';
+    wrapper.appendChild(h1);
+    wrapper.appendChild(pre);
+
+    body.insertBefore(wrapper, body.children[1]);
+  }
+};
+
+window.onload = function() {
+  Hoptoad.initialize.apply(Hoptoad);
+};
+</script>
+
+<style type="text/css">
+#hoptoad {
+  background: #FFF url(http://hoptoadapp.com/images/fell-off-the-toad.gif) no-repeat top right;
+  color: #F00;
+  padding: 45px 101px 45px 12px;
+  font-size: 14px;
+  font-weight: bold;
+  display: block;
+  float: right;
+}
+
+#wrapper {
+  padding-right: 360px;
+}
+</style>