right_agent 2.2.1-x86-mingw32 → 2.4.3-x86-mingw32

data/spec/agent_spec.rb

@@ -493,10 +493,10 @@ describe RightScale::Agent do
       it "should ack if request dispatch fails" do
         run_in_em do
           request = RightScale::Request.new("/foo/bar", "payload")
-          @log.should_receive(:error).with(/Failed to dispatch request/, Exception, :trace).once
+          @log.should_receive(:error).with(/Failed to dispatch request/, StandardError, :trace).once
           @broker.should_receive(:subscribe).with(hsh(:name => @identity), nil, Hash, Proc).
                                              and_return(@broker_ids).and_yield(@broker_id, request, @header).once
-          @dispatcher.should_receive(:dispatch).and_raise(Exception)
+          @dispatcher.should_receive(:dispatch).and_raise(StandardError)
           @header.should_receive(:ack).once
           @agent.run
         end
@@ -505,10 +505,10 @@ describe RightScale::Agent do
       it "should ack if response delivery fails" do
         run_in_em do
           result = RightScale::Result.new("token", "to", "results", "from")
-          @log.should_receive(:error).with(/Failed to deliver response/, Exception, :trace).once
+          @log.should_receive(:error).with(/Failed to deliver response/, StandardError, :trace).once
           @broker.should_receive(:subscribe).with(hsh(:name => @identity), nil, Hash, Proc).
                                              and_return(@broker_ids).and_yield(@broker_id, result, @header).once
-          @sender.should_receive(:handle_response).and_raise(Exception)
+          @sender.should_receive(:handle_response).and_raise(StandardError)
           @header.should_receive(:ack).once
           @agent.run
         end
@@ -528,7 +528,7 @@ describe RightScale::Agent do
         run_in_em do
           @agent = RightScale::Agent.new(:user => "me", :identity => @identity)
           @broker.should_receive(:nil?).and_return(true)
-          @log.should_receive(:error).with("[stop] Terminating because just because", nil, :trace).once
+          @log.should_receive(:error).with("[stop] Terminating because just because").once
           @agent.terminate("just because")
         end
       end

data/spec/clients/auth_client_spec.rb

@@ -269,7 +269,7 @@ describe RightScale::AuthClient do
           end
 
           it "log error if callback fails" do
-            @log.should_receive(:error).with("Failed status callback", StandardError).once
+            @log.should_receive(:error).with("Failed status callback", StandardError, :caller).once
             @client.status { |t, s| raise StandardError, "test" }
             @client.send(:state=, state).should == state
           end

data/spec/clients/balanced_http_client_spec.rb

@@ -123,26 +123,26 @@ describe RightScale::BalancedHttpClient do
     end
 
     it "uses specified request UUID" do
-      @log.should_receive(:info).with("Requesting POST <my uuid> /foo/bar").once
+      @log.should_receive(:info).with("Requesting POST <my uuid> /foo/bar {}").once
       @log.should_receive(:info).with("Completed <my uuid> in 10ms | 200 [http://my.com/foo/bar] | 11 bytes")
       @client.request(:post, @path, @params, :request_uuid => "my uuid")
     end
 
     it "generates request UUID if none specified" do
-      @log.should_receive(:info).with("Requesting POST <random uuid> /foo/bar").once
+      @log.should_receive(:info).with("Requesting POST <random uuid> /foo/bar {}").once
       @log.should_receive(:info).with("Completed <random uuid> in 10ms | 200 [http://my.com/foo/bar] | 11 bytes").once
       @client.request(:post, @path)
     end
 
     it "logs request before sending it" do
-      @log.should_receive(:info).with("Requesting POST <random uuid> /foo/bar").once
+      @log.should_receive(:info).with("Requesting POST <random uuid> /foo/bar {}").once
       flexmock(@http_client).should_receive(:request).and_raise(RuntimeError).once
       @client.request(:post, @path) rescue nil
     end
 
     it "logs using specified :log_level" do
       @params = {:some => "data"}
