square-hoptoad_notifier 2.4.8

data/lib/hoptoad_notifier/rails/controller_methods.rb

@@ -0,0 +1,68 @@
+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 hoptoad_local_request?
+          HoptoadNotifier.notify(hash_or_exception, hoptoad_request_data)
+        end
+      end
+      
+      def hoptoad_local_request?
+        if defined?(::Rails.application.config)
+          ::Rails.application.config.consider_all_requests_local || request.local?
+        else
+          consider_all_requests_local || local_request?
+        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,42 @@
+module HoptoadNotifier
+  module Rails
+    module JavascriptNotifier
+      def self.included(base) #:nodoc:
+        base.send :helper_method, :hoptoad_javascript_notifier
+      end
+
+      private
+
+      def hoptoad_javascript_notifier
+        return unless HoptoadNotifier.configuration.public?
+
+        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,
+            :api_key         => HoptoadNotifier.configuration.api_key,
+            :environment     => HoptoadNotifier.configuration.environment_name,
+            :action_name     => action_name,
+            :controller_name => controller_name,
+            :url             => request.url
+          }
+        }
+
+        if @template
+          @template.render(options)
+        else
+          render_to_string(options)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/hoptoad_notifier/rails3_tasks.rb

@@ -0,0 +1,82 @@
+require 'hoptoad_notifier'
+require File.join(File.dirname(__FILE__), 'shared_tasks')
+
+namespace :hoptoad do
+  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.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,32 @@
+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"
+      app.config.middleware.insert 0, "HoptoadNotifier::UserInformer"
+    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'
+        require 'hoptoad_notifier/rails/controller_methods'
+        
+        ::ActionController::Base.send(:include, HoptoadNotifier::Rails::ControllerMethods)
+        ::ActionController::Base.send(:include, HoptoadNotifier::Rails::JavascriptNotifier)
+      end
+    end
+  end
+end

data/lib/hoptoad_notifier/sender.rb

@@ -0,0 +1,83 @@
+module HoptoadNotifier
+  # Sends out the notice to Hoptoad
+  class Sender
+
+    NOTICES_URI = '/notifier_api/v2/notices/'.freeze
+    HTTP_ERRORS = [Timeout::Error,
+                   Errno::EINVAL,
+                   Errno::ECONNRESET,
+                   EOFError,
+                   Net::HTTPBadResponse,
+                   Net::HTTPHeaderSyntaxError,
+                   Net::ProtocolError,
+                   Errno::ECONNREFUSED].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
+
+      if secure
+        http.use_ssl     = true
+        http.ca_file     = OpenSSL::X509::DEFAULT_CERT_FILE
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      else
+        http.use_ssl     = false
+      end
+
+      response = begin
+                   http.post(url.path, data, HEADERS)
+                 rescue *HTTP_ERRORS => 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
+
+      if response && response.respond_to?(:body)
+        error_id = response.body.match(%r{<error-id[^>]*>(.*?)</error-id>})
+        error_id[1] if error_id
+      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/shared_tasks.rb

@@ -0,0 +1,29 @@
+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
+
+  namespace :heroku do
+    desc "Install Heroku deploy notifications addon"
+    task :add_deploy_notification => [:environment] do
+      heroku_api_key = `heroku console 'puts ENV[%{HOPTOAD_API_KEY}]' | head -n 1`.strip
+      heroku_rails_env = `heroku console 'puts RAILS_ENV' | head -n 1`.strip
+
+      command = %Q(heroku addons:add deployhooks:http url="http://hoptoadapp.com/deploys.txt?deploy[rails_env]=#{heroku_rails_env}&api_key=#{heroku_api_key}")
+
+      puts "\nRunning:\n#{command}\n"
+      puts `#{command}`
+    end
+  end
+end

data/lib/hoptoad_notifier/tasks.rb

@@ -0,0 +1,83 @@
+require 'hoptoad_notifier'
+require File.join(File.dirname(__FILE__), 'shared_tasks')
+
+namespace :hoptoad do
+  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("REQUEST_URI" => "/hoptoad_verification_controller")
+    response = ActionController::TestResponse.new
+    HoptoadVerificationController.new.process(request, response)
+  end
+end
+