honeybadger 1.11.2 → 1.12.0.beta2

data/lib/honeybadger/rack.rb

@@ -1,58 +1,12 @@
-module Honeybadger
-  # Middleware for Rack applications. Any errors raised by the upstream
-  # application will be delivered to Honeybadger and re-raised.
-  #
-  # Synopsis:
-  #
-  #   require 'rack'
-  #   require 'honeybadger'
-  #
-  #   Honeybadger.configure do |config|
-  #     config.api_key = 'my_api_key'
-  #   end
-  #
-  #   app = Rack::Builder.app do
-  #     run lambda { |env| raise "Rack down" }
-  #   end
-  #
-  #   use Honeybadger::Rack
-  #   run app
-  #
-  # Use a standard Honeybadger.configure call to configure your api key.
-  class Rack
-    def initialize(app)
-      @app = app
-      Honeybadger.configuration.framework = "Rack: #{::Rack.release}"
-    end
+require 'honeybadger/rack/error_notifier'
+require 'honeybadger/rack/user_informer'
+require 'honeybadger/rack/user_feedback'
 
-    def ignored_user_agent?(env)
-      true if Honeybadger.
-        configuration.
-        ignore_user_agent.
-        flatten.
-        any? { |ua| ua === env['HTTP_USER_AGENT'] }
-    end
-
-    def notify_honeybadger(exception,env)
-      Honeybadger.notify_or_ignore(exception, :rack_env => env) unless ignored_user_agent?(env)
-    end
-
-    def call(env)
-      begin
-        response = @app.call(env)
-      rescue Exception => raised
-        env['honeybadger.error_id'] = notify_honeybadger(raised, env)
-        raise
-      ensure
-        Honeybadger.context.clear!
-      end
-
-      framework_exception = env['rack.exception'] || env['sinatra.error']
-      if framework_exception
-        env['honeybadger.error_id'] = notify_honeybadger(framework_exception, env)
-      end
-
-      response
+module Honeybadger
+  module Rack
+    def self.new(*args, &block)
+      warn '[DEPRECATION] Honeybadger::Rack is deprecated in 2.0. Use Honeybadger::Rack::ErrorNotifier.'
+      ErrorNotifier.new(*args, &block)
     end
   end
 end

data/lib/honeybadger/rack/error_notifier.rb

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

data/lib/honeybadger/rack/user_feedback.rb

@@ -0,0 +1,74 @@
+require 'erb'
+require 'uri'
+
+begin
+  require 'i18n'
+rescue LoadError
+  module Honeybadger
+    module I18n
+      def self.t(key, options={})
+        options[:default]
+      end
+    end
+  end
+end
+
+module Honeybadger
+  module Rack
+    class UserFeedback
+      def initialize(app)
+        @app = app
+      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
+
+      def config
+        Honeybadger.configuration
+      end
+
+      def enabled?
+        config.feedback && config.features['feedback']
+      end
+
+      def action
+        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 ||= File.read(template_file)).result(binding)
+      end
+
+      def custom_template_file
+        @custom_template_file ||= config.project_root &&
+          File.join(config.project_root, 'lib', 'honeybadger', 'templates', 'feedback_form.erb')
+      end
+
+      def custom_template_file?
+        custom_template_file && File.exists?(custom_template_file)
+      end
+
+      def template_file
+        if custom_template_file?
+          custom_template_file
+        else
+          File.expand_path('../../templates/feedback_form.erb', __FILE__)
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/rack/user_informer.rb

@@ -0,0 +1,28 @@
+module Honeybadger
+  module Rack
+    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
+end

data/lib/honeybadger/rails.rb

@@ -18,11 +18,11 @@ module Honeybadger
 
       if defined?(::Rails.configuration) && ::Rails.configuration.respond_to?(:middleware)
         ::Rails.configuration.middleware.insert_after 'ActionController::Failsafe',
-                                                      Honeybadger::Rack
+                                                      Honeybadger::Rack::ErrorNotifier
         ::Rails.configuration.middleware.insert_after 'Rack::Lock',
-                                                      Honeybadger::UserInformer
-        ::Rails.configuration.middleware.insert_after Honeybadger::UserInformer,
-                                                      Honeybadger::UserFeedback
+                                                      Honeybadger::Rack::UserInformer
+        ::Rails.configuration.middleware.insert_after Honeybadger::Rack::UserInformer,
+                                                      Honeybadger::Rack::UserFeedback
       end
 
       Honeybadger.configure(true) do |config|
@@ -34,6 +34,7 @@ module Honeybadger
 
       if defined?(::Rails.configuration) && ::Rails.configuration.respond_to?(:after_initialize)
         ::Rails.configuration.after_initialize do
+          Honeybadger::Dependency.inject!
           Honeybadger.ping(Honeybadger.configuration)
         end
       end

data/lib/honeybadger/railtie.rb

@@ -10,9 +10,9 @@ module Honeybadger
     end
 
     initializer "honeybadger.use_rack_middleware" do |app|
-      app.config.middleware.insert 0, "Honeybadger::UserInformer"
-      app.config.middleware.insert_after "Honeybadger::UserInformer","Honeybadger::UserFeedback"
-      app.config.middleware.insert_after "Honeybadger::UserFeedback","Honeybadger::Rack"
+      app.config.middleware.insert 0, "Honeybadger::Rack::UserInformer"
+      app.config.middleware.insert_after "Honeybadger::Rack::UserInformer","Honeybadger::Rack::UserFeedback"
+      app.config.middleware.insert_after "Honeybadger::Rack::UserFeedback","Honeybadger::Rack::ErrorNotifier"
     end
 
     config.after_initialize do
@@ -44,6 +44,7 @@ module Honeybadger
         ::ActionDispatch::ShowExceptions.send(:include,Honeybadger::Rails::Middleware::ExceptionsCatcher)
       end
 
+      Honeybadger::Dependency.inject!
       Honeybadger.ping(Honeybadger.configuration)
     end
   end

data/lib/honeybadger/user_feedback.rb

@@ -1,72 +1,8 @@
-require 'erb'
-require 'uri'
-
-begin
-  require 'i18n'
-rescue LoadError
-  module Honeybadger
-    module I18n
-      def self.t(key, options={})
-        options[:default]
-      end
-    end
-  end
-end
-
 module Honeybadger
-  class UserFeedback
+  class UserFeedback < Rack::UserFeedback
     def initialize(app)
-      @app = app
-    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
-
-    def config
-      Honeybadger.configuration
-    end
-
-    def enabled?
-      config.feedback && config.features['feedback']
-    end
-
-    def action
-      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 ||= File.read(template_file)).result(binding)
-    end
-
-    def custom_template_file
-      @custom_template_file ||= config.project_root &&
-        File.join(config.project_root, 'lib', 'honeybadger', 'templates', 'feedback_form.erb')
-    end
-
-    def custom_template_file?
-      custom_template_file && File.exists?(custom_template_file)
-    end
-
-    def template_file
-      if custom_template_file?
-        custom_template_file
-      else
-        File.expand_path('../templates/feedback_form.erb', __FILE__)
-      end
+      warn '[DEPRECATION] Honeybadger::UserFeedback is deprecated in 2.0. Use Honeybadger::Rack::UserFeedback.'
+      super
     end
   end
 end

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