honeybadger 1.0.0

data/lib/honeybadger/rack.rb

@@ -0,0 +1,55 @@
+module Honeybadger
+  # Middleware for Rack applications. Any errors raised by the upstream
+  # application will be delivered to Honeybadger and re-raised.
+  #
+  # Synopsis:
+  #
+  #   require 'rack'
+  #   require 'honeybadger'
+  #
+  #   Honeybadger.configure do |config|
+  #     config.api_key = 'my_api_key'
+  #   end
+  #
+  #   app = Rack::Builder.app do
+  #     run lambda { |env| raise "Rack down" }
+  #   end
+  #
+  #   use Honeybadger::Rack
+  #   run app
+  #
+  # Use a standard Honeybadger.configure call to configure your api key.
+  class Rack
+    def initialize(app)
+      @app = app
+      Honeybadger.configuration.logger ||= Logger.new STDOUT
+    end
+
+    def ignored_user_agent?(env)
+      true if Honeybadger.
+        configuration.
+        ignore_user_agent.
+        flatten.
+        any? { |ua| ua === env['HTTP_USER_AGENT'] }
+    end
+
+    def notify_honeybadger(exception,env)
+      Honeybadger.notify_or_ignore(exception,:rack_env => env) unless ignored_user_agent?(env)
+    end
+
+    def call(env)
+      begin
+        response = @app.call(env)
+      rescue Exception => raised
+        env['honeybadger.error_id'] = notify_honeybadger(raised,env)
+        raise
+      end
+
+      if env['rack.exception']
+        env['honeybadger.error_id'] = notify_honeybadger(env['rack.exception'],env)
+      end
+
+      response
+    end
+  end
+end

data/lib/honeybadger/rails.rb

@@ -0,0 +1,34 @@
+require 'honeybadger'
+require 'honeybadger/rails/controller_methods'
+require 'honeybadger/rails/action_controller_catcher'
+
+module Honeybadger
+  module Rails
+    def self.initialize
+      if defined?(ActionController::Base)
+        ActionController::Base.send(:include, Honeybadger::Rails::ActionControllerCatcher)
+        ActionController::Base.send(:include, Honeybadger::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',
+                                                      Honeybadger::Rack
+      end
+
+      Honeybadger.configure(true) do |config|
+        config.logger           = rails_logger
+        config.environment_name = defined?(::Rails.env) && ::Rails.env || defined?(RAILS_ENV) && RAILS_ENV
+        config.project_root     = defined?(::Rails.root) && ::Rails.root || defined?(RAILS_ROOT) && RAILS_ROOT
+        config.framework        = defined?(::Rails.version) && "Rails: #{::Rails.version}" || defined?(::Rails::VERSION::STRING) && "Rails: #{::Rails::VERSION::STRING}"
+      end
+    end
+  end
+end
+
+Honeybadger::Rails.initialize

data/lib/honeybadger/rails/action_controller_catcher.rb

@@ -0,0 +1,30 @@
+module Honeybadger
+  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_honeybadger, :rescue_action_in_public)
+        base.send(:alias_method, :rescue_action_in_public, :rescue_action_in_public_with_honeybadger)
+      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_honeybadger(exception)
+        unless honeybadger_ignore_user_agent?
+          error_id = Honeybadger.notify_or_ignore(exception, honeybadger_request_data)
+          request.env['honeybadger.error_id'] = error_id
+        end
+        rescue_action_in_public_without_honeybadger(exception)
+      end
+
+      def honeybadger_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"]
+        Honeybadger.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
+      end
+    end
+  end
+end

data/lib/honeybadger/rails/controller_methods.rb

@@ -0,0 +1,69 @@
+module Honeybadger
+  module Rails
+    module ControllerMethods
+      def honeybadger_request_data
+        { :parameters       => honeybadger_filter_if_filtering(params.to_hash),
+          :session_data     => honeybadger_filter_if_filtering(honeybadger_session_data),
+          :controller       => params[:controller],
+          :action           => params[:action],
+          :url              => honeybadger_request_url,
+          :cgi_data         => honeybadger_filter_if_filtering(request.env) }
+      end
+
+      private
+
+      # This method should be used for sending manual notifications while you are still
+      # inside the controller. Otherwise it works like Honeybadger.notify.
+      def notify_honeybadger(hash_or_exception)
+        unless honeybadger_local_request?
+          Honeybadger.notify(hash_or_exception, honeybadger_request_data)
+        end
+      end
+
+      def honeybadger_local_request?
+        if defined?(::Rails.application.config)
+          ::Rails.application.config.consider_all_requests_local || (request.local? && (!request.env["HTTP_X_FORWARDED_FOR"]))
+        else
+          consider_all_requests_local || (local_request? && (!request.env["HTTP_X_FORWARDED_FOR"]))
+        end
+      end
+
+      def honeybadger_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"]
+        Honeybadger.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
+      end
+
+      def honeybadger_filter_if_filtering(hash)
+        return hash if ! hash.is_a?(Hash)
+
+        if respond_to?(:filter_parameters) # Rails 2
+          filter_parameters(hash)
+        elsif defined?(ActionDispatch::Http::ParameterFilter) # Rails 3
+          ActionDispatch::Http::ParameterFilter.new(::Rails.application.config.filter_parameters).filter(hash)
+        else
+          hash
+        end rescue hash
+      end
+
+      def honeybadger_session_data
+        if session.respond_to?(:to_hash)
+          session.to_hash
+        else
+          session.data
+        end
+      end
+
+      def honeybadger_request_url
+        url = "#{request.protocol}#{request.host}"
+
+        unless [80, 443].include?(request.port)
+          url << ":#{request.port}"
+        end
+
+        url << request.fullpath
+        url
+      end
+    end
+  end
+end

