honeybadger 1.13.2 → 1.14.0

data/lib/honeybadger/user_informer.rb

@@ -1,26 +1,8 @@
 module Honeybadger
-  class UserInformer
+  class UserInformer < Rack::UserInformer
     def initialize(app)
-      @app = app
-    end
-
-    def replacement(with)
-      Honeybadger.configuration.user_information.gsub(/\{\{\s*error_id\s*\}\}/, with.to_s)
-    end
-
-    def call(env)
-      status, headers, body = @app.call(env)
-      if env['honeybadger.error_id'] && Honeybadger.configuration.user_information
-        new_body = []
-        replace  = replacement(env['honeybadger.error_id'])
-        body.each do |chunk|
-          new_body << chunk.gsub("<!-- HONEYBADGER ERROR -->", replace)
-        end
-        body.close if body.respond_to?(:close)
-        headers['Content-Length'] = new_body.reduce(0) { |a,e| a += e.bytesize }.to_s
-        body = new_body
-      end
-      [status, headers, body]
+      warn '[DEPRECATION] Honeybadger::UserInformer is deprecated in 2.0. Use Honeybadger::Rack::UserInformer.'
+      super
     end
   end
 end

data/spec/honeybadger/configuration_spec.rb

@@ -30,11 +30,13 @@ describe Honeybadger::Configuration do
     assert_config_default :source_extract_radius, 2
     assert_config_default :async, nil
     assert_config_default :send_request_session, true
+    assert_config_default :send_local_variables, false
     assert_config_default :debug, false
     assert_config_default :log_exception_on_send_failure, false
     assert_config_default :fingerprint, nil
     assert_config_default :hostname, Socket.gethostname
     assert_config_default :feedback, true
+    assert_config_default :features, {'notices' => true, 'local_variables' => true}
   end
 
   it "configures async as Proc" do
@@ -116,6 +118,7 @@ describe Honeybadger::Configuration do
     assert_config_overridable :send_request_session
     assert_config_overridable :debug
     assert_config_overridable :hostname
+    assert_config_overridable :features
     assert_config_overridable :metrics
     assert_config_overridable :feedback
     assert_config_overridable :log_exception_on_send_failure
@@ -134,7 +137,8 @@ describe Honeybadger::Configuration do
      :notifier_version, :params_filters, :project_root, :port, :protocol,
      :proxy_host, :proxy_pass, :proxy_port, :proxy_user, :secure,
      :source_extract_radius, :async, :send_request_session, :debug,
-     :fingerprint, :hostname, :metrics, :feedback, :log_exception_on_send_failure].each do |option|
+     :fingerprint, :hostname, :features, :metrics, :feedback,
+     :log_exception_on_send_failure].each do |option|
        expect(hash[option]).to eq config[option]
     end
   end

