honeybadger 1.9.5 → 1.10.0.beta1

data/lib/honeybadger/templates/feedback_form.html.erb

@@ -0,0 +1,82 @@
+<style>
+#honeybadger_feedback_form *, #honeybadger_feedback_form *:before, #honeybadger_feedback_form *:after { -moz-box-sizing: border-box; -webkit-box-sizing: border-box; box-sizing: border-box; }
+#honeybadger_feedback_form h2 { font-size: 110%; line-height: 1.5em; }
+#honeybadger_feedback_form label { font-weight: bold; }
+#honeybadger_feedback_name, #honeybadger_feedback_email, #honeybadger_feedback_comment { width: 100%; padding: 0.5em; }
+#honeybadger_feedback_comment { height: 10em; }
+#honeybadger_feedback_submit { height: 1em; }
+#honeybadger_feedback_form .honeybadger-feedback-phone { display: none; }
+</style>
+
+<script>
+function honeybadgerFeedbackResponse(data) {
+  if (data['result'] == 'OK') {
+    var form = document.getElementById('honeybadger_feedback_form');
+    var success = document.getElementById('honeybadger_feedback_success');
+
+    form.style.display = 'none';
+    success.style.display = 'block';
+  } else {
+    var message;
+
+    if (data['error']) {
+      message = data['error'];
+    } else {
+      message = "An unknown error occurred. Please try again.";
+    }
+
+    alert(message);
+  }
+}
+
+function sendHoneybadgerFeedback() {
+  try {
+    var script = document.createElement('script');
+    var form = document.getElementById('honeybadger_feedback_form');
+    script.src = '<%= action %>?format=js&token=<%= error_id %>&name=' + encodeURIComponent(form.name.value) + '&email=' + encodeURIComponent(form.email.value) + '&comment=' + encodeURIComponent(form.comment.value);
+    form.appendChild(script);
+    return false;
+  } catch(e) {
+    if (window.console) {
+      console.log('Error caught while processing Honeybadger feedback form: ' + e);
+      console.log('Submitting form normally...');
+    }
+    return true;
+  }
+}
+</script>
+
+<div id="honeybadger_feedback_success" style="display:none;">
+  <p><strong>Thanks for the feedback!</strong></p>
+</div>
+
+<form action="<%= action %>" method="POST" id="honeybadger_feedback_form" onsubmit="return sendHoneybadgerFeedback();">
+  <input type="hidden" name="token" id="honeybadger_feedback_token" value="<%= error_id %>">
+
+  <h2>Care to help us fix this?</h2>
+  <p>Any information you can provide will help our technical team get to the bottom of this issue.</p>
+
+  <p class="honeybadger-feedback-name">
+    <label for="honeybadger_feedback_name">Your name</label><br>
+    <input type="text" name="name" id="honeybadger_feedback_name" size="60">
+  </p>
+
+  <p class="honeybadger-feedback-phone">
+    <label for="honeybadger_feedback_phone">Your phone number</label><br>
+    <input type="text" name="phone" id="honeybadger_feedback_phone" size="60">
+  </p>
+
+  <p class="honeybadger-feedback-email">
+    <label for="honeybadger_feedback_email">Your email address</label><br>
+    <input type="email" name="email" id="honeybadger_feedback_email" size="60">
+  </p>
+
+  <p class="honeybadger-feedback-comment">
+    <label for="honeybadger_feedback_comment">Comment (required)</label><br>
+    <textarea name="comment" id="honeybadger_feedback_comment" cols="50" rows="6" required></textarea>
+  </p>
+
+  <p class="honeybadger-feedback-submit">
+    <input type="submit" id="honeybadger_feedback_submit" value="Send">
+  </p>
+</form>

data/lib/honeybadger/user_feedback.rb

@@ -0,0 +1,42 @@
+require 'erb'
+require 'uri'
+
+module Honeybadger
+  class UserFeedback
+    TEMPLATE = File.read(File.expand_path('../templates/feedback_form.html.erb', __FILE__)).freeze
+
+    def initialize(app)
+      @app = app
+    end
+
+    def action
+      config = Honeybadger.configuration
+      URI.parse("#{config.protocol}://#{config.host}:#{config.port}/v1/feedback/").to_s
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def render_form(error_id, action = action)
+      return unless action
+      ERB.new(TEMPLATE).result(binding)
+    end
+
+    def enabled?
+      Honeybadger.configuration.feedback && Honeybadger.configuration.features['feedback']
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      if enabled? && env['honeybadger.error_id'] && form = render_form(env['honeybadger.error_id'])
+        new_body = []
+        body.each do |chunk|
+          new_body << chunk.gsub("<!-- HONEYBADGER FEEDBACK -->", form)
+        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]
+    end
+  end
+end

