honeybadger 1.1.0 → 1.2.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    honeybadger (1.1.0)
+    honeybadger (1.2.0)
       activesupport
       json
 
@@ -23,7 +23,7 @@ GEM
       net-sftp (>= 2.0.0)
       net-ssh (>= 2.0.14)
       net-ssh-gateway (>= 1.1.0)
-    coderay (1.0.6)
+    coderay (1.0.7)
     cucumber (0.10.7)
       builder (>= 2.1.2)
       diff-lcs (>= 1.1.2)
@@ -35,7 +35,7 @@ GEM
     ffi (1.0.11)
     gherkin (2.4.21)
       json (>= 1.4.6)
-    guard (1.2.1)
+    guard (1.2.3)
       listen (>= 0.4.2)
       thor (>= 0.14.6)
     guard-test (0.5.0)
@@ -43,12 +43,12 @@ GEM
       test-unit (~> 2.2)
     highline (1.6.13)
     json (1.7.3)
-    listen (0.4.6)
+    listen (0.4.7)
       rb-fchange (~> 0.0.5)
       rb-fsevent (~> 0.9.1)
       rb-inotify (~> 0.8.8)
     metaclass (0.0.1)
-    method_source (0.7.1)
+    method_source (0.8)
     mocha (0.10.5)
       metaclass (~> 0.0.1)
     multi_json (1.3.6)
@@ -59,10 +59,10 @@ GEM
     net-ssh (2.5.2)
     net-ssh-gateway (1.1.0)
       net-ssh (>= 1.99.1)
-    pry (0.9.9.6)
+    pry (0.9.10)
       coderay (~> 1.0.5)
-      method_source (~> 0.7.1)
-      slop (>= 2.4.4, < 3)
+      method_source (~> 0.8)
+      slop (~> 3.3.1)
     rack (1.1.3)
     rake (0.9.2.2)
     rb-fchange (0.0.5)
@@ -85,10 +85,10 @@ GEM
       multi_json (~> 1.0)
       simplecov-html (~> 0.5.3)
     simplecov-html (0.5.3)
-    slop (2.4.4)
+    slop (3.3.2)
     term-ansicolor (1.0.7)
-    test-unit (2.5.0)
-    thor (0.15.3)
+    test-unit (2.5.1)
+    thor (0.15.4)
 
 PLATFORMS
   ruby

data/README.md

@@ -14,8 +14,12 @@ Add the Honeybadger gem to your gemfile:
 
     gem 'honeybadger'
 
-Create an initializer in config/initializers and configure your API key
-for your project:
+Then generate the initializer:
+
+    rails generate honeybadger --api-key <Your Api Key>
+
+If you prefer to manually create the initializer, that's simple enough.
+Just put the code below in config/initializers/honeybadger.rb
 
     # Uncomment the following line if running lower than Rails 3.2
     # require 'honeybadger/rails'
@@ -30,7 +34,7 @@ That's it!
 Add the honeybadger gem to your app. In config/environment.rb:
 
     config.gem 'honeybadger'
-    
+
 or if you are using bundler:
 
     gem 'honeybadger', :require => 'honeybadger/rails'
@@ -67,7 +71,7 @@ middleware:
     app = Rack::Builder.app do
       run lambda { |env| raise "Rack down" }
     end
-    
+
     use Honeybadger::Rack
     run app
 
@@ -90,7 +94,7 @@ Using honeybadger in a Sinatra app is just like a Rack app:
 
 ## Usage
 
-For the most part, Honeybadger works for itself. 
+For the most part, Honeybadger works for itself.
 
 It intercepts the exception middleware calls, sends notifications and continues the middleware call chain.
 
@@ -120,6 +124,23 @@ this rake task (from RAILS_ROOT):
 If everything is configured properly, that task will send a notice to Honeybadger
 which will be visible immediately.
 