-      @log.should_receive(:debug).with("Requesting POST <random uuid> /foo/bar").once
+      @log.should_receive(:debug).with("Requesting POST <random uuid> /foo/bar {:some=>\"data\"}").once
       @log.should_receive(:debug).with("Completed <random uuid> in 10ms | 200 [http://my.com/foo/bar] | 11 bytes").once
       @client.request(:post, @path, @params, :log_level => :debug)
     end
@@ -170,7 +170,7 @@ describe RightScale::BalancedHttpClient do
     end
 
     it "logs successful completion of request" do
-      @log.should_receive(:info).with("Requesting POST <random uuid> /foo/bar")
+      @log.should_receive(:info).with("Requesting POST <random uuid> /foo/bar {}")
       @log.should_receive(:info).with("Completed <random uuid> in 10ms | 200 [http://my.com/foo/bar] | 11 bytes").once
       @client.request(:post, @path, @params, @options)
     end
@@ -412,7 +412,8 @@ describe RightScale::BalancedHttpClient do
       gateway_timeout = RightScale::HttpExceptions.create(504, "server timeout")
       bad_request = RightScale::HttpExceptions.create(400, "bad data")
       @no_result = RightSupport::Net::NoResult.new("no result", {@url => gateway_timeout, @url => bad_request})
-      lambda { @client.send(:handle_no_result, @no_result, @url, &@proc) }.should raise_error(bad_request)
+      lambda { @client.send(:handle_no_result, @no_result, @url, &@proc) }.
+          should raise_error(RightScale::HttpExceptions::BadRequest)
       @yielded.should == bad_request
     end
 
@@ -458,7 +459,8 @@ describe RightScale::BalancedHttpClient do
     it "raises last exception in details if not retryable" do
       bad_request = RightScale::HttpExceptions.create(400, "bad data")
       @no_result = RightSupport::Net::NoResult.new("no result", {@url => bad_request})
-      lambda { @client.send(:handle_no_result, @no_result, @url, &@proc) }.should raise_error(bad_request)
+      lambda { @client.send(:handle_no_result, @no_result, @url, &@proc) }.
+          should raise_error(RightScale::HttpExceptions::BadRequest)
       @yielded.should == bad_request
     end
   end
@@ -528,27 +530,10 @@ describe RightScale::BalancedHttpClient do
     end
 
     context "when no exception" do
-
-      context "and Log.level is :info with no host" do
-        it "generates text containing path" do
-          text = @client.send(:log_text, @path, {:value => 123}, [])
-          text.should == "/foo/bar"
-        end
-      end
-
-      context "and Log.level is :info with host" do
-        it "generates text containing host and path" do
-          text = @client.send(:log_text, @path, {:value => 123}, [], @url)
-          text.should == "[http://my.com/foo/bar]"
-        end
-      end
-
-      context "and Log.level is :debug" do
-        it "generates text containing containing host, path, and filtered parameters" do
-          @log.should_receive(:level).and_return(:debug)
-          text = @client.send(:log_text, @path, {:some => "data", :secret => "data"}, ["secret"], @url)
-          text.should == "[http://my.com/foo/bar {:some=>\"data\", :secret=>\"<hidden>\"}]"
-        end
+      it "generates text containing containing host, path, and filtered parameters" do
+        @log.should_receive(:level).and_return(:debug)
+        text = @client.send(:log_text, @path, {:some => "data", :secret => "data"}, ["secret"], @url)
+        text.should == "[http://my.com/foo/bar {:some=>\"data\", :secret=>\"<hidden>\"}]"
       end
     end
 
@@ -591,6 +576,13 @@ describe RightScale::BalancedHttpClient do
     it "does not filter if params is not a hash" do
       @client.send(:filter, "params", ["secret"]).should == "params"
     end
+
+    it "also applies filters to any parameter named :payload or 'payload'" do
+      filter = ["secret", "very_secret"]
+      params = {:some => 1, :payload => {:secret => "data"}, "payload" => {:very_secret => "data"}, :secret => "data"}
+      @client.send(:filter, params, filter).should == {:some => 1, :payload => {:secret => "<hidden>"},
+                                                       "payload" => { :very_secret => "<hidden>"}, :secret => "<hidden>"}
+    end
   end
 
   context :split do