data/lib/honeybadger/user_informer.rb

@@ -0,0 +1,26 @@
+module Honeybadger
+  class 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]
+    end
+  end
+end

data/spec/honeybadger/configuration_spec.rb

@@ -32,6 +32,7 @@ describe Honeybadger::Configuration do
     assert_config_default :debug, false
     assert_config_default :fingerprint, nil
     assert_config_default :hostname, Socket.gethostname
+    assert_config_default :feedback, true
   end
 
   it "configures async as Proc" do
@@ -113,6 +114,8 @@ describe Honeybadger::Configuration do
     assert_config_overridable :send_request_session
     assert_config_overridable :debug
     assert_config_overridable :hostname
+    assert_config_overridable :metrics
+    assert_config_overridable :feedback
   end
 
   it "has an api key" do
@@ -128,7 +131,7 @@ 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].each do |option|
+     :fingerprint, :hostname, :metrics, :feedback].each do |option|
        expect(hash[option]).to eq config[option]
     end
   end

data/spec/honeybadger/logger_spec.rb

@@ -28,7 +28,7 @@ describe Honeybadger do
   it "prints environment info on a failed notification without a body" do
     reset_config
     stub_verbose_log
-    stub_http(:response => Faraday::Response.new(:status => 500), :body => nil)
+    stub_http(:response => Net::HTTPError, :body => nil)
     Honeybadger.should_receive(:write_verbose_log).with(/Environment Info:/)
     Honeybadger.should_not_receive(:write_verbose_log).with(/Response from Honeybadger:/, anything)
     send_notice
@@ -46,9 +46,32 @@ describe Honeybadger do
   it "prints environment info and response on a failure with a body" do
     reset_config
     stub_verbose_log
-    stub_http(:response => Faraday::Response.new(:status => 500))
+    stub_http(:response => Net::HTTPError)
     Honeybadger.should_receive(:write_verbose_log).with(/Environment Info:/)
     Honeybadger.should_receive(:write_verbose_log).with(/Response from Honeybadger:/)
     send_notice
   end