data/lib/honeybadger/rails/middleware/exceptions_catcher.rb

@@ -0,0 +1,29 @@
+module Honeybadger
+  module Rails
+    module Middleware
+      module ExceptionsCatcher
+        def self.included(base)
+          base.send(:alias_method_chain,:render_exception,:honeybadger)
+        end
+
+        def skip_user_agent?(env)
+          user_agent = env["HTTP_USER_AGENT"]
+          ::Honeybadger.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
+        rescue
+          false
+        end
+
+        def render_exception_with_honeybadger(env,exception)
+          controller = env['action_controller.instance']
+          env['honeybadger.error_id'] = Honeybadger.
+            notify_or_ignore(exception,
+                   (controller.try(:honeybadger_request_data) || {:rack_env => env})) unless skip_user_agent?(env)
+          if defined?(controller.rescue_action_in_public_without_honeybadger)
+            controller.rescue_action_in_public_without_honeybadger(exception)
+          end
+          render_exception_without_honeybadger(env,exception)
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/rails3_tasks.rb

@@ -0,0 +1,84 @@
+require 'honeybadger'
+require File.join(File.dirname(__FILE__), 'shared_tasks')
+
+namespace :honeybadger do
+  desc "Verify your gem installation by sending a test exception to the honeybadger service"
+  task :test => [:environment] do
+    Rails.logger = defined?(ActiveSupport::TaggedLogging) ?
+      ActiveSupport::TaggedLogging.new(Logger.new(STDOUT)) :
+      Logger.new(STDOUT)
+
+    Rails.logger.level = Logger::DEBUG
+    Honeybadger.configure(true) do |config|
+      config.logger = Rails.logger
+    end
+
+    require './app/controllers/application_controller'
+
+    class HoneybadgerTestingException < RuntimeError; end
+
+    unless Honeybadger.configuration.api_key
+      puts "Honeybadger needs an API key configured! Check the README to see how to add it."
+      exit
+    end
+
+    Honeybadger.configuration.development_environments = []
+
+    puts "Configuration:"
+    Honeybadger.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_honeybadger
+      def test_honeybadger
+        puts "Raising '#{exception_class.name}' to simulate application failure."
+        raise exception_class.new, 'Testing honeybadger via "rake honeybadger: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'] || "HoneybadgerTestingException"
+        Object.const_get(exception_name)
+      rescue
+        Object.const_set(exception_name, Class.new(Exception))
+      end
+
+      def logger
+        nil
+      end
+    end
+    class HoneybadgerVerificationController < 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/honeybadger/railtie.rb

@@ -0,0 +1,45 @@
+require 'honeybadger'
+require 'rails'
+
+module Honeybadger
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      require 'honeybadger/rake_handler'
+      require "honeybadger/rails3_tasks"
+    end
+
+    initializer "honeybadger.use_rack_middleware" do |app|
+      app.config.middleware.insert 0, "Honeybadger::Rack"
+    end
+
+    config.after_initialize do
+      Honeybadger.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
+
+      ActiveSupport.on_load(:action_controller) do
+        # Lazily load action_controller methods
+        #
+        require 'honeybadger/rails/controller_methods'
+
+        include Honeybadger::Rails::ControllerMethods
+      end
+
+      if defined?(::ActionDispatch::DebugExceptions)
+        # We should catch the exceptions in ActionDispatch::DebugExceptions in Rails 3.2.x.
+        #
+        require 'honeybadger/rails/middleware/exceptions_catcher'
+        ::ActionDispatch::DebugExceptions.send(:include,Honeybadger::Rails::Middleware::ExceptionsCatcher)
+      elsif defined?(::ActionDispatch::ShowExceptions)
+        # ActionDispatch::DebugExceptions is not defined in Rails 3.0.x and 3.1.x so
+        # catch the exceptions in ShowExceptions.
+        #
+        require 'honeybadger/rails/middleware/exceptions_catcher'
+        ::ActionDispatch::ShowExceptions.send(:include,Honeybadger::Rails::Middleware::ExceptionsCatcher)
+      end
+    end
+  end
+end

data/lib/honeybadger/rake_handler.rb