data/spec/clients/base_retry_client_spec.rb

@@ -89,7 +89,6 @@ describe RightScale::BaseRetryClient do
       options = @client.instance_variable_get(:@options)
       options[:retry_enabled].should be_nil
       options[:filter_params].should be_nil
-      options[:exception_callback].should be_nil
     end
 
     it "initiates connection and enables use if connected" do
@@ -214,7 +213,7 @@ describe RightScale::BaseRetryClient do
           end
 
           it "log error if callback fails" do
-            @log.should_receive(:error).with("Failed status callback", StandardError).once
+            @log.should_receive(:error).with("Failed status callback", StandardError, :caller).once
             @client.status { |t, s| raise StandardError, "test" }
             @client.send(:state=, state).should == state
           end
@@ -321,13 +320,13 @@ describe RightScale::BaseRetryClient do
     it "sets state to :disconnected and logs if server not responding" do
       e = RightScale::BalancedHttpClient::NotResponding.new("not responding", RightScale::HttpExceptions.create(503))
       @http_client.should_receive(:check_health).and_raise(e).once
-      @log.should_receive(:error).with("Failed test health check", RightScale::HttpException).once
+      @log.should_receive(:error).with("Failed test health check", RightScale::HttpException, :trace).once
       @client.send(:check_health).should == :disconnected
       @client.state.should == :disconnected
     end
 
     it "sets state to :disconnected and logs if exception unexpected" do
-      @log.should_receive(:error).with("Failed test health check", StandardError).once
+      @log.should_receive(:error).with("Failed test health check", StandardError, :caller).once
       @http_client.should_receive(:check_health).and_raise(StandardError).once
       @client.send(:check_health).should == :disconnected
       @client.state.should == :disconnected
@@ -387,14 +386,14 @@ describe RightScale::BaseRetryClient do
       it "logs error if exception is raised" do
         flexmock(EM::PeriodicTimer).should_receive(:new).and_return(@timer).and_yield
         flexmock(@client).should_receive(:enable_use).and_raise(StandardError).once
-        @log.should_receive(:error).with("Failed test reconnect", StandardError).once
+        @log.should_receive(:error).with("Failed test reconnect", StandardError, :caller).once
         @client.send(:reconnect).should be_true
         @client.state.should == :disconnected
       end
 
       it "resets the timer interval to the configured value" do
         @client.send(:reconnect); @client.instance_variable_set(:@reconnecting, nil) # to get @reconnect_timer initialized
-        @log.should_receive(:error).with("Failed test health check", StandardError).once
+        @log.should_receive(:error).with("Failed test health check", StandardError, :caller).once
         @http_client.should_receive(:check_health).and_raise(StandardError).once
         @timer.should_receive(:interval=).with(15).once
         flexmock(EM::PeriodicTimer).should_receive(:new).and_return(@timer).and_yield

data/spec/clients/non_blocking_client_spec.rb

@@ -404,6 +404,10 @@ describe RightScale::NonBlockingClient do
       @client.send(:handle_error, :get, Errno::ETIMEDOUT).should == [408, "Request timeout"]
     end
 
+    it "converts Errno::ECONNREFUSED to 503 ServiceUnavailable" do
+      @client.send(:handle_error, :get, Errno::ECONNREFUSED).should == [503, "Connection refused"]
+    end
+
     it "converts error to 500 InternalServerError by default" do
       @client.send(:handle_error, :get, "failed").should == [500, "failed"]
     end

data/spec/clients/router_client_spec.rb

@@ -470,7 +470,7 @@ describe RightScale::RouterClient do
       end
 
       it "adjusts connect interval if websocket creation fails and sets state to :long_poll" do
-        @log.should_receive(:error).with("Failed creating WebSocket", RuntimeError).once
+        @log.should_receive(:error).with("Failed creating WebSocket", RuntimeError, :caller).once
         flexmock(Faye::WebSocket::Client).should_receive(:new).and_raise(RuntimeError).once
         @client.send(:try_connect, @routing_keys, &@handler)
         @client.instance_variable_get(:@connect_interval).should == 60
