riscfuture-hoptoad_notifier 2.3.6

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,39 @@
+require 'hoptoad_notifier'
+require 'hoptoad_notifier/rails/controller_methods'
+require 'hoptoad_notifier/rails/action_controller_catcher'
+require 'hoptoad_notifier/rails/error_lookup'
+require 'hoptoad_notifier/rails/javascript_notifier'
+
+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)
+        ActionController::Base.send(:include, HoptoadNotifier::Rails::JavascriptNotifier)
+      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,60 @@
+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_filter_if_filtering(hoptoad_session_data),
+          :controller       => params[:controller],
+          :action           => params[:action],
+          :url              => hoptoad_request_url,
+          :cgi_data         => hoptoad_filter_if_filtering(request.env) }
+      end
+
+      def hoptoad_filter_if_filtering(hash)
+        return hash if ! hash.is_a?(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/rails/javascript_notifier.rb

@@ -0,0 +1,43 @@
+module HoptoadNotifier
+  module Rails
+    module JavascriptNotifier
+      def self.included(base) #:nodoc:
+        base.send(:after_filter, :insert_hoptoad_javascript_notifier)
+      end
+
+      private
+
+      def insert_hoptoad_javascript_notifier
+        return unless HoptoadNotifier.configuration.public?
+        return unless HoptoadNotifier.configuration.js_notifier
+
+        path = File.join(File.dirname(__FILE__), '..', '..', 'templates', 'javascript_notifier.erb')
+        host = HoptoadNotifier.configuration.host.dup
+        port = HoptoadNotifier.configuration.port
+        host << ":#{port}" unless [80, 443].include?(port)
+
+        options = {
+          :file          => path,
+          :layout        => false,
+          :use_full_path => false,
+          :locals        => {
+            :host        => host,
+            :secure      => HoptoadNotifier.configuration.secure,
+            :api_key     => HoptoadNotifier.configuration.api_key,
+            :environment => HoptoadNotifier.configuration.environment_name
+          }
+        }
+
+        if @template
+          javascript = @template.render(options)
+        else
+          javascript = render_to_string(options)
+        end
+
+        if response.body.respond_to?(:gsub)
+          response.body = response.body.gsub(/<(head)>/i, "<\\1>\n" + javascript)
+        end
+      end
+    end
+  end
+end

data/lib/hoptoad_notifier/rails3_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
+
+  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 Rails.root + '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.execute_if_updated
+    Rails.application.routes.draw do
+      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,29 @@
+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
+
+      if defined?(::ActionController::Base)
+        require 'hoptoad_notifier/rails/javascript_notifier'
+
+        ::ActionController::Base.send(:include, HoptoadNotifier::Rails::JavascriptNotifier)
+      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
+