@@ -0,0 +1,65 @@
+# Patch Rake::Application to handle errors with Honeybadger
+module Honeybadger::RakeHandler
+  def self.included(klass)
+    klass.class_eval do
+      include Rake087Methods unless defined?(Rake::VERSION) && Rake::VERSION >= '0.9.0'
+      alias_method :display_error_message_without_honeybadger, :display_error_message
+      alias_method :display_error_message, :display_error_message_with_honeybadger
+    end
+  end
+
+  def display_error_message_with_honeybadger(ex)
+    if Honeybadger.sender && Honeybadger.configuration &&
+      (Honeybadger.configuration.rescue_rake_exceptions || 
+       (Honeybadger.configuration.rescue_rake_exceptions===nil && !self.tty_output?))
+
+      Honeybadger.notify_or_ignore(ex, :component => reconstruct_command_line, :cgi_data => ENV)
+    end
+
+    display_error_message_without_honeybadger(ex)
+  end
+
+  def reconstruct_command_line
+    "rake #{ARGV.join( ' ' )}"
+  end
+
+  # This module brings Rake 0.8.7 error handling to 0.9.0 standards
+  module Rake087Methods
+    # Method taken from Rake 0.9.0 source
+    #
+    # Provide standard exception handling for the given block.
+    def standard_exception_handling
+      begin
+        yield
+      rescue SystemExit => ex
+        # Exit silently with current status
+        raise
+      rescue OptionParser::InvalidOption => ex
+        $stderr.puts ex.message
+        exit(false)
+      rescue Exception => ex
+        # Exit with error message
+        display_error_message(ex)
+        exit(false)
+      end
+    end
+
+    # Method extracted from Rake 0.8.7 source
+    def display_error_message(ex)
+      $stderr.puts "#{name} aborted!"
+      $stderr.puts ex.message
+      if options.trace
+        $stderr.puts ex.backtrace.join("\n")
+      else
+        $stderr.puts ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || ""
+        $stderr.puts "(See full trace by running task with --trace)"
+      end
+    end
+  end
+end
+
+Rake.application.instance_eval do
+  class << self
+    include Honeybadger::RakeHandler
+  end
+end

data/lib/honeybadger/sender.rb

@@ -0,0 +1,120 @@
+module Honeybadger
+  class Sender
+    NOTICES_URI = '/v1/notices/'.freeze
+    HTTP_ERRORS = [Timeout::Error,
+                   Errno::EINVAL,
+                   Errno::ECONNRESET,
+                   EOFError,
+                   Net::HTTPBadResponse,
+                   Net::HTTPHeaderSyntaxError,
+                   Net::ProtocolError,
+                   Errno::ECONNREFUSED].freeze
+
+    def initialize(options = {})
+      [ :api_key,
+        :proxy_host,
+        :proxy_port,
+        :proxy_user,
+        :proxy_pass,
+        :protocol,
+        :host,
+        :port,
+        :secure,
+        :use_system_ssl_cert_chain,
+        :http_open_timeout,
+        :http_read_timeout
+      ].each do |option|
+        instance_variable_set("@#{option}", options[option])
+      end
+    end
+
+    # Public: Sends the notice data off to Honeybadger for processing.
+    #
+    # data - The JSON notice to be sent off
+    #
+    # Returns nothing
+    def send_to_honeybadger(data)
+      http     = setup_http_connection
+      headers  = HEADERS
+
+      headers.merge!({ 'X-API-Key' => api_key}) if api_key.present?
+
+      response = begin
+                   http.post(url.path, data, headers)
+                 rescue *HTTP_ERRORS => e
+                   log(:error, "Unable to contact the Honeybadger server. HTTP Error=#{e}")
+                   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)
+        notice = JSON.parse(response.body)
+        error_id = notice['id']
+      end
+    rescue => e
+      log(:error, "[Honeybadger::Sender#send_to_honeybadger] Cannot send notification. Error: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}")
+      nil
+    end
+
+    attr_reader :api_key,
+      :proxy_host,
+      :proxy_port,
+      :proxy_user,
+      :proxy_pass,
+      :protocol,
+      :host,
+      :port,
+      :secure,
+      :use_system_ssl_cert_chain,
+      :http_open_timeout,
+      :http_read_timeout
+
+    alias_method :secure?, :secure
+    alias_method :use_system_ssl_cert_chain?, :use_system_ssl_cert_chain
+
+    private
+
+    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
+      Honeybadger.report_environment_info
+      Honeybadger.report_response_body(response.body) if response && response.respond_to?(:body)
+    end
+
+    def logger
+      Honeybadger.logger
+    end
+
+    def setup_http_connection
+      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      = Honeybadger.configuration.ca_bundle_path
+        http.verify_mode  = OpenSSL::SSL::VERIFY_PEER
+      else
+        http.use_ssl     = false
+      end
+
+      http
+    rescue => e
+      log(:error, "[Honeybadger::Sender#setup_http_connection] Failure initializing the HTTP connection.\nError: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}")
+      raise e
+    end
+  end
+end