@@ -661,7 +661,6 @@ describe RightScale::RouterClient do
         end
 
         it "handles exception if there is a long-polling failure" do
-          @log.should_receive(:error).with("Failed long-polling", RuntimeError, :trace).once
           @defer_callback_proc.call(RuntimeError.new).should be nil
           @client.instance_variable_get(:@listen_state).should == :choose
           @client.instance_variable_get(:@listen_interval).should == 4
@@ -745,7 +744,6 @@ describe RightScale::RouterClient do
        RightScale::Exceptions::RetryableError.new("error"),
        RightScale::Exceptions::InternalServerError.new("error", "server")].each do |e|
         it "does not trace #{e} exceptions but sets state to :choose" do
-          @log.should_receive(:error).with("Failed long-polling", e, :no_trace).once
           @client.send(:process_long_poll, e).should be nil
           @client.instance_variable_get(:@listen_state).should == :choose
           @client.instance_variable_get(:@listen_interval).should == 4
@@ -754,7 +752,6 @@ describe RightScale::RouterClient do
 
       it "traces unexpected exceptions and sets state to :choose" do
         e = RuntimeError.new
-        @log.should_receive(:error).with("Failed long-polling", e, :trace).once
         @client.send(:process_long_poll, e).should be nil
         @client.instance_variable_get(:@listen_state).should == :choose
         @client.instance_variable_get(:@listen_interval).should == 4

data/spec/dispatcher_spec.rb

@@ -26,7 +26,6 @@ class Foo
   include RightScale::Actor
   expose_idempotent :bar, :index, :i_kill_you
   expose_non_idempotent :bar_non
-  on_exception :handle_exception
 
   def index(payload)
     bar(payload)
@@ -47,34 +46,17 @@ class Foo
   def i_kill_you(payload)
     raise RuntimeError.new('I kill you!')
   end
-
-  def handle_exception(method, deliverable, error)
-  end
 end
 
 class Bar
   include RightScale::Actor
   expose :i_kill_you
-  on_exception do |method, deliverable, error|
-    @scope = self
-    @called_with = [method, deliverable, error]
-  end
 
   def i_kill_you(payload)
     raise RuntimeError.new('I kill you!')
   end
 end
 
-# No specs, simply ensures multiple methods for assigning on_exception callback,
-# on_exception raises exception when called with an invalid argument.
-class Doomed
-  include RightScale::Actor
-  on_exception do
-  end
-  on_exception lambda {}
-  on_exception :doh
-end
-
 describe "RightScale::Dispatcher" do
 
   include FlexMock::ArgumentTypes
@@ -89,7 +71,7 @@ describe "RightScale::Dispatcher" do
     @registry = RightScale::ActorRegistry.new
     @registry.register(@actor, nil)
     @agent_id = "rs-agent-1-1"
-    @agent = flexmock("Agent", :identity => @agent_id, :registry => @registry, :exception_callback => nil).by_default
+    @agent = flexmock("Agent", :identity => @agent_id, :registry => @registry).by_default
     @cache = RightScale::DispatchedCache.new(@agent_id)
     @dispatcher = RightScale::Dispatcher.new(@agent, @cache)
   end
@@ -157,41 +139,17 @@ describe "RightScale::Dispatcher" do
       lambda { @dispatcher.dispatch(req) }.should raise_error(RightScale::Dispatcher::InvalidRequestType)
     end
 
-    it "should call the on_exception callback if something goes wrong" do
-      @log.should_receive(:error).once
+    it "should log exception if dispatch fails" do
+      @log.should_receive(:error).with(/Failed dispatching/, RuntimeError, :trace).once
       req = RightScale::Request.new('/foo/i_kill_you', nil)
-      flexmock(@actor).should_receive(:handle_exception).with(:i_kill_you, req, Exception).once
-      res = @dispatcher.dispatch(req)
-      res.results.error?.should be_true
-      (res.results.content =~ /Could not handle \/foo\/i_kill_you request/).should be_true
-    end
-
-    it "should call on_exception Procs defined in a subclass with the correct arguments" do
-      @log.should_receive(:error).once
-      actor = Bar.new
-      @registry.register(actor, nil)
-      req = RightScale::Request.new('/bar/i_kill_you', nil)
       @dispatcher.dispatch(req)