data/spec/honeybadger/dependency_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+describe Honeybadger::Dependency do
+  let(:dependency) { Honeybadger::Dependency.new }
+  subject          { dependency }
+
+  before { Honeybadger::Dependency.stub(:instances).and_return([]) }
+
+  describe ".register" do
+    it "returns a new dependency" do
+      instance = double()
+      Honeybadger::Dependency.stub(:new).and_return(instance)
+      expect(Honeybadger::Dependency.register {}).to eq [instance]
+    end
+
+    it "registers a new dependency" do
+      expect { Honeybadger::Dependency.register {} }.to change(described_class, :instances).from([]).to([kind_of(Honeybadger::Dependency)])
+    end
+  end
+
+  describe ".inject!" do
+    it "injects all satisfied instances" do
+      Honeybadger::Dependency.instances.replace([mock_dependency, mock_dependency])
+      Honeybadger::Dependency.inject!
+    end
+
+    it "skips all unsatisfied instances" do
+      Honeybadger::Dependency.instances.replace([mock_dependency(false), mock_dependency(false)])
+      Honeybadger::Dependency.inject!
+    end
+  end
+
+  describe "#requirement" do
+    let(:block) { Proc.new {} }
+
+    it "returns and Array of requirements" do
+      expect(subject.requirement(&block)).to eq [block]
+    end
+
+    it "registers a new requirement" do
+      expect { subject.requirement(&block) }.to change(subject, :requirements).from([]).to([block])
+    end
+  end
+
+  describe "#injection" do
+    let(:block) { Proc.new {} }
+
+    it "returns an Array of injections" do
+      expect(subject.injection(&block)).to eq [block]
+    end
+
+    it "registers a new injection" do
+      expect { subject.injection(&block) }.to change(subject, :injections).from([]).to([block])
+    end
+  end
+
+  describe "#ok?" do
+    subject { dependency.ok? }
+
+    context "when not injected yet" do
+      it { should be_true }
+    end
+
+    context "when already injected" do
+      before { dependency.inject! }
+
+      it { should be_false }
+    end
+
+    context "all requirements are met" do
+      before do
+        3.times { dependency.requirement { true } }
+      end
+    end
+
+    context "some requirements fail" do
+      before do
+        3.times { dependency.requirement { true } }
+        dependency.requirement { false }
+      end
+
+      it { should be_false }
+    end
+
+    context "some requirements error" do
+      before do
+        dependency.requirement { true }
+        dependency.requirement { fail 'oops!' }
+      end
+
+      it { should be_false }
+
+      it "logs the failure" do
+        Honeybadger.should_receive(:write_verbose_log).with(/oops!/, :error).once
+        dependency.ok?
+      end
+    end
+  end
+
+  describe "#inject!" do
+    it "calls injections" do
+      dependency.injections.replace([mock_injection, mock_injection])
+      dependency.inject!
+    end
+
+    context "some injections fail" do
+      before do
+        failing_injection = Proc.new { fail 'oh noes!' }
+        dependency.injections.replace([mock_injection, failing_injection, mock_injection(false)])
+      end
+
+      it "halts injection silently" do
+        expect { dependency.inject! }.not_to raise_error
+      end
+
+      it "logs the failure" do
+        Honeybadger.should_receive(:write_verbose_log).with(/oh noes!/, :error).once
+        dependency.inject!
+      end
+
+      it "marks the dependency as injected" do
+        expect { dependency.inject!}.to change(dependency, :injected?).from(false).to(true)
+      end
+    end
+  end
+
+  def mock_dependency(ok = true)
+    double(:ok? => ok).tap { |d| d.send(ok ? :should_receive : :should_not_receive, :inject!) }
+  end
+
+  def mock_injection(positive = true)
+    double().tap { |d| d.send(positive ? :should_receive : :should_not_receive, :call) }
+  end
+end

data/spec/honeybadger/exception_extensions_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Exception, :unless => defined?(BindingOfCaller) do
+  should { respond_to :__honeybadger_bindings_stack }
+  its(:__honeybadger_bindings_stack) { should eq([]) }
+end
+
+describe Exception, :if => defined?(BindingOfCaller) do
+  describe "#set_backtrace" do
+    context "call stack does not match current file" do
+      it "changes the bindings stack" do
+        expect { subject.set_backtrace(['foo.rb:1']) }.to change(subject, :__honeybadger_bindings_stack).from([])
+      end
+    end
+
+    context "call stack includes current file" do
+      before do
+        subject.stub(:caller).and_return(["#{File.expand_path('../../../lib/honeybadger/exception_extensions.rb', __FILE__)}:1"])
+      end
+
+      it "does not change the bindings stack" do
+        expect { subject.set_backtrace(['foo.rb:1']) }.not_to change(subject, :__honeybadger_bindings_stack).from([])
+      end
+    end
+
+    context "call stack includes a non-matching line" do
+      before do
+        subject.stub(:caller).and_return(['(foo)'])
+      end
+
+      it "skips the non-matching line" do
+        expect { subject.set_backtrace(['foo.rb:1']) }.not_to raise_error
+      end
+
+      it "changes the bindings stack" do
+        expect { subject.set_backtrace(['foo.rb:1']) }.to change(subject, :__honeybadger_bindings_stack).from([])
+      end
+    end
+  end
+end

