jordan-brough-hoptoad_notifier 2.3.0

data/lib/hoptoad_notifier/rack.rb

@@ -0,0 +1,40 @@
+module HoptoadNotifier
+  # Middleware for Rack applications. Any errors raised by the upstream
+  # application will be delivered to Hoptoad and re-raised.
+  #
+  # Synopsis:
+  #
+  #   require 'rack'
+  #   require 'hoptoad_notifier'
+  #
+  #   HoptoadNotifier.configure do |config|
+  #     config.api_key = 'my_api_key'
+  #   end
+  #
+  #   app = Rack::Builder.app do
+  #     use HoptoadNotifier::Rack
+  #     run lambda { |env| raise "Rack down" }
+  #   end
+  #
+  # Use a standard HoptoadNotifier.configure call to configure your api key.
+  class Rack
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      begin
+        response = @app.call(env)
+      rescue Exception => raised
+        HoptoadNotifier.notify_or_ignore(raised, :rack_env => env)
+        raise
+      end
+
+      if env['rack.exception']
+        HoptoadNotifier.notify_or_ignore(env['rack.exception'], :rack_env => env)
+      end
+
+      response
+    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/rails/action_controller_catcher.rb

@@ -0,0 +1,29 @@
+module HoptoadNotifier
+  module Rails
+    module ActionControllerCatcher
+
+      # Sets up an alias chain to catch exceptions when Rails does
+      def self.included(base) #:nodoc:
+        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
+
+      private
+
+      # 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)
+        unless hoptoad_ignore_user_agent?
+          HoptoadNotifier.notify_or_ignore(exception, hoptoad_request_data)
+        end
+        rescue_action_in_public_without_hoptoad(exception)
+      end
+
+      def hoptoad_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.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
+      end
+    end
+  end
+end

data/lib/hoptoad_notifier/rails/controller_methods.rb

@@ -0,0 +1,63 @@
+module HoptoadNotifier
+  module Rails
+    module ControllerMethods
+      private
+
+      # 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)
+        unless consider_all_requests_local || local_request?
+          HoptoadNotifier.notify(hash_or_exception, hoptoad_request_data)
+        end
+      end
+
+      def hoptoad_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.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
+      end
+
+      def hoptoad_request_data
+        { :parameters       => hoptoad_filter_if_filtering(params.to_hash),
+          :session_data     => hoptoad_session_data,
+          :controller       => params[:controller],
+          :action           => params[:action],
+          :url              => hoptoad_request_url,
+          :cgi_data         => hoptoad_filter_if_filtering(request.env).merge(hoptoad_extra_cgi_data) }
+      end
+
+      # override in your controllers to provide extra hoptoad cgi data
+      def hoptoad_extra_cgi_data
+        {}
+      end
+
+      def hoptoad_filter_if_filtering(hash)
+        if respond_to?(:filter_parameters)
+          filter_parameters(hash) rescue hash
+        else
+          hash
+        end
+      end
+
+      def hoptoad_session_data
+        if session.respond_to?(:to_hash)
+          session.to_hash
+        else
+          session.data
+        end
+      end
+
+      def hoptoad_request_url
+        url = "#{request.protocol}#{request.host}"
+
+        unless [80, 443].include?(request.port)
+          url << ":#{request.port}"
+        end
+
+        url << request.request_uri
+        url
+      end
+    end
+  end
+end
+

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/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
+