-      called_with = actor.instance_variable_get("@called_with")
-      called_with[0].should == :i_kill_you
-      called_with[1].should == req
-      called_with[2].should be_kind_of(RuntimeError)
-      called_with[2].message.should == 'I kill you!'
     end
 
-    it "should call on_exception Procs defined in a subclass in the scope of the actor" do
+    it "should return error result if dispatch fails" do
       @log.should_receive(:error).once
-      actor = Bar.new
-      @registry.register(actor, nil)
-      req = RightScale::Request.new('/bar/i_kill_you', nil)
-      @dispatcher.dispatch(req)
-      actor.instance_variable_get("@scope").should == actor
-    end
-
-    it "should log error if dispatch fails" do
-      RightScale::Log.should_receive(:error).once
       req = RightScale::Request.new('/foo/i_kill_you', nil)
-      @dispatcher.dispatch(req)
+      res = @dispatcher.dispatch(req)
+      res.results.error?.should be_true
     end
 
     it "should reject requests whose time-to-live has expired" do
@@ -312,13 +270,6 @@ describe "RightScale::Dispatcher" do
       end
     end
 
-    it "should return error result if dispatch fails" do
-      @log.should_receive(:error).with(/Could not handle/, Exception, :trace).once
-      req = RightScale::Request.new('/foo/i_kill_you', nil)
-      res = @dispatcher.dispatch(req)
-      res.results.error?.should be_true
-    end
-
   end
 
 end # RightScale::Dispatcher

data/spec/error_tracker_spec.rb