+
+  context "429 error response" do
+    let(:failure_class) do
+      if RUBY_VERSION !~ /^1/
+        'Net::HTTPTooManyRequests'
+      else
+        'Net::HTTPClientError'
+      end
+    end
+
+    before do
+      reset_config
+      stub_verbose_log
+      stub_request(:post, /api\.honeybadger\.io\/v1\/notices/).to_return(:status => 429, :body => '{"error":"something went wrong"}')
+    end
+
+    it "logs the response" do
+      Honeybadger.should_receive(:write_verbose_log).with(/Failure: #{failure_class}/, :error)
+      Honeybadger.should_receive(:write_verbose_log).with(/Environment Info:/)
+      Honeybadger.should_receive(:write_verbose_log).with(/something went wrong/)
+      Honeybadger.notify(RuntimeError.new('oops!'))
+    end
+  end
 end

data/spec/honeybadger/notice_spec.rb

@@ -95,6 +95,16 @@ describe Honeybadger::Notice do
     expect(notice.hostname).to eq 'asdf'
   end
 
+  it "defaults api key to configuration" do
+    notice = build_notice
+    expect(notice.api_key).to eq 'abc123def456'
+  end
+
+  it "sets the api key" do
+    notice = build_notice({ :api_key => 'asdf' })
+    expect(notice.api_key).to eq 'asdf'
+  end
+
   context "custom fingerprint" do
     it "includes nil fingerprint when no fingerprint is specified" do
       notice = build_notice
@@ -303,6 +313,56 @@ describe Honeybadger::Notice do
     assert_filters_hash(:session_data)
   end
 
+  describe 'url' do
+    let(:params_filters) { [] }
+    let(:notice) { build_notice(:params_filters => params_filters, :url => url) }
+
+    context 'filtered params in query' do
+      let(:params_filters) { [:bar] }
+      let(: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=1&bar=[FILTERED]&baz=3'
+      end
+    end
+
+    context 'malformed query' do
+      let(:url) { 'https://www.honeybadger.io/?foobar12' }
+
+      it 'maintains query' do
+        expect(notice.url).to eq url
+      end
+    end
+
+    context 'no query' do
+      let(:url) { 'https://www.honeybadger.io' }
+
+      it 'keeps original URL' do
+        expect(notice.url).to eq url
+      end
+    end
+
+    context 'malformed url' do
+      let(:url) { 'http s ! honeybadger' }
+
+      before do
+        expect { URI.parse(url) }.to raise_error
+      end
+
+      it 'keeps original URL' do
+        expect(notice.url).to eq url
+      end
+    end
+
+    context 'complex url' do
+      let(:url) { 'https://foo:bar@www.honeybadger.io:123/asdf/?foo=1&bar=2&baz=3' }
+
+      it 'keeps original URL' do
+        expect(notice.url).to eq url
+      end
+    end
+  end
+
   it "removes rack.request.form_vars" do
     original = {
       "rack.request.form_vars" => "story%5Btitle%5D=The+TODO+label",
@@ -559,14 +619,20 @@ describe Honeybadger::Notice do
   end
 
   def assert_filters_hash(attribute)
-    filters  = ["abc", :def]
+    filters  = ["abc", :def, /private/, /^foo_.*$/]
     original = { 'abc' => "123", 'def' => "456", 'ghi' => "789", 'nested' => { 'abc' => '100' },
-      'something_with_abc' => 'match the entire string'}
+      '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]' } }
+                 '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)
 

data/spec/honeybadger/sender_spec.rb

@@ -1,27 +1,24 @@
 require 'spec_helper'
 
 describe Honeybadger::Sender do
-  before(:each) { reset_config }
+  before { reset_config }
 
-  it "it makes a single request when sending notices" do
-    stub_request(:post, /api\.honeybadger\.io/)
+  before do
+    stub_request(:post, /api\.honeybadger\.io\/v1\/notices/).to_return(:body => '{"id":"123"}')
+  end
+
+  it "makes a single request when sending notices" do
     Honeybadger.notify(RuntimeError.new('oops!'))
     assert_requested :post, 'https://api.honeybadger.io/v1/notices/', :times => 1
   end
 
   it "posts to Honeybadger when using an HTTP proxy" do
-    post = double()
-    http = stub_http
-    http.stub(:post).and_yield(post).and_return(false)
-
-    url = "http://api.honeybadger.io:80#{Honeybadger::Sender::NOTICES_URI}"
-    uri = URI.parse(url)
+    http  = stub_http
+    proxy = double(:new => http)
+    Net::HTTP.stub(:Proxy).and_return(proxy)
 
-    post.should_receive(:url).with(uri.path)
-    post.should_receive(:body=).with('asdf')
-
-    Faraday.should_receive(:new).
-      with(hash_including(:proxy => { :uri => 'https://some.host:88', :user => 'login', :password => 'passwd' })).and_return(http)
+    http.should_receive(:post).with(Honeybadger::Sender::NOTICES_URI, kind_of(String), Honeybadger::HEADERS.merge({ 'X-API-Key' => 'abc123'}))
+    Net::HTTP.should_receive(:Proxy).with('some.host', 88, 'login', 'passwd')
 
     send_exception(:proxy_host => 'some.host',
                    :proxy_port => 88,
@@ -36,27 +33,47 @@ describe Honeybadger::Sender do
   end
 
   it "returns nil on failed posting" do
-    stub_http(:response => Faraday::Response.new(:status => 500))
+    stub_http(:response => Net::HTTPError)
     expect(send_exception(:secure => false)).to be_nil
   end
 
-  it "logs missing API key and return nil" do
-    sender = build_sender(:api_key => nil)
-    sender.should_receive(:log).with(:error, /API key/)
-    expect(send_exception(:sender => sender, :secure => false)).to be_nil
+  describe '#api_key' do
+    context 'api_key is missing' do
+      it "logs missing API key and return nil" do
+        sender = build_sender(:api_key => nil)
+        sender.should_receive(:log).with(:error, /API key/)
+        expect(send_exception(:sender => sender, :secure => false)).to be_nil
+      end
+    end
+
+    context 'notice is a hash' do
+      it 'uses api_key from hash when present' do
+        sender = build_sender(:api_key => 'asdf')
+        send_exception(:sender => sender, :notice => { 'api_key' => 'zxcv' })
+        assert_requested :post, 'https://api.honeybadger.io/v1/notices/', :times => 1, :headers => { 'x-api-key' => 'zxcv' }
+      end
+    end
+
+    context 'notice is a Honeybadger::Notice' do
+      it 'uses api_key from notice when present' do
+        sender = build_sender(:api_key => 'asdf')
+        send_exception(:sender => sender, :notice => Honeybadger::Notice.new(:api_key => 'zxcv'))
+        assert_requested :post, 'https://api.honeybadger.io/v1/notices/', :times => 1, :headers => { 'x-api-key' => 'zxcv' }
+      end
+    end
   end
 
   it "logs success" do
     stub_http
     sender = build_sender
-    sender.should_receive(:log).with(:debug, /Success/, kind_of(Faraday::Response), kind_of(String))
+    sender.should_receive(:log).with(:debug, /Success/, kind_of(Net::HTTPSuccess), kind_of(String))
     send_exception(:sender => sender, :secure => false)
   end
 
   it "logs failure" do
-    stub_http(:response => Faraday::Response.new(:status => 500))
+    stub_http(:response => Net::HTTPServerError.new('1.2', '500', 'Internal Error'))
     sender = build_sender
-    sender.should_receive(:log).with(:error, /Failure/, kind_of(Faraday::Response), kind_of(String))
+    sender.should_receive(:log).with(:error, /Failure/, kind_of(Net::HTTPServerError), kind_of(String))
     send_exception(:sender => sender, :secure => false)
   end
 
@@ -64,24 +81,28 @@ describe Honeybadger::Sender do
     # TODO: Figure out why nested groups aren't running
     context "HTTP connection setup problems" do
       it "should not be rescued" do
-        Faraday.should_receive(:new).and_raise(NoMemoryError)
-        expect { build_sender.send(:client) }.to raise_error(NoMemoryError)
+        proxy = double()
+        proxy.stub(:new).and_raise(NoMemoryError)
+        Net::HTTP.stub(:Proxy).and_return(proxy)
+        expect { build_sender.send(:setup_http_connection) }.to raise_error(NoMemoryError)
       end
 
       it "should be logged" do
-        Faraday.should_receive(:new).and_raise(RuntimeError)
+        proxy = double()
+        proxy.stub(:new).and_raise(RuntimeError)
+        Net::HTTP.stub(:Proxy).and_return(proxy)
 
         sender = build_sender
         sender.should_receive(:log).with(:error, /Failure initializing the HTTP connection/)
 
-        expect { sender.send(:client) }.to raise_error(RuntimeError)
+        expect { sender.send(:setup_http_connection) }.to raise_error(RuntimeError)
       end
     end
 
     context "unexpected exception sending problems" do
       it "should be logged" do
         sender  = build_sender
-        sender.should_receive(:client).and_raise(RuntimeError)
+        sender.should_receive(:setup_http_connection).and_raise(RuntimeError)
 
         sender.should_receive(:log).with(:error, /Error/)
         sender.send_to_honeybadger("stuff")
@@ -89,7 +110,7 @@ describe Honeybadger::Sender do
 
       it "returns nil no matter what" do
         sender  = build_sender
-        sender.should_receive(:client).and_raise(LocalJumpError)
+        sender.should_receive(:setup_http_connection).and_raise(LocalJumpError)
 
         expect { sender.send_to_honeybadger("stuff").should be_nil }.not_to raise_error
       end
@@ -127,34 +148,32 @@ describe Honeybadger::Sender do
       http = stub_http
       url = "http://api.honeybadger.io:80#{Honeybadger::Sender::NOTICES_URI}"
       uri = URI.parse(url)
-      post = double(:body= => nil)
-      http.should_receive(:post).and_yield(post)
-      post.should_receive(:url).with(uri.path)
+      http.should_receive(:post).with(uri.path, anything, Honeybadger::HEADERS.merge({ 'X-API-Key' => 'abc123'}))
       send_exception(:secure => false)
     end
 
     it "post to the right path for ssl" do
       http = stub_http
-      post = double(:body= => nil)
-      http.should_receive(:post).and_yield(post)
-      post.should_receive(:url).with(Honeybadger::Sender::NOTICES_URI)
+      http.should_receive(:post).with(Honeybadger::Sender::NOTICES_URI, anything, Honeybadger::HEADERS.merge({ 'X-API-Key' => 'abc123'}))
       send_exception(:secure => true)
     end
 
     it "verifies the SSL peer when the use_ssl option is set to true" do
       url = "https://api.honeybadger.io#{Honeybadger::Sender::NOTICES_URI}"
+      uri = URI.parse(url)
 
-      real_http = Faraday.new(:url => url)
+      real_http = Net::HTTP.new(uri.host, uri.port)
       real_http.stub(:post => nil)
-      Faraday.stub(:new).and_return(real_http)
+      proxy = double(:new => real_http)
+      Net::HTTP.stub(:Proxy => proxy)
 
       File.stub(:exist?).with(OpenSSL::X509::DEFAULT_CERT_FILE).and_return(false)
 
       send_exception(:secure => true)
 
-      expect(real_http.ssl).not_to be_empty
-      expect(real_http.ssl[:verify_mode]).to eq OpenSSL::SSL::VERIFY_PEER
-      expect(real_http.ssl[:ca_file]).to eq Honeybadger.configuration.local_cert_path
+      expect(real_http.use_ssl?).to be_true
+      expect(real_http.verify_mode).to eq OpenSSL::SSL::VERIFY_PEER
+      expect(real_http.ca_file).to eq Honeybadger.configuration.local_cert_path
     end
 
     it "uses the default DEFAULT_CERT_FILE if asked to" do
@@ -169,61 +188,65 @@ describe Honeybadger::Sender do
 
       expect(sender.use_system_ssl_cert_chain?).to be_true
 
-      http    = sender.send(:client)
-      expect(http.ssl[:ca_file]).not_to eq Honeybadger.configuration.local_cert_path
+      http = sender.send(:setup_http_connection)
+      expect(http.ca_file).not_to eq Honeybadger.configuration.local_cert_path
     end
 
     it "verifies the connection when the use_ssl option is set (VERIFY_PEER)" do
       sender  = build_sender(:secure => true)
-      http    = sender.send(:client)
-      expect(http.ssl[:verify_mode]).to eq OpenSSL::SSL::VERIFY_PEER
+      http    = sender.send(:setup_http_connection)
+      expect(http.verify_mode).to eq OpenSSL::SSL::VERIFY_PEER
     end
 
     it "uses the default cert (OpenSSL::X509::DEFAULT_CERT_FILE) only if explicitly told to" do
       sender  = build_sender(:secure => true)
-      http    = sender.send(:client)
+      http    = sender.send(:setup_http_connection)
 
-      expect(http.ssl[:ca_file]).to eq Honeybadger.configuration.local_cert_path
+      expect(http.ca_file).to eq Honeybadger.configuration.local_cert_path
 
       File.stub(:exist?).with(OpenSSL::X509::DEFAULT_CERT_FILE).and_return(true)
       sender  = build_sender(:secure => true, :use_system_ssl_cert_chain => true)
-      http    = sender.send(:client)
+      http    = sender.send(:setup_http_connection)
 
-      expect(http.ssl[:ca_file]).not_to eq Honeybadger.configuration.local_cert_path
-      expect(http.ssl[:ca_file]).to eq OpenSSL::X509::DEFAULT_CERT_FILE
+      expect(http.ca_file).not_to eq Honeybadger.configuration.local_cert_path
+      expect(http.ca_file).to eq OpenSSL::X509::DEFAULT_CERT_FILE
     end
 
     it "uses ssl if secure" do
       sender  = build_sender(:secure => true)
-      http    = sender.send(:client)
+      http    = sender.send(:setup_http_connection)
       expect(http.port).to eq 443
     end
 
     it "does not use ssl if not secure" do
       sender  = build_sender(:secure => false)
-      http    = sender.send(:client)
+      http    = sender.send(:setup_http_connection)
       expect(http.port).to eq 80
     end
   end
 
   context "network timeouts" do
     it "default the open timeout to 2 seconds" do
-      Faraday.should_receive(:new).with(hash_including({ :request => hash_including({ :open_timeout => 2 }) }))
+      http = stub_http
+      http.should_receive(:open_timeout=).with(2)
       send_exception
     end
 
     it "default the read timeout to 5 seconds" do
-      Faraday.should_receive(:new).with(hash_including({ :request => hash_including({ :timeout => 5 }) }))
+      http = stub_http
+      http.should_receive(:read_timeout=).with(5)
       send_exception
     end
 
     it "allow override of the open timeout" do
-      Faraday.should_receive(:new).with(hash_including({ :request => hash_including({ :open_timeout => 4 }) }))
+      http = stub_http
+      http.should_receive(:open_timeout=).with(4)
       send_exception(:http_open_timeout => 4)
     end
 
     it "allow override of the read timeout" do
-      Faraday.should_receive(:new).with(hash_including({ :request => hash_including({ :timeout => 10 }) }))
+      http = stub_http
+      http.should_receive(:read_timeout=).with(10)
       send_exception(:http_read_timeout => 10)
     end
   end