data/spec/honeybadger/integrations/delayed_job_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe "DelayedJob Dependency" do
+  before do
+    Honeybadger::Dependency.reset!
+  end
+
+  context "when delayed_job is not installed" do
+    it "fails quietly" do
+      expect { Honeybadger::Dependency.inject! }.not_to raise_error
+    end
+  end
+
+  context "when delayed_job is installed" do
+    let(:plugins_array) { [] }
+    let(:plugin_class) do
+      Class.new do
+        def self.callbacks(&block)
+        end
+      end
+    end
+
+    before do
+      Object.const_set(:Delayed, Module.new)
+      ::Delayed.const_set(:Plugin, plugin_class)
+      ::Delayed.const_set(:Worker, double(:plugins => plugins_array))
+    end
+
+    after { Object.send(:remove_const, :Delayed) }
+
+    it "adds the plugin to DelayedJob" do
+      Honeybadger::Dependency.inject!
+      expect(plugins_array).to include(Honeybadger::Integrations::DelayedJob::Plugin)
+    end
+
+    context "and delayed_job_honeybadger is installed" do
+      before do
+        ::Delayed.const_set(:Plugins, Module.new)
+        ::Delayed::Plugins.const_set(:Honeybadger, Class.new(plugin_class))
+      end
+
+      it "warns the user of the conflict" do
+        Honeybadger.should_receive(:write_verbose_log).with(/Support for Delayed Job has been moved/, :warn).once
+        Honeybadger::Dependency.inject!
+      end
+    end
+  end
+end

data/spec/honeybadger/integrations/sidekiq_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe "Sidekiq Dependency" do
+  before do
+    Honeybadger::Dependency.reset!
+  end
+
+  context "when sidekiq is not installed" do
+    it "fails quietly" do
+      expect { Honeybadger::Dependency.inject! }.not_to raise_error
+    end
+  end
+
+  context "when sidekiq is installed" do
+    let(:shim) do
+      Class.new do
+        def self.configure_server
+        end
+      end
+    end
+
+    let(:config) { double('config', :error_handlers => []) }
+    let(:chain) { double('chain', :add => true) }
+
+    before do
+      Object.const_set(:Sidekiq, shim)
+      ::Sidekiq.stub(:configure_server).and_yield(config)
+      config.stub(:server_middleware).and_yield(chain)
+    end
+
+    after { Object.send(:remove_const, :Sidekiq) }
+
+    context "when version is less than 3" do
+      before do
+        ::Sidekiq.const_set(:VERSION, '2.17.7')
+      end
+
+      it "adds the server middleware" do
+        chain.should_receive(:add).with(Honeybadger::Integrations::Sidekiq::Middleware)
+        Honeybadger::Dependency.inject!
+      end
+
+      it "doesn't add the error handler" do
+        Honeybadger::Dependency.inject!
+        expect(config.error_handlers).to be_empty
+      end
+    end
+
+    context "when version is 3 or greater" do
+      before do
+        ::Sidekiq.const_set(:VERSION, '3.0.0')
+      end
+
+      it "adds the error handler" do
+        Honeybadger::Dependency.inject!
+        expect(config.error_handlers).not_to be_empty
+      end
+    end
+  end
+end

data/spec/honeybadger/integrations/thor_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe "Thor Dependency" do
+  before do
+    Honeybadger::Dependency.reset!
+  end
+
+  context "when thor is not installed" do
+    it "fails quietly" do
+      expect { Honeybadger::Dependency.inject! }.not_to raise_error
+    end
+  end
+
+  context "when thor is installed" do
+    let(:shim) do
+      double('fake thor')
+    end
+
+    before do
+      Object.const_set(:Thor, shim)
+    end
+    after { Object.send(:remove_const, :Thor) }
+
+    it "includes integration module into Thor" do
+      shim.should_receive(:send).with(:include, Honeybadger::Integrations::Thor)
+      Honeybadger::Dependency.inject!
+    end
+  end
+end