@@ -0,0 +1,346 @@
+#
+# Copyright (c) 2014 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'hydraulic_brake'
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe RightScale::ErrorTracker do
+
+  include FlexMock::ArgumentTypes
+
+  class AgentMock; end
+
+  before(:each) do
+    @agent = AgentMock.new
+    @agent_name = "test_agent"
+    @shard_id = 9
+    @endpoint = "https://airbrake.com"
+    @api_key = "secret"
+    @trace_level = RightScale::Agent::TRACE_LEVEL
+    @tracker = RightScale::ErrorTracker.instance
+    @log = flexmock(RightScale::Log)
+    @brake = flexmock(HydraulicBrake)
+    @options = {
+      :shard_id => @shard_id,
+      :trace_level => @trace_level,
+      :airbrake_endpoint => @endpoint,
+      :airbrake_api_key => @api_key,
+      :filter_params => [:password] }
+  end
+
+  context :init do
+    it "initializes the tracker" do
+      flexmock(@tracker).should_receive(:notify_init).with(@agent_name, @options).once
+      @tracker.init(@agent, @agent_name, @options).should be true
+      @tracker.instance_variable_get(:@agent).should == @agent
+      @tracker.instance_variable_get(:@trace_level).should == @trace_level
+      @tracker.exception_stats.should be_a RightSupport::Stats::Exceptions
+    end
+  end
+
+  context :log do
+    before(:each) do
+      @tracker.init(@agent, @agent_name, :trace_level => @trace_level, :shard_id => @shard_id)
+    end
+
+    context "exception nil" do
+      it "logs description" do
+        @log.should_receive(:error).with("failed").once
+        @tracker.log(self, "failed").should be true
+      end
+    end
+
+    context "exception string" do
+      it "logs error string" do
+        @log.should_receive(:error).with("failed", "error").once
+        @tracker.log(self, "failed", "error").should be true
+      end
+    end
+
+    context "exception" do
+      it "logs exception" do
+        @log.should_receive(:error).with("failed", RuntimeError, :trace).once
+        @tracker.log(self, "failed", RuntimeError.new("error")).should be true
+      end
+
+      it "applies trace level configured for selected exceptions" do
+        @log.should_receive(:error).with("failed", RightScale::BalancedHttpClient::NotResponding, :no_trace).once
+        @tracker.log(self, "failed", RightScale::BalancedHttpClient::NotResponding.new("error")).should be true
+      end
+
+      it "applies specified trace level" do
+        @log.should_receive(:error).with("failed", RuntimeError, :caller).once
+        @tracker.log(self, "failed", RuntimeError.new("error"), nil, :caller).should be true
+      end
+
+      it "tracks exception statistics when component is not a string" do
+        request = RightScale::Request.new("/foo/bar", "payload")
+        @log.should_receive(:error).with("failed", RuntimeError, :trace).once
+        flexmock(@tracker).should_receive(:track).with(self, RuntimeError, request).once
+        @tracker.log(self, "failed", RuntimeError.new("error"), request).should be true
+      end
+
+      it "tracks exception statistics when component is a string" do
+        request = RightScale::Request.new("/foo/bar", "payload")
+        @log.should_receive(:error).once
+        flexmock(@tracker).should_receive(:track).with("test", RuntimeError, request).once
+        @tracker.log("test", "failed", RuntimeError.new("error"), request).should be true
+      end
+
+      it "does not track exception statistics for :no_trace" do
+        @log.should_receive(:error).once
+        flexmock(@tracker).should_receive(:track).never
+        @tracker.log(self, "failed", RuntimeError.new("error"), nil, :no_trace).should be true
+      end
+    end
+
+    it "logs error if error logging fails" do
+      @log.should_receive(:error).with("failed", RuntimeError, :trace).once.ordered
+      @log.should_receive(:error).with("Failed to log error", RuntimeError, :trace).once.ordered
+      flexmock(@tracker).should_receive(:track).and_raise(RuntimeError).once
+      @tracker.log(self, "failed", RuntimeError.new("error")).should be false
+    end
+
+    it "does not raise exception even if exception logging fails" do
+      @log.should_receive(:error).and_raise(RuntimeError).twice
+      @tracker.log(self, "failed").should be false
+    end
+  end
+
+  context :track do
+    before(:each) do
+      @now = Time.at(1000000)
+      flexmock(Time).should_receive(:now).and_return(@now)
+      @exception = RuntimeError.new("error")
+      @tracker.init(@agent, @agent_name, :trace_level => @trace_level, :shard_id => @shard_id)
+    end
+
+    it "records exception in stats when component is an object" do
+      @tracker.track(@agent, @exception).should be true
+      @tracker.exception_stats.all.should == {"agent_mock" => {"total" => 1, "recent" => [{"count" => 1, "when" => 1000000,
+                                              "type" => "RuntimeError", "message" => "error", "where" => nil}]}}
+    end
+
+    it "records exception in stats when component is a string" do
+      request = RightScale::Request.new("/foo/bar", "payload")
+      @tracker.track("test", @exception, request).should be true
+      @tracker.exception_stats.all.should == {"test" => {"total" => 1, "recent" => [{"count" => 1, "when" => 1000000,
+                                              "type" => "RuntimeError", "message" => "error", "where" => nil}]}}
+    end
+
+    it "only tracks if stats container exists" do
+      @tracker.instance_variable_set(:@exception_stats, nil)
+      request = RightScale::Request.new("/foo/bar", "payload")
+      @tracker.track("test", @exception, request).should be true
+      @tracker.exception_stats.should be nil
+    end
+  end
+
+  context :notify do
+    before(:each) do
+      @exception = RuntimeError.new("error")
+      @tracker.init(@agent, @agent_name, @options)
+      @cgi_data = @tracker.instance_variable_get(:@cgi_data)
+    end
+
+    it "sends notification using HydraulicBrake" do
+      @brake.should_receive(:notify).with(on { |a| a[:error_message] == "error" &&
+                                                   a[:error_class] == "RuntimeError" &&
+                                                   a[:backtrace].nil? &&
+                                                   ["test", "development"].include?(a[:environment_name]) &&
+                                                   a[:cgi_data].should == @cgi_data &&
+                                                   a.keys & [:component, :action, :parameters, :session_data] == [] }).once
+      @tracker.notify(@exception).should be true
+    end
+
+    it "includes packet data in notification" do
+      request = RightScale::Request.new("/foo/bar", {:pay => "load"}, :token => "token")
+      @brake.should_receive(:notify).with(on { |a| a[:error_message] == "error" &&
+                                                   a[:error_class] == "RuntimeError" &&
+                                                   a[:backtrace].nil? &&
+                                                   a[:action] == "bar" &&
+                                                   a[:parameters] == {:pay => "load"} &&
+                                                   ["test", "development"].include?(a[:environment_name]) &&
+                                                   a[:cgi_data] == @cgi_data &&
+                                                   a[:session_data] == {:uuid => "token"} }).once
+      @tracker.notify(@exception, request).should be true
+    end
+
+    it "includes event data in notification" do
+      @brake.should_receive(:notify).with(on { |a| a[:error_message] == "error" &&
+                                                   a[:error_class] == "RuntimeError" &&
+                                                   a[:backtrace].nil? &&
+                                                   a[:action] == "bar" &&
+                                                   a[:parameters] == {:pay => "load"} &&
+                                                   ["test", "development"].include?(a[:environment_name]) &&
+                                                   a[:cgi_data] == @cgi_data &&
+                                                   a[:session_data] == {:uuid => "token"} }).once
+      @tracker.notify(@exception, {"uuid" => "token", "path" => "/foo/bar", "data" => {:pay => "load"}}).should be true
+    end
+
+    it "adds agent class to :cgi_data in notification" do
+      @brake.should_receive(:notify).with(on { |a| a[:cgi_data] == @cgi_data.merge(:agent_class => "AgentMock") }).once
+      @tracker.notify(@exception, packet = nil, @agent).should be true
+    end
+
+    it "adds component to notification" do
+      @brake.should_receive(:notify).with(on { |a| a[:component] == "component" }).once
+      @tracker.notify(@exception, packet = nil, agent = nil, "component").should be true
+    end
+
+    it "converts non-nil, non-hash payload in packet to a hash" do
+      request = RightScale::Request.new("/foo/bar", "payload", :token => "token")
+      @brake.should_receive(:notify).with(on { |a| a[:parameters] == {:param => "payload"} }).once
+      @tracker.notify(@exception, request).should be true
+    end
+
+    it "converts non-nil, non-hash data in event to a hash" do
+      @brake.should_receive(:notify).with(on { |a| a[:parameters] == {:param => "payload"} }).once
+      @tracker.notify(@exception, {"uuid" => "token", "path" => "/foo/bar", "data" => "payload"}).should be true
+    end
+
+    it "omits :parameters from notification if payload in packet is nil" do
+      request = RightScale::Request.new("/foo/bar", nil, :token => "token")
+      @brake.should_receive(:notify).with(on { |a| !a.has_key?(:parameters) }).once
+      @tracker.notify(@exception, request).should be true
+    end
+
+    it "omits :parameters from notification if data in packet is nil" do
+      @brake.should_receive(:notify).with(on { |a| !a.has_key?(:parameters) }).once
+      @tracker.notify(@exception, {"uuid" => "token", "path" => "/foo/bar", "data" => nil}).should be true
+    end
+
+    it "functions even if cgi_data has not been initialized by notify_init" do
+      @tracker.instance_variable_set(:@cgi_data, nil)
+      @brake.should_receive(:notify).with(on { |a| a[:error_message] == "error" &&
+                                                   a[:error_class] == "RuntimeError" &&
+                                                   a[:backtrace].nil? &&
+                                                   ["test", "development"].include?(a[:environment_name]) &&
+                                                   a.keys & [:cgi_data, :component, :action, :parameters, :session_data] == [] }).once
+      @tracker.notify(@exception).should be true
+    end
+
+    it "does nothing if notify is disabled" do
+      @tracker.init(@agent, @agent_name, :trace_level => @trace_level, :shard_id => @shard_id)
+      @brake.should_receive(:notify).never
+      @tracker.notify(@exception).should be true
+    end
+  end
+
+  context :notify_callback do
+    it "returns proc that calls notify" do
+      @tracker.init(@agent, @agent_name, @options)
+      flexmock(@tracker).should_receive(:notify).with("exception", "packet", "agent", "component").once
+      @tracker.notify_callback.call("exception", "packet", "agent", "component")
+    end
+  end
+
+  context :stats do
+    before(:each) do
+      @now = Time.at(1000000)
+      flexmock(Time).should_receive(:now).and_return(@now)
+      @exception = RuntimeError.new("error")
+      @tracker.init(@agent, @agent_name, :trace_level => @trace_level, :shard_id => @shard_id)
+    end
+
+    it "returns exception stats" do
+      @tracker.track(@agent, @exception).should be true
+      @tracker.stats.should == {"exceptions" => {"agent_mock" => {"total" => 1, "recent" => [{"count" => 1,
+                                "when" => 1000000, "type" => "RuntimeError", "message" => "error", "where" => nil}]}}}
+    end
+
+    it "returns no exception stats if stats container not initialized" do
+      @tracker.instance_variable_set(:@exception_stats, nil)
+      @tracker.track(@agent, @exception).should be true
+      @tracker.stats.should == {"exceptions" => nil}
+    end
+
+    it "resets stats after collecting current stats" do
+      @tracker.track(@agent, @exception).should be true
+      @tracker.stats(true).should == {"exceptions" => {"agent_mock" => {"total" => 1, "recent" => [{"count" => 1,
+                                      "when" => 1000000, "type" => "RuntimeError", "message" => "error", "where" => nil}]}}}
+      @tracker.stats.should == {"exceptions" => nil}
+    end
+  end
+
+  context :notify_init do
+    class ConfigMock
+      attr_accessor :secure, :host, :port, :api_key, :project_root
+    end
+
+    it "does not initialize if Airbrake endpoint or API key is undefined" do
+      @brake.should_receive(:configure).never
+      @tracker.send(:notify_init, @agent_name, @options.merge(:airbrake_endpoint => nil))
+      @tracker.instance_variable_get(:@notify_enabled).should be false
+      @tracker.send(:notify_init, @agent_name, @options.merge(:airbrake_api_key => nil))
+      @tracker.instance_variable_get(:@notify_enabled).should be false
+    end
+
+    it "initializes cgi data and configures HydraulicBrake" do
+      config = ConfigMock.new
+      @brake.should_receive(:configure).and_yield(config).once
+      @tracker.send(:notify_init, @agent_name, @options).should be true
+      cgi_data = @tracker.instance_variable_get(:@cgi_data)
+      cgi_data[:agent_name].should == @agent_name
+      cgi_data[:pid].should be_a Integer
+      cgi_data[:process].should be_a String
+      cgi_data[:shard_id].should == @shard_id
+      config.secure.should be true
+      config.host.should == "airbrake.com"
+      config.port.should == 443
+      config.api_key.should == @api_key
+      config.project_root.should be_a String
+      @tracker.instance_variable_get(:@notify_enabled).should be true
+      @tracker.instance_variable_get(:@filter_params).should == ["password"]
+    end
+
+    it "raises exception if hydraulic_gem is not available" do
+      flexmock(@tracker).should_receive(:require_succeeds?).with("hydraulic_brake").and_return(false)
+      lambda do
+        @tracker.send(:notify_init, @agent_name, @options)
+      end.should raise_error(RuntimeError, /hydraulic_brake gem missing/)
+    end
+  end
+
+  context :filter do
+
+    before(:each) do
+      @params = {:user => "me", :password => "secret"}
+    end
+
+    it "applies filters" do
+      @tracker.init(@agent, @agent_name, @options)
+      @tracker.send(:filter, @params).should == {:user => "me", :password => "<hidden>"}
+    end
+
+    it "converts parameter names to string form before comparison" do
+      @tracker.init(@agent, @agent_name, @options)
+      @tracker.send(:filter, :user => "me", "password" => "secret").should == {:user => "me", "password" => "<hidden>"}
+    end
+
+    it "does not filter if no filters are specified" do
+      @tracker.init(@agent, @agent_name, @options.merge(:filter_params => nil))
+      @tracker.send(:filter, @params).should == @params
+    end
+  end
+end