honeybadger 1.3.1 → 1.4.0

data/lib/honeybadger/backtrace.rb

@@ -4,7 +4,7 @@ module Honeybadger
 
     # Public: Handles backtrace parsing line by line
     class Line
-      # regexp (optionnally allowing leading X: for windows support)
+      # regexp (optionally allowing leading X: for windows support)
       INPUT_FORMAT = %r{^((?:[a-zA-Z]:)?[^:]+):(\d+)(?::in `([^']+)')?$}.freeze
 
       # Public: The file portion of the line (such as app/models/user.rb)
@@ -62,6 +62,11 @@ module Honeybadger
         "<Line:#{to_s}>"
       end
 
+      # Public: Determines if this line is part of the application trace or not
+      def application?
+        (filtered_file =~ /^\[PROJECT_ROOT\]/i) && !(filtered_file =~ /^\[PROJECT_ROOT\]\/vendor/i)
+      end
+
       # Public: An excerpt from the source file, lazily loaded to preserve
       # performance
       def source(radius = 2)
@@ -94,7 +99,7 @@ module Honeybadger
     end
 
     # Public: holder for an Array of Backtrace::Line instances
-    attr_reader :lines
+    attr_reader :lines, :application_lines
 
     def self.parse(ruby_backtrace, opts = {})
       ruby_lines = split_multiline_backtrace(ruby_backtrace)
@@ -108,6 +113,7 @@ module Honeybadger
 
     def initialize(lines)
       self.lines = lines
+      self.application_lines = lines.select(&:application?)
     end
 
     # Public
@@ -146,7 +152,7 @@ module Honeybadger
 
     private
 
-    attr_writer :lines
+    attr_writer :lines, :application_lines
 
     def self.split_multiline_backtrace(backtrace)
       if backtrace.to_a.size == 1

data/lib/honeybadger/configuration.rb

@@ -91,6 +91,9 @@ module Honeybadger
     # The radius around trace line to include in source excerpt
     attr_accessor :source_extract_radius
 
+    # A Proc object used to send notices asynchronously
+    attr_writer :async
+
     DEFAULT_PARAMS_FILTERS = %w(password password_confirmation).freeze
 
     DEFAULT_BACKTRACE_FILTERS = [
@@ -231,6 +234,25 @@ module Honeybadger
       !development_environments.include?(environment_name)
     end
 
+    # Public: Configure async delivery
+    #
+    # block - An optional block containing an async handler
+    #
+    # Examples
+    #
+    #   config.async = Proc.new { |notice| Thread.new { notice.deliver } }
+    #
+    #   config.async do |notice|
+    #     Thread.new { notice.deliver }
+    #   end
+    #
+    # Returns configured async handler (should respond to #call(notice))
+    def async
+      @async = Proc.new if block_given?
+      @async
+    end
+    alias :async? :async
+
     def port
       @port || default_port
     end

data/lib/honeybadger/notice.rb

@@ -114,6 +114,13 @@ module Honeybadger
       set_context
     end
 
+    # Public: Send the notice to Honeybadger using the configured sender
+    #
+    # Returns a reference to the error in Honeybadger
+    def deliver
+      Honeybadger.sender.send_to_honeybadger(to_json)
+    end
+
     # Public: Template used to create JSON payload
     #
     # Returns JSON representation of notice
@@ -274,6 +281,8 @@ module Honeybadger
             parts = line.split(': ')
             [parts[0].strip, parts[1] || '']
           end]
+        elsif backtrace.application_lines.any?
+          backtrace.application_lines.first.source(source_extract_radius)
         else
           backtrace.lines.first.source(source_extract_radius)
         end

data/lib/honeybadger/rack.rb

@@ -34,21 +34,22 @@ module Honeybadger
     end
 
     def notify_honeybadger(exception,env)
-      Honeybadger.notify_or_ignore(exception,:rack_env => env) unless ignored_user_agent?(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)
+        env['honeybadger.error_id'] = notify_honeybadger(raised, env)
         raise
       ensure
         Honeybadger.context.clear!
       end
 
-      if env['rack.exception']
-        env['honeybadger.error_id'] = notify_honeybadger(env['rack.exception'],env)
+      framework_exception = env['rack.exception'] || env['sinatra.error']
+      if framework_exception
+        env['honeybadger.error_id'] = notify_honeybadger(framework_exception, env)
       end
 
       response

data/lib/honeybadger/rails3_tasks.rb

@@ -3,16 +3,26 @@ 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)
+  task :test => :environment do
+    Rails.logger = if defined?(ActiveSupport::TaggedLogging)
+                     ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
+                   else
+                     Logger.new(STDOUT)
+                   end
+    Rails.logger.level = Logger::INFO
 
-    Rails.logger.level = Logger::DEBUG
     Honeybadger.configure(true) do |config|
       config.logger = Rails.logger
     end
 
+    # Suppress error logging in Rails' exception handling middleware. Rails 3.0
+    # uses ActionDispatch::ShowExceptions to rescue/show exceptions, but does
+    # not log anything but application trace. Rails 3.2 now falls back to
+    # logging the framework trace (moved to ActionDispatch::DebugExceptions),
+    # which caused cluttered output while running the test task.
+    class ActionDispatch::DebugExceptions ; def logger(*args) ; @logger ||= Logger.new('/dev/null') ; end ; end
+    class ActionDispatch::ShowExceptions ; def logger(*args) ; @logger ||= Logger.new('/dev/null') ; end ; end
+
     require './app/controllers/application_controller'
 
     class HoneybadgerTestingException < RuntimeError; end
@@ -22,6 +32,11 @@ namespace :honeybadger do
       exit
     end
 
+    if Honeybadger.configuration.async?
+      puts "Temporarily disabling asynchronous delivery"
+      Honeybadger.configuration.async = nil
+    end
+
     Honeybadger.configuration.development_environments = []
 
     puts "Configuration:"
@@ -43,35 +58,17 @@ namespace :honeybadger do
         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

data/lib/honeybadger/sender.rb

@@ -48,9 +48,9 @@ module Honeybadger
 
       case response
       when Net::HTTPSuccess then
-        log(:info, "Success: #{response.class}", response)
+        log(:info, "Success: #{response.class}", response, data)
       else
-        log(:error, "Failure: #{response.class}", response)
+        log(:error, "Failure: #{response.class}", response, data)
       end
 
       if response && response.respond_to?(:body)
@@ -84,8 +84,14 @@ module Honeybadger
       URI.parse("#{protocol}://#{host}:#{port}").merge(NOTICES_URI)
     end
 
-    def log(level, message, response = nil)
-      logger.send(level, LOG_PREFIX + message) if logger
+    def log(level, message, response = nil, data = nil)
+      if logger
+        logger.send(level, LOG_PREFIX + message)
+
+        # Log the notice payload for debugging
+        logger.debug(LOG_PREFIX + "Notice: #{data}") if data
+      end
+
       Honeybadger.report_environment_info
       Honeybadger.report_response_body(response.body) if response && response.respond_to?(:body)
     end

data/lib/honeybadger/shared_tasks.rb

@@ -1,7 +1,18 @@
 namespace :honeybadger do
   desc "Notify Honeybadger of a new deploy."
-  task :deploy => :environment do
+  task :deploy do
     require 'honeybadger_tasks'
+
+    if defined?(Rails.root)
+      initializer_file = Rails.root.join('config', 'initializers','honeybadger.rb')
+
+      if initializer_file.exist?
+        load initializer_file
+      else
+        Rake::Task[:environment].invoke
+      end
+    end
+
     HoneybadgerTasks.deploy(:environment    => ENV['TO'],
                             :revision       => ENV['REVISION'],
                             :repository     => ENV['REPO'],

data/lib/honeybadger/tasks.rb

@@ -4,7 +4,7 @@ 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 => ['honeybadger:log_stdout', :environment] do
-    RAILS_DEFAULT_LOGGER.level = Logger::DEBUG
+    RAILS_DEFAULT_LOGGER.level = Logger::INFO
 
     require 'action_controller/test_process'
 
@@ -17,6 +17,11 @@ namespace :honeybadger do
       exit
     end
 
+    if Honeybadger.configuration.async?
+      puts "Temporarily disabling asynchronous delivery"
+      Honeybadger.configuration.async = nil
+    end
+
     Honeybadger.configuration.development_environments = []
 
     catcher = Honeybadger::Rails::ActionControllerCatcher

data/test/test_helper.rb

@@ -1,7 +1,5 @@
 require 'test/unit'
 
-require 'bundler/setup'
-
 require 'mocha'
 require 'shoulda'
 require 'bourne'
@@ -27,14 +25,12 @@ end
 module DefinesConstants
   def setup
     @defined_constants = []
-    Honeybadger.context.clear!
   end
 
   def teardown
     @defined_constants.each do |constant|
       Object.__send__(:remove_const, constant)
     end
-    Honeybadger.context.clear!
   end
 
   def define_constant(name, value)
@@ -55,91 +51,95 @@ class CollectingSender
   end
 end
 
-module Honeybadger
-  class UnitTest < Test::Unit::TestCase
-    def assert_no_difference(expression, message = nil, &block)
-      assert_difference expression, 0, message, &block
-    end
+class Test::Unit::TestCase
+  def teardown
+    Honeybadger.context.clear!
+  end
 
-    def stub_sender
-      stub('sender', :send_to_honeybadger => nil)
-    end
+  def assert_no_difference(expression, message = nil, &block)
+    assert_difference expression, 0, message, &block
+  end
 
-    def stub_sender!
-      Honeybadger.sender = stub_sender
-    end
+  def stub_sender
+    stub('sender', :send_to_honeybadger => nil)
+  end
+
+  def stub_sender!
+    Honeybadger.sender = stub_sender
+  end
 
-    def stub_notice
-      stub('notice', :to_json => 'some yaml', :ignore? => false)
+  def stub_notice
+    Honeybadger::Notice.new({}).tap do |notice|
+      notice.stubs(:ignored? => false, :to_json => '{"foo":"bar"}')
     end
+  end
 
-    def stub_notice!
-       stub_notice.tap do |notice|
-        Honeybadger::Notice.stubs(:new => notice)
-      end
+  def stub_notice!
+     stub_notice.tap do |notice|
+       Honeybadger::Notice.stubs(:new => notice)
     end
+  end
 
-    def reset_config
-      Honeybadger.configuration = nil
-      Honeybadger.configure do |config|
-        config.api_key = 'abc123'
-      end
+  def reset_config
+    Honeybadger.configuration = nil
+    Honeybadger.configure do |config|
+      config.api_key = 'abc123'
     end
+  end
 
-    def build_notice_data(exception = nil)
-      exception ||= build_exception
-      {
-        :api_key       => 'abc123',
-        :error_class   => exception.class.name,
-        :error_message => "#{exception.class.name}: #{exception.message}",
-        :backtrace     => exception.backtrace,
-        :environment   => { 'PATH' => '/bin', 'REQUEST_URI' => '/users/1' },
-        :request       => {
-          :params     => { 'controller' => 'users', 'action' => 'show', 'id' => '1' },
-          :rails_root => '/path/to/application',
-          :url        => "http://test.host/users/1"
-        },
-        :session       => {
-          :key  => '123abc',
-          :data => { 'user_id' => '5', 'flash' => { 'notice' => 'Logged in successfully' } }
-        }
+  def build_notice_data(exception = nil)
+    exception ||= build_exception
+    {
+      :api_key       => 'abc123',
+      :error_class   => exception.class.name,
+      :error_message => "#{exception.class.name}: #{exception.message}",
+      :backtrace     => exception.backtrace,
+      :environment   => { 'PATH' => '/bin', 'REQUEST_URI' => '/users/1' },
+      :request       => {
+        :params     => { 'controller' => 'users', 'action' => 'show', 'id' => '1' },
+        :rails_root => '/path/to/application',
+        :url        => "http://test.host/users/1"
+      },
+      :session       => {
+        :key  => '123abc',
+        :data => { 'user_id' => '5', 'flash' => { 'notice' => 'Logged in successfully' } }
       }
-    end
+    }
+  end
 
-    def build_exception(opts = {})
-      backtrace = ["test/honeybadger/rack_test.rb:15:in `build_exception'",
-                   "test/honeybadger/rack_test.rb:52:in `test_delivers_exception_from_rack'",
-                   "/Users/josh/Developer/.rvm/gems/ruby-1.9.3-p0/gems/mocha-0.10.5/lib/mocha/integration/mini_test/version_230_to_262.rb:28:in `run'"]
-      opts = { :backtrace => backtrace }.merge(opts)
-      BacktracedException.new(opts)
-    end
+  def build_exception(opts = {})
+    backtrace = ["test/honeybadger/rack_test.rb:15:in `build_exception'",
+                 "test/honeybadger/rack_test.rb:52:in `test_delivers_exception_from_rack'",
+                 "/Users/josh/Developer/.rvm/gems/ruby-1.9.3-p0/gems/mocha-0.10.5/lib/mocha/integration/mini_test/version_230_to_262.rb:28:in `run'"]
+    opts = { :backtrace => backtrace }.merge(opts)
+    BacktracedException.new(opts)
+  end
 
-    def assert_array_starts_with(expected, actual)
-      assert_respond_to actual, :to_ary
-      array = actual.to_ary.reverse
-      expected.reverse.each_with_index do |value, i|
-        assert_equal value, array[i]
-      end
+  def assert_array_starts_with(expected, actual)
+    assert_respond_to actual, :to_ary
+    array = actual.to_ary.reverse
+    expected.reverse.each_with_index do |value, i|
+      assert_equal value, array[i]
     end
+  end
 
-    def assert_logged(expected)
-      assert_received(Honeybadger, :write_verbose_log) do |expect|
-        expect.with {|actual| actual =~ expected }
-      end
+  def assert_logged(expected)
+    assert_received(Honeybadger, :write_verbose_log) do |expect|
+      expect.with {|actual| actual =~ expected }
     end
+  end
 
-    def assert_not_logged(expected)
-      assert_received(Honeybadger, :write_verbose_log) do |expect|
-        expect.with {|actual| actual =~ expected }.never
-      end
+  def assert_not_logged(expected)
+    assert_received(Honeybadger, :write_verbose_log) do |expect|
+      expect.with {|actual| actual =~ expected }.never
     end
+  end
 
-    def assert_caught_and_sent
-      assert !Honeybadger.sender.collected.empty?
-    end
+  def assert_caught_and_sent
+    assert !Honeybadger.sender.collected.empty?
+  end
 
-    def assert_caught_and_not_sent
-      assert Honeybadger.sender.collected.empty?
-    end
+  def assert_caught_and_not_sent
+    assert Honeybadger.sender.collected.empty?
   end
 end