data/spec/honeybadger/notice_spec.rb

@@ -76,6 +76,17 @@ describe Honeybadger::Notice do
     expect(notice.url).to eq url
   end
 
+  it "initializes default features" do
+    notice = build_notice(:features => nil)
+    expect(notice.features).to eq({})
+  end
+
+  it "accepts features" do
+    features = {'foo' => 'bar'}
+    notice = build_notice(:features => features)
+    expect(notice.features).to eq features
+  end
+
   it "sets the host name" do
     notice = build_notice
     expect(notice.hostname).to eq hostname
@@ -286,76 +297,6 @@ describe Honeybadger::Notice do
     assert_array_starts_with backtrace.lines, notice.backtrace.lines
   end
 
-  it "converts unserializable objects to strings" do
-    assert_serializes_hash(:parameters)
-    assert_serializes_hash(:cgi_data)
-    assert_serializes_hash(:session_data)
-  end
-
-  it "filters parameters" do
-    assert_filters_hash(:parameters)
-  end
-
-  it "filters cgi data" do
-    assert_filters_hash(:cgi_data)
-  end
-
-  it "filters session" do
-    assert_filters_hash(:session_data)
-  end
-
-  context 'filtered parameters in query string' do
-    let(:params_filters) { [:foo, :bar] }
-
-    describe '#url' do
-      let(:notice) { build_notice(:params_filters => params_filters, :url => 'https://www.honeybadger.io/?foo=1&bar=2&baz=3') }
-      it 'filters query' do
-        expect(notice.url).to eq 'https://www.honeybadger.io/?foo=[FILTERED]&bar=[FILTERED]&baz=3'
-      end
-    end
-
-    describe '#cgi_data' do
-      let(:cgi_data) { { 'QUERY_STRING' => 'foo=1&bar=2&baz=3', 'ORIGINAL_FULLPATH' => '/?foo=1&bar=2&baz=3' } }
-      let(:notice) { build_notice(:params_filters => params_filters, :cgi_data => cgi_data) }
-
-      subject { notice.cgi_data }
-
-      it 'filters QUERY_STRING key' do
-        expect(subject['QUERY_STRING']).to eq 'foo=[FILTERED]&bar=[FILTERED]&baz=3'
-      end
-
-      it 'filters ORIGINAL_FULLPATH key' do
-        expect(subject['ORIGINAL_FULLPATH']).to eq '/?foo=[FILTERED]&bar=[FILTERED]&baz=3'
-      end
-    end
-  end
-
-  describe '#filter_url' do
-    let(:notice) { build_notice(:params_filters => [], :url => url) }
-    subject { notice.send(:filter_url, url) }
-
-    context 'malformed query' do
-      let(:url) { 'https://www.honeybadger.io/?foobar12' }
-      it { should eq url }
-    end
-
-    context 'no query' do
-      let(:url) { 'https://www.honeybadger.io' }
-      it { should eq url }
-    end
-
-    context 'malformed url' do
-      let(:url) { 'http s ! honeybadger' }
-      before { expect { URI.parse(url) }.to raise_error }
-      it { should eq url }
-    end
-
-    context 'complex url' do
-      let(:url) { 'https://foo:bar@www.honeybadger.io:123/asdf/?foo=1&bar=2&baz=3' }
-      it { should eq url }
-    end
-  end
-
   it "removes rack.request.form_vars" do
     original = {
       "rack.request.form_vars" => "story%5Btitle%5D=The+TODO+label",
@@ -481,6 +422,17 @@ describe Honeybadger::Notice do
     expect(notice[:request][:context]).to eq({ 'one' => 'two', 'three' => 'four', 'foo' => 'baz' })
   end
 
+  it "doesn't mutate global context" do
+    Honeybadger.context({ 'one' => 'two' })
+    expect { build_notice(:context => { 'foo' => 'bar' }) }.not_to change { Thread.current[:honeybadger_context] }
+  end
+
+  it "doesn't mutate local context" do
+    Honeybadger.context({ 'one' => 'two' })
+    hash = { 'foo' => 'bar' }
+    expect { build_notice(:context => hash) }.not_to change { hash }
+  end
+
   it "returns nil context when context is not set" do
     notice = build_notice
     notice[:request][:context].should be_nil
@@ -493,14 +445,6 @@ describe Honeybadger::Notice do
     expect(hash['request']['context']).to eq({ 'debuga' => true, 'debugb' => false })
   end
 
-  it "ensures #to_hash is called on objects that support it" do
-    expect { build_notice(:session => { :object => double(:to_hash => {}) }) }.not_to raise_error
-  end
-
-  it "ensures #to_ary is called on objects that support it" do
-    expect { build_notice(:session => { :object => double(:to_ary => {}) }) }.not_to raise_error
-  end
-
   context "with a rack environment hash" do
     it "extracts data from a rack environment hash" do
       url = "https://subdomain.happylane.com:100/test/file.rb?var=value&var2=value2"
@@ -557,7 +501,12 @@ describe Honeybadger::Notice do
       expect(notice.session_data).to eq session_data
     end
 
-    unless Gem::Version.new(Rack.release) < Gem::Version.new('1.2')
+    if Gem::Version.new(Rack.release) < Gem::Version.new('1.3')
+      it "parses params which are malformed in Rack >= 1.3" do
+        rack_env = Rack::MockRequest.env_for('http://www.example.com/explode', :method => 'POST', :input => 'foo=bar&bar=baz%')
+        expect { Honeybadger::Notice.new(:rack_env => rack_env) }.not_to raise_error
+      end
+    else
       it "fails gracefully when Rack params cannot be parsed" do
         rack_env = Rack::MockRequest.env_for('http://www.example.com/explode', :method => 'POST', :input => 'foo=bar&bar=baz%')
         notice = Honeybadger::Notice.new(:rack_env => rack_env)
@@ -572,13 +521,6 @@ describe Honeybadger::Notice do
     notice.session_data.should be_nil
   end
 
-  it "does not allow infinite recursion" do
-    hash = {:a => :a}
-    hash[:hash] = hash
-    notice = Honeybadger::Notice.new(:parameters => hash)
-    expect(notice.parameters[:hash]).to eq "[possible infinite recursion halted]"
-  end
-
   it "trims error message to 1k" do
     message = 'asdfghjkl'*200
     e = StandardError.new(message)
@@ -594,6 +536,115 @@ describe Honeybadger::Notice do
     expect(notice.error_message).to eq 'Something very specific went wrong.'
   end
 
+  describe "#to_json" do
+    context "when local variables are not found" do
+      it "sends local_variables in request payload" do
+        notice = build_notice
+        hash = {'foo' => 'bar'}
+        notice.stub(:local_variables).and_return(hash)
+        expect(JSON.parse(notice.to_json)['request']['local_variables']).to eq(hash)
+      end
+    end
+
+    context "when local variables are found" do
+      it "sends local_variables in request payload" do
+        notice = build_notice
+        expect(JSON.parse(notice.to_json)['request']['local_variables']).to eq({})
+      end
+    end
+  end
+
+  describe "#local_variables" do
+    let(:notice) { build_notice(:exception => @exception, :configuration => configuration) }
+    let(:configuration) { configure }
+
+    before do
+      foo = 'bar'
+      begin
+        fail 'oops'
+      rescue
+        @exception = $!
+      end
+    end
+
+    context "when binding_of_caller is not installed", :unless => defined?(BindingOfCaller) do
+      context "when local variables aren't enabled" do
+        it "does not attempt to find them" do
+          expect(notice.local_variables).to eq({})
+        end
+      end
+
+      context "when local variables are enabled" do
+        before do
+          configuration.send_local_variables = true
+        end
+
+        it "does not attempt to find them" do
+          expect(notice.local_variables).to eq({})
+        end
+      end
+    end
+
+    context "when binding_of_caller is installed", :if => defined?(BindingOfCaller) do
+      context "when local variables aren't enabled" do
+        it "does not attempt to find them" do
+          expect(notice.local_variables).to eq({})
+        end
+      end
+
+      context "when local variables are enabled" do
+        before do
+          configuration.send_local_variables = true
+        end
+
+        it "finds the local variables from first frame of trace" do
+          expect(notice.local_variables[:foo]).to eq 'bar'
+        end
+
+        context "when the feature is disabled" do
+          before do
+            configuration.features['local_variables'] = false
+          end
+
+          it "assigns empty Hash" do
+            expect(notice.local_variables).to eq({})
+          end
+        end
+
+        context "with an application trace" do
+          before do
+            @exception.__honeybadger_bindings_stack.unshift(double('Binding', :eval => nil))
+            configuration.project_root = File.dirname(__FILE__)
+          end
+
+          it "finds the local variables from first frame of application trace" do
+            expect(notice.local_variables[:foo]).to eq 'bar'
+          end
+
+          context "and project_root is a Pathname" do
+            before do
+              configuration.project_root = Pathname.new(File.dirname(__FILE__))
+            end
+
+            specify { expect { notice }.not_to raise_error }
+          end
+        end
+
+        context "without an exception" do
+          it "assigns empty Hash" do
+            expect(build_notice(:exception => nil).local_variables).to eq({})
+          end
+        end
+
+        context "without bindings" do
+          it "assigns empty Hash" do
+            expect(build_notice(:exception => RuntimeError.new).local_variables).to eq({})
+          end
+        end
+      end
+    end
+  end
+
   def assert_accepts_exception_attribute(attribute, args = {}, &block)
     exception = build_exception
     block ||= lambda { exception.send(attribute) }
@@ -607,47 +658,6 @@ describe Honeybadger::Notice do
     expect(notice_from_hash.send(attribute)).to eq value
   end
 
-  def assert_serializes_hash(attribute)
-    [File.open(__FILE__), Proc.new { puts "boo!" }, Module.new].each do |object|
-      hash = {
-        :strange_object => object,
-        :sub_hash => {
-          :sub_object => object
-        },
-        :array => [object]
-      }
-      notice = build_notice(attribute => hash)
-      hash = notice.send(attribute)
-      expect(object.to_s).to eq hash[:strange_object] # objects should be serialized
-
-      expect(hash[:sub_hash]).to be_a Hash # subhashes should be kept
-      expect(object.to_s).to eq hash[:sub_hash][:sub_object] # subhash members should be serialized
-      expect(hash[:array]).to be_a Array # arrays should be kept
-      expect(object.to_s).to eq hash[:array].first # array members should be serialized
-    end
-  end
-
-  def assert_filters_hash(attribute)
-    filters  = ["abc", :def, /private/, /^foo_.*$/]
-    original = { 'abc' => "123", 'def' => "456", 'ghi' => "789", 'nested' => { 'abc' => '100' },
-      'something_with_abc' => 'match the entire string', 'private_param' => 'prra',
-      'foo_param' => 'bar', 'not_foo_param' => 'baz', 'nested_foo' => { 'foo_nested' => 'bla'} }
-    filtered = { 'abc'    => "[FILTERED]",
-                 'def'    => "[FILTERED]",
-                 'something_with_abc' => "match the entire string",
-                 'ghi'    => "789",
-                 'nested' => { 'abc' => '[FILTERED]' },
-                 'private_param' => '[FILTERED]',
-                 'foo_param' => '[FILTERED]',
-                 'not_foo_param' => 'baz',
-                 'nested_foo' => { 'foo_nested' => '[FILTERED]'}
-    }
-
-    notice = build_notice(:params_filters => filters, attribute => original)
-
-    expect(notice.send(attribute)).to eq filtered
-  end
-
   def build_backtrace_array
     ["app/models/user.rb:13:in `magic'",
       "app/controllers/users_controller.rb:8:in `index'"]