+## User Tracking
+
+Honeybadger will automatically try to associate errors and notices with the current user.
+
+By default, it tries to call `current_user` when rescuing exceptions in ActionController.
+If you want to use a different method, you may do so in the honeybadger initializer:
+
+    Honeybadger.configure do |config|
+      ...
+      # The current user method to call for errors rescued in ActionController
+      config.current_user_method = :a_controller_method_which_returns_the_user
+    end
+
+Honeybadger assumes that the object returned by `current_user` will respond to `#id`,
+and will optionally include the user's email address if the user object also responds
+to `#email`.
+
 ## Going beyond exceptions
 
 You can also pass a hash to `Honeybadger.notify` method and store whatever you want,

data/Rakefile

@@ -1,6 +1,7 @@
 require 'rubygems'
 require 'rake'
 require 'date'
+require 'json'
 begin
   require 'cucumber/rake/task'
 rescue LoadError
@@ -193,6 +194,14 @@ namespace :cucumber do
   end
 end
 
+desc "Update supported versions: Run this to pull down latest rails versions from rubygems"
+task :update_supported_versions do
+  down_to = Gem::Version.new('3.0.0')
+  versions = JSON.parse `curl https://rubygems.org/api/v1/versions/rails.json 2> /dev/null`
+  supported_versions = versions.map { |v| Gem::Version.new(v['number']) }.reject { |v| v < down_to || v.prerelease? }.sort
+  `echo '#{supported_versions.join("\n")}' > SUPPORTED_RAILS_VERSIONS`
+end
+
 #############################################################################
 #
 # Packaging tasks

data/SUPPORTED_RAILS_VERSIONS

@@ -11,11 +11,20 @@
 3.0.10
 3.0.11
 3.0.12
+3.0.13
+3.0.14
+3.0.15
+3.0.16
+3.0.17
 3.1.0
 3.1.1
 3.1.2
 3.1.3
 3.1.4
+3.1.5
+3.1.6
+3.1.7
+3.1.8
 3.2.0
 3.2.1
 3.2.2
@@ -23,3 +32,5 @@
 3.2.4
 3.2.5
 3.2.6
+3.2.7
+3.2.8

data/features/rails.feature

@@ -199,6 +199,17 @@ Feature: Install the Gem in a Rails application
     And I perform a request to "http://example.com:123/test/index?param=value"
     Then I should receive a Honeybadger notification
 
+  Scenario: Notify honeybadger within a metal controller
+    When I configure the Honeybadger shim
+    And I configure usage of Honeybadger
+    And I define a metal response for "TestController#index":
+      """
+      raise RuntimeError, "some message"
+      """
+    And I route "/test/index" to "test#index"
+    And I perform a request to "http://example.com:123/test/index?param=value"
+    Then I should receive a Honeybadger notification
+
   Scenario: Reporting 404s
     When I configure the Honeybadger shim
     And I configure usage of Honeybadger

data/features/step_definitions/rails_application_steps.rb

@@ -195,12 +195,12 @@ When /^I install the "([^\"]*)" plugin$/ do |plugin_name|
   FileUtils.mkdir_p("#{rails_root}/vendor/plugins/#{plugin_name}")
 end
 
-When /^I define a response for "([^\"]*)":$/ do |controller_and_action, definition|
+When /^I define a( metal)? response for "([^\"]*)":$/ do |metal, controller_and_action, definition|
   controller_class_name, action = controller_and_action.split('#')
   controller_name = controller_class_name.underscore
   controller_file_name = File.join(rails_root, 'app', 'controllers', "#{controller_name}.rb")
   File.open(controller_file_name, "w") do |file|
-    file.puts "class #{controller_class_name} < ApplicationController"
+    file.puts "class #{controller_class_name} < #{ metal ? 'ActionController::Metal' : 'ApplicationController'}"
     file.puts "def consider_all_requests_local; false; end"
     file.puts "def local_request?; false; end"
     file.puts "def #{action}"

data/generators/honeybadger/honeybadger_generator.rb

@@ -66,7 +66,7 @@ class HoneybadgerGenerator < Rails::Generator::Base
   end
 
   def heroku_api_key
-    heroku_var("(hoptoad|honeybadger)_api_key",options[:app]).split.find {|x| x unless x.blank?}
+    heroku_var("(honeybadger)_api_key",options[:app]).split.find {|x| x unless x.blank?}
   end
 
   def heroku?

data/honeybadger.gemspec

@@ -4,8 +4,8 @@ Gem::Specification.new do |s|
   s.rubygems_version = '1.3.5'
 
   s.name              = 'honeybadger'
-  s.version           = '1.1.0'
-  s.date              = '2012-07-26'
+  s.version           = '1.2.0'
+  s.date              = '2012-09-21'
 
   s.summary     = "Error reports you can be happy about."
   s.description = "Make managing application errors a more pleasant experience."

data/lib/honeybadger.rb

@@ -19,7 +19,7 @@ require 'honeybadger/sender'
 require 'honeybadger/railtie' if defined?(Rails::Railtie)
 
 module Honeybadger
-  VERSION = '1.1.0'
+  VERSION = '1.2.0'
   LOG_PREFIX = "** [Honeybadger] "
 
   HEADERS = {

data/lib/honeybadger/backtrace.rb

@@ -16,25 +16,42 @@ module Honeybadger
       # Public: The method of the line (such as index)
       attr_reader :method
 
+      # Public: Filtered representations
+      attr_reader :filtered_file, :filtered_number, :filtered_method
+
       # Public: Parses a single line of a given backtrace
       #
       # unparsed_line - The raw line from +caller+ or some backtrace
       #
       # Returns the parsed backtrace line
-      def self.parse(unparsed_line)
-        _, file, number, method = unparsed_line.match(INPUT_FORMAT).to_a
-        new(file, number, method)
+      def self.parse(unparsed_line, opts = {})
+        filters = opts[:filters] || []
+        filtered_line = filters.inject(unparsed_line) do |line, proc|
+          proc.call(line)
+        end
+
+        if filtered_line
+          _, file, number, method = unparsed_line.match(INPUT_FORMAT).to_a
+          _, *filtered_args = filtered_line.match(INPUT_FORMAT).to_a
+          new(file, number, method, *filtered_args)
+        else
+          nil
+        end
       end
 
-      def initialize(file, number, method)
-        self.file   = file
-        self.number = number
-        self.method = method
+      def initialize(file, number, method, filtered_file = file,
+                     filtered_number = number, filtered_method = method)
+        self.filtered_file   = filtered_file
+        self.filtered_number = filtered_number
+        self.filtered_method = filtered_method
+        self.file            = file
+        self.number          = number
+        self.method          = method
       end
 
       # Public: Reconstructs the line in a readable fashion
       def to_s
-        "#{file}:#{number}:in `#{method}'"
+        "#{filtered_file}:#{filtered_number}:in `#{filtered_method}'"
       end
 
       def ==(other)
@@ -45,9 +62,35 @@ module Honeybadger
         "<Line:#{to_s}>"
       end
 
+      # Public: An excerpt from the source file, lazily loaded to preserve
+      # performance
+      def source(radius = 2)
+        @source ||= get_source(file, number, radius)
+      end
+
       private
 
-      attr_writer :file, :number, :method
+      attr_writer :file, :number, :method, :filtered_file, :filtered_number, :filtered_method
+
+      # Private: Open source file and read line(s)
+      #
+      # Returns an array of line(s) from source file
+      def get_source(file, number, radius = 2)
+        if file && File.exists?(file)
+          before = after = radius
+          start = (number.to_i - 1) - before
+          start = 0 and before = 1 if start <= 0
+          duration = before + 1 + after
+
+          l = 0
+          File.open(file) do |f|
+            start.times { f.gets ; l += 1 }
+            return Hash[duration.times.map { (line = f.gets) ? [(l += 1), line] : nil }.compact]
+          end
+        else
+          {}
+        end
+      end
     end
 
     # Public: holder for an Array of Backtrace::Line instances
@@ -56,17 +99,10 @@ module Honeybadger
     def self.parse(ruby_backtrace, opts = {})
       ruby_lines = split_multiline_backtrace(ruby_backtrace)
 
-      filters = opts[:filters] || []
-      filtered_lines = ruby_lines.to_a.map do |line|
-        filters.inject(line) do |line, proc|
-          proc.call(line)
-        end
+      lines = ruby_lines.collect do |unparsed_line|
+        Line.parse(unparsed_line, opts)
       end.compact
 
-      lines = filtered_lines.collect do |unparsed_line|
-        Line.parse(unparsed_line)
-      end
-
       instance = new(lines)
     end
 

data/lib/honeybadger/configuration.rb

@@ -5,7 +5,7 @@ module Honeybadger
                :ignore_user_agent, :notifier_name, :notifier_url, :notifier_version,
                :params_filters, :project_root, :port, :protocol, :proxy_host, :proxy_pass,
                :proxy_port, :proxy_user, :secure, :use_system_ssl_cert_chain, :framework,
-               :user_information, :rescue_rake_exceptions].freeze
+               :user_information, :rescue_rake_exceptions, :source_extract_radius].freeze
 
     # The API key for your project, found on the project edit form.
     attr_accessor :api_key
@@ -84,15 +84,21 @@ module Honeybadger
     # The framework Honeybadger is configured to use
     attr_accessor :framework
 
+    # The current user method to call for errors rescued in ActionController
+    attr_accessor :current_user_method
+
     # Should Honeybadger catch exceptions from Rake tasks?
     # (boolean or nil; set to nil to catch exceptions when rake isn't running from a terminal; default is nil)
     attr_accessor :rescue_rake_exceptions
 
+    # The radius around trace line to include in source excerpt
+    attr_accessor :source_extract_radius
+
     DEFAULT_PARAMS_FILTERS = %w(password password_confirmation).freeze
 
     DEFAULT_BACKTRACE_FILTERS = [
       lambda { |line|
-        if defined?(Honeybadger.configuration.project_root) && Honeybadger.configuration.project_root.to_s != '' 
+        if defined?(Honeybadger.configuration.project_root) && Honeybadger.configuration.project_root.to_s != ''
           line.sub(/#{Honeybadger.configuration.project_root}/, "[PROJECT_ROOT]")
         else
           line
@@ -138,6 +144,8 @@ module Honeybadger
       @framework                 = 'Standalone'
       @user_information          = 'Honeybadger Error {{error_id}}'
       @rescue_rake_exceptions    = nil
+      @current_user_method       = :current_user
+      @source_extract_radius     = 2
     end
 
     # Public: Takes a block and adds it to the list of backtrace filters. When

data/lib/honeybadger/notice.rb

@@ -11,6 +11,12 @@ module Honeybadger
     # The name of the class of error (such as RuntimeError)
     attr_reader :error_class
 
+    # Excerpt from source file
+    attr_reader :source_extract
+
+    # The number of lines of context to include before and after source excerpt
+    attr_reader :source_extract_radius
+
     # The name of the server environment (such as "production")
     attr_reader :environment_name
 
@@ -64,6 +70,9 @@ module Honeybadger
     # The host name where this error occurred (if any)
     attr_reader :hostname
 
+    # The user affected by the exception, if available
+    attr_reader :user
+
     def initialize(args)
       self.args         = args
       self.exception    = args[:exception]
@@ -87,13 +96,17 @@ module Honeybadger
 
       self.environment_name = args[:environment_name]
       self.cgi_data         = args[:cgi_data] || args[:rack_env]
+      self.user             = args[:user]
       self.backtrace        = Backtrace.parse(exception_attribute(:backtrace, caller), :filters => self.backtrace_filters)
       self.error_class      = exception_attribute(:error_class) {|exception| exception.class.name }
       self.error_message    = exception_attribute(:error_message, 'Notification') do |exception|
         "#{exception.class.name}: #{exception.message}"
       end
 
-      self.hostname        = local_hostname
+      self.hostname         = local_hostname
+
+      self.source_extract_radius = args[:source_extract_radius] || 2
+      self.source_extract        = extract_source_from_backtrace
 
       also_use_rack_params_filters
       find_session_data
@@ -114,7 +127,8 @@ module Honeybadger
         :error => {
           :class => error_class,
           :message => error_message,
-          :backtrace => backtrace
+          :backtrace => backtrace,
+          :source => source_extract
         },
         :request => {
           :url => url,
@@ -122,7 +136,8 @@ module Honeybadger
           :action => action,
           :params => parameters,
           :session => session_data,
-          :cgi_data => cgi_data
+          :cgi_data => cgi_data,
+          :user => user
         },
         :server => {
           :project_root => project_root,
@@ -169,7 +184,8 @@ module Honeybadger
       :backtrace_filters, :parameters, :params_filters, :environment_filters,
       :session_data, :project_root, :url, :ignore, :ignore_by_filters,
       :notifier_name, :notifier_url, :notifier_version, :component, :action,
-      :cgi_data, :environment_name, :hostname
+      :cgi_data, :environment_name, :hostname, :user, :source_extract,
+      :source_extract_radius
 
     # Private: Arguments given in the initializer
     attr_accessor :args
@@ -247,6 +263,23 @@ module Honeybadger
       end
     end
 
+    def extract_source_from_backtrace
+      if backtrace.lines.empty?
+        nil
+      else
+        # ActionView::Template::Error has its own source_extract method.
+        # If present, use that instead.
+        if exception.respond_to?(:source_extract)
+          Hash[exception_attribute(:source_extract).split("\n").map do |line|
+            parts = line.split(': ')
+            [parts[0].strip, parts[1] || '']
+          end]
+        else
+          backtrace.lines.first.source(source_extract_radius)
+        end
+      end
+    end
+
     def filter(hash)
       if params_filters
         hash.each do |key, value|

data/lib/honeybadger/rails/controller_methods.rb

@@ -7,7 +7,8 @@ module Honeybadger
           :controller       => params[:controller],
           :action           => params[:action],
           :url              => honeybadger_request_url,
-          :cgi_data         => honeybadger_filter_if_filtering(request.env) }
+          :cgi_data         => honeybadger_filter_if_filtering(request.env),
+          :user             => honeybadger_user_info }
       end
 
       private
@@ -54,6 +55,17 @@ module Honeybadger
         end
       end
 
+      def honeybadger_user_info
+        method = Honeybadger.configuration.current_user_method
+
+        if respond_to?(method) && user = send(method)
+          {
+            :id => user.id,
+            :email => user.respond_to?(:email) ? user.email : 'N/A'
+          }
+        end
+      end
+
       def honeybadger_request_url
         url = "#{request.protocol}#{request.host}"
 

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

@@ -17,7 +17,7 @@ module Honeybadger
           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)
+                   (controller.respond_to?(:honeybadger_request_data) ? controller.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

data/lib/honeybadger/shared_tasks.rb

@@ -24,7 +24,7 @@ namespace :honeybadger do
       end
 
       heroku_rails_env = heroku_var("rails_env")
-      heroku_api_key = heroku_var("(honeybadger)_api_key").split.find {|x| x unless x.blank?} ||
+      heroku_api_key = heroku_var("honeybadger_api_key").split.find {|x| x unless x.blank?} ||
         Honeybadger.configuration.api_key
 
       command = %Q(heroku addons:add deployhooks:http --url="https://api.honeybadger.io/v1/deploys?deploy[environment]=#{heroku_rails_env}&api_key=#{heroku_api_key}")

data/lib/honeybadger_tasks.rb

@@ -57,8 +57,13 @@ module HoneybadgerTasks
     else
       response = http.request(post)
 
-      puts response.body
-      return Net::HTTPSuccess === response
+      if Net::HTTPSuccess === response
+        puts "Succesfully recorded deployment"
+        return true
+      else
+        puts response.body
+        return false
+      end
     end
   end
 end

data/lib/rails/generators/honeybadger/honeybadger_generator.rb

@@ -76,7 +76,7 @@ class HoneybadgerGenerator < Rails::Generators::Base
   end
 
   def heroku_api_key
-    heroku_var("(hoptoad|honeybadger)_api_key",options[:app]).split.find {|x| x unless x.blank?}
+    heroku_var("honeybadger_api_key",options[:app]).split.find {|x| x unless x.blank?}
   end
 
   def heroku?

data/test/unit/backtrace_test.rb

@@ -1,4 +1,5 @@
 require 'test_helper'
+require 'stringio'
 
 class BacktraceTest < Honeybadger::UnitTest
   should "parse a backtrace into lines" do
@@ -55,6 +56,66 @@ class BacktraceTest < Honeybadger::UnitTest
     assert_equal expected_backtrace, original_backtrace
   end
 
+  context "when source file exists" do
+    setup do
+      source = <<-RUBY
+        $:<<'lib'
+        require 'honeybadger'
+
+        begin
+          raise StandardError
+        rescue => e
+          puts Honeybadger::Notice.new(exception: e).backtrace.to_json
+        end
+      RUBY
+
+      array = [
+        "app/models/user.rb:2:in `magic'",
+        "app/concerns/authenticated_controller.rb:4:in `authorize'",
+        "app/controllers/users_controller.rb:8:in `index'"
+      ]
+
+      ['app/models/user.rb', 'app/concerns/authenticated_controller.rb', 'app/controllers/users_controller.rb'].each do |file|
+        File.expects(:exists?).with(file).returns true
+        File.expects(:open).with(file).yields StringIO.new(source)
+      end
+
+      @backtrace = Honeybadger::Backtrace.parse(array)
+    end
+
+    should "include a snippet from the source file for each line of the backtrace" do
+      assert_equal 4, @backtrace.lines.first.source.keys.size
+      assert_match /\$:<</, @backtrace.lines.first.source[1]
+      assert_match /require/, @backtrace.lines.first.source[2]
+      assert_match /\n/, @backtrace.lines.first.source[3]
+      assert_match /begin/, @backtrace.lines.first.source[4]
+
+      assert_equal 5, @backtrace.lines.second.source.keys.size
+      assert_match /require/, @backtrace.lines.second.source[2]
+      assert_match /\n/, @backtrace.lines.second.source[3]
+      assert_match /begin/, @backtrace.lines.second.source[4]
+      assert_match /StandardError/, @backtrace.lines.second.source[5]
+      assert_match /rescue/, @backtrace.lines.second.source[6]
+
+      assert_equal 3, @backtrace.lines.third.source.keys.size
+      assert_match /rescue/, @backtrace.lines.third.source[6]
+      assert_match /Honeybadger/, @backtrace.lines.third.source[7]
+      assert_match /end/, @backtrace.lines.third.source[8]
+    end
+  end
+
+  should "fail gracefully when looking up snippet and file doesn't exist" do
+    array = [
+      "app/models/user.rb:13:in `magic'",
+      "app/controllers/users_controller.rb:8:in `index'"
+    ]
+
+    backtrace = Honeybadger::Backtrace.parse(array)
+
+    assert_empty backtrace.lines.first.source
+    assert_empty backtrace.lines.second.source
+  end
+
   context "with a project root" do
     setup do
       @project_root = '/some/path'

data/test/unit/capistrano_test.rb

@@ -20,7 +20,7 @@ class CapistranoTest < Honeybadger::UnitTest
   should "log when calling honeybadger:deploy task" do
     @configuration.set(:current_revision, '084505b1c0e0bcf1526e673bb6ac99fbcb18aecc')
     @configuration.set(:repository, 'repository')
-    @configuration.set(:current_release, '/home/deploy/rails_app/hoptoad')
+    @configuration.set(:current_release, '/home/deploy/rails_app/honeybadger')
     io = StringIO.new
     logger = Capistrano::Logger.new(:output => io)
     logger.level = Capistrano::Logger::MAX_LEVEL

data/test/unit/configuration_test.rb

@@ -27,6 +27,8 @@ class ConfigurationTest < Honeybadger::UnitTest
     assert_config_default :ignore,
                           Honeybadger::Configuration::IGNORE_DEFAULT
     assert_config_default :framework, 'Standalone'
+    assert_config_default :current_user_method,     :current_user
+    assert_config_default :source_extract_radius, 2
   end
 
   should "provide default values for secure connections" do
@@ -67,6 +69,7 @@ class ConfigurationTest < Honeybadger::UnitTest
     assert_config_overridable :notifier_url
     assert_config_overridable :environment_name
     assert_config_overridable :logger
+    assert_config_overridable :current_user_method
   end
 
   should "have an api key" do

data/test/unit/honeybadger_tasks_test.rb

@@ -96,7 +96,7 @@ class HoneybadgerTasksTest < Honeybadger::UnitTest
           end
 
           before_should "puts the response body on success" do
-            HoneybadgerTasks.expects(:puts).with("body")
+            HoneybadgerTasks.expects(:puts).with("Succesfully recorded deployment")
             @http_proxy.expects(:request).with(any_parameters).returns(successful_response('body'))
           end
 
@@ -122,7 +122,7 @@ class HoneybadgerTasksTest < Honeybadger::UnitTest
 
     context "in a configured project with custom host" do
       setup do
-        Honeybadger.configure do |config| 
+        Honeybadger.configure do |config|
           config.api_key = "1234123412341234"
           config.host = "custom.host"
           config.secure = false

data/test/unit/notice_test.rb

@@ -57,6 +57,10 @@ class NoticeTest < Honeybadger::UnitTest
     assert_equal 'index', build_notice(:action => 'index').action
   end
 
+  should "accept source excerpt radius" do
+    assert_equal 3, build_notice(:source_extract_radius => 3).source_extract_radius
+  end
+
   should "accept a url" do
     url = 'http://some.host/uri'
     notice = build_notice(:url => url)
@@ -68,31 +72,61 @@ class NoticeTest < Honeybadger::UnitTest
     assert_equal hostname, notice.hostname
   end
 
-  should "accept a backtrace from an exception or hash" do
-    array = ["user.rb:34:in `crazy'"]
-    exception = build_exception
-    exception.set_backtrace array
-    backtrace = Honeybadger::Backtrace.parse(array)
-    notice_from_exception = build_notice(:exception => exception)
+  context "with a backtrace" do
+    setup do
+      @backtrace_array = ['my/file/backtrace:3']
+      @exception = build_exception
+      @exception.set_backtrace(@backtrace_array)
+    end
+
+    should "accept a backtrace from an exception or hash" do
+      backtrace = Honeybadger::Backtrace.parse(@backtrace_array)
+      notice_from_exception = build_notice(:exception => @exception)
 
+      assert_equal backtrace,
+        notice_from_exception.backtrace,
+        "backtrace was not correctly set from an exception"
 
-    assert_equal backtrace,
-                 notice_from_exception.backtrace,
-                 "backtrace was not correctly set from an exception"
+      notice_from_hash = build_notice(:backtrace => @backtrace_array)
+      assert_equal backtrace,
+        notice_from_hash.backtrace,
+        "backtrace was not correctly set from a hash"
+    end
 
-    notice_from_hash = build_notice(:backtrace => array)
-    assert_equal backtrace,
-                 notice_from_hash.backtrace,
-                 "backtrace was not correctly set from a hash"
+    should "pass its backtrace filters for parsing" do
+      Honeybadger::Backtrace.expects(:parse).with(@backtrace_array, {:filters => 'foo'}).returns(mock(:lines => []))
+
+      notice = Honeybadger::Notice.new({:exception => @exception, :backtrace_filters => 'foo'})
+    end
+
+    should "pass its backtrace line filters for parsing" do
+      Honeybadger::Backtrace::Line.expects(:parse).with(@backtrace_array.first, {:filters => 'foo'})
+
+      notice = Honeybadger::Notice.new({:exception => @exception, :backtrace_filters => 'foo'})
+    end
+
+    should "include source extract from backtrace" do
+      backtrace = Honeybadger::Backtrace.parse(@backtrace_array)
+      notice_from_exception = build_notice(:exception => @exception)
+
+      assert_equal backtrace.lines.first.source, notice_from_exception.source_extract
+    end
   end
 
-  should "pass its backtrace filters for parsing" do
-    backtrace_array = ['my/file/backtrace:3']
+  should "Use source extract from view when reporting an ActionView::Template::Error" do
+    # TODO: I would like to stub out a real ActionView::Template::Error, but we're
+    # currently locked at actionpack 2.3.8. Perhaps if one day we upgrade...
+    source = <<-ERB
+      1:   <%= current_user.name %>
+      2: </div>
+      3: 
+      4: <div>
+    ERB
     exception = build_exception
-    exception.set_backtrace(backtrace_array)
-    Honeybadger::Backtrace.expects(:parse).with(backtrace_array, {:filters => 'foo'})
+    exception.stubs(:source_extract).returns(source)
+    notice = Honeybadger::Notice.new({:exception => exception})
 
-    notice = Honeybadger::Notice.new({:exception => exception, :backtrace_filters => 'foo'})
+    assert_equal({ '1' => '  <%= current_user.name %>', '2' => '</div>', '3' => '', '4' => '<div>'}, notice.source_extract)
   end
 
   should "set the error class from an exception or hash" do
@@ -135,6 +169,10 @@ class NoticeTest < Honeybadger::UnitTest
     assert_equal data, notice.cgi_data, "should take CGI data from a hash"
   end
 
+  should "accept user" do
+    assert_equal 'foo@bar.com', build_notice(:user => 'foo@bar.com').user
+  end
+
   should "accept notifier information" do
     params = { :notifier_name    => 'a name for a notifier',
                :notifier_version => '1.0.5',
@@ -196,12 +234,21 @@ class NoticeTest < Honeybadger::UnitTest
     assert_nil notice.url
     assert_nil notice.controller
     assert_nil notice.action
+    assert_nil notice.user
 
     json = notice.to_json
     payload = JSON.parse(json)
     assert_nil payload['request']['url']
     assert_nil payload['request']['component']
     assert_nil payload['request']['action']
+    assert_nil payload['request']['user']
+  end
+
+  should "send user in request" do
+    notice = build_notice(:user => 'foo@bar.com')
+    json = notice.to_json
+    payload = JSON.parse(json)
+    assert_equal payload['request']['user'], 'foo@bar.com'
   end
 
   %w(url controller action).each do |var|
@@ -288,7 +335,6 @@ class NoticeTest < Honeybadger::UnitTest
     end
   end
 
-
   should "ensure #to_ary is called on objects that support it" do
     assert_nothing_raised do
       build_notice(:session => { :object => stub(:to_ary => {}) })

data/test/unit/rails/action_controller_catcher_test.rb

@@ -113,6 +113,7 @@ class ActionControllerCatcherTest < Honeybadger::UnitTest
     klass.local                       = opts[:local]
     controller = klass.new
     controller.stubs(:rescue_action_in_public_without_honeybadger)
+    controller.stubs(Honeybadger.configuration.current_user_method).returns(opts[:current_user]) if opts[:current_user]
     opts[:request].query_parameters = opts[:request].query_parameters.merge(opts[:params] || {})
     opts[:request].session = ActionController::TestSession.new(opts[:session] || {})
     # Prevents request.fullpath from crashing Rails in tests
@@ -297,4 +298,27 @@ class ActionControllerCatcherTest < Honeybadger::UnitTest
     assert_received(session, :data) { |expect| expect.at_least_once }
     assert_caught_and_sent
   end
+
+  should "call current_user_method if overridden" do
+    Honeybadger.configuration.current_user_method = :rockstar
+
+    current_user = mock( :id => 1 )
+    controller = process_action_with_automatic_notification(:current_user => current_user)
+    assert_received(controller, :rockstar) { |expect| expect.at_least_once }
+    assert_caught_and_sent
+  end
+
+  should "include current_user.id in request user data" do
+    current_user = stub( :id => 1 )
+    controller = process_action_with_automatic_notification(:current_user => current_user)
+    assert_equal({ :id => 1, :email => 'N/A' }, controller.honeybadger_request_data[:user])
+    assert_caught_and_sent
+  end
+
+  should "include current_user.email in request user data" do
+    current_user = stub( :id => 1, :email => 'foo@bar.com' )
+    controller = process_action_with_automatic_notification(:current_user => current_user)
+    assert_equal({ :id => 1, :email => 'foo@bar.com' }, controller.honeybadger_request_data[:user])
+    assert_caught_and_sent
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: honeybadger
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-26 00:00:00.000000000 Z
+date: 2012-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json