right_agent 2.6.3 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 16d90487a104c3df9bda429bb53e65aea08986c3
-  data.tar.gz: 01b33304e25eb7399946c2a08db53a493dcfeb22
+  metadata.gz: 74c2e07823dff52a0a487855918d9fe020f4509b
+  data.tar.gz: b9fc140fd85dc787e63a04880e3b195024ca0f42
 SHA512:
-  metadata.gz: 740c5fc4895b8b39b36196908548b22f614af3bd1b69bcdd1784703c9363816b513e07c88c9ba01ce2c89c6ee2bf3041a9b02e262fc0e44baaa8a6a05bc8d570
-  data.tar.gz: cf41ede79b081d7db299440e0e4753751088bb093c2ce85b7dc3f615e510aba2d5c501ee082687b6a18ae1915825ec611b08cf832bd2ef4db19197a78cc1c135
+  metadata.gz: a17751f1a016b2e81cdebb0281449c90db0be2cf4e8c17062d54ce36ee29d1517c4d2c1686debf81f75c34f4ae054d109ff9b3f45453b9db27070affb3df7f9b
+  data.tar.gz: f5720ae5a981c8b54a6d3d811fc8f35e8c0ea8c02d573c29fc78e9011c28fbf33aa7d9d089c0337f2a653f250f120cc94fa0403337a23b98681f6728f3037a70

data/Rakefile

@@ -48,7 +48,6 @@ task :default => :spec
 
 desc 'Run unit tests'
 RSpec::Core::RakeTask.new do |t|
-  t.rspec_opts = RSPEC_OPTS
   t.pattern = Dir['**/*_spec.rb']
 end
 

data/lib/right_agent/clients/base_retry_client.rb

@@ -273,40 +273,57 @@ module RightScale
       end
     end
 
-    # Reconnect with server by periodically checking health
-    # Randomize when initially start checking to reduce server spiking
+    # If EventMachine reactor is running, begin attempting to periodically
+    # reconnect with server by checking health. Randomize initial attempt to
+    # reduce server spiking.
+    #
+    # If EventMachine reactor is NOT running, attempt to reconnect once
+    # and raise any exception that is encountered.
     #
     # @return [TrueClass] always true
     def reconnect
       unless @reconnecting
         @reconnecting = true
-        @stats["reconnects"].update("initiate")
-        @reconnect_timer = EM_S::PeriodicTimer.new(rand(@options[:reconnect_interval])) do
-          begin
-            create_http_client
-            if check_health == :connected
-              enable_use
-              # Check state again since may have disconnected during enable_use
-              if self.state == :connected
-                @stats["reconnects"].update("success")
-                @reconnect_timer.cancel if @reconnect_timer # only need 'if' for test purposes
-                @reconnect_timer = @reconnecting = nil
-              end
+
+        if EM.reactor_running?
+          @stats["reconnects"].update("initiate")
+          @reconnect_timer = EM_S::PeriodicTimer.new(rand(@options[:reconnect_interval])) do
+            begin
+              reconnect_once
+            rescue Exception => e
+              ErrorTracker.log(self, "Failed #{@options[:server_name]} reconnect", e, nil, :caller)
+              @stats["reconnects"].update("failure")
+              self.state = :disconnected
             end
-          rescue Exception => e
-            ErrorTracker.log(self, "Failed #{@options[:server_name]} reconnect", e, nil, :caller)
-            @stats["reconnects"].update("failure")
-            self.state = :disconnected
+            @reconnect_timer.interval = @options[:reconnect_interval] if @reconnect_timer
           end
-          @reconnect_timer.interval = @options[:reconnect_interval] if @reconnect_timer
+        else
+          reconnect_once
         end
       end
+
       true
     end
 
-    # Make request via HTTP
-    # Rely on underlying HTTP client to log request and response
-    # Retry request if response indicates to or if there are connectivity failures
+    # Attempt to reconnect exactly once. Perform no exception handling,
+    # state management, or scheduling of future reconnects, but cancel the
+    # reconnect timer if it exists and set @reconnecting, et al to nil.
+    def reconnect_once
+      create_http_client
+      if check_health == :connected
+        enable_use
+        # Check state again since may have disconnected during enable_use
+        if self.state == :connected
+          @stats["reconnects"].update("success")
+          @reconnect_timer.cancel if @reconnect_timer
+          @reconnect_timer = @reconnecting = nil
+        end
+      end
+    end
+
+    # Make request via HTTP. Attempt to reconnect first if disconnected and EM reactor is not running.
+    # Rely on underlying HTTP client to log request and response.
+    # Retry request if response indicates to or if there are connectivity failures.
     #
     # There are also several timeouts involved:
     #   - Underlying BalancedHttpClient connection open timeout (:open_timeout)
@@ -364,6 +381,7 @@ module RightScale
             :request_timeout => @options[:request_timeout],
             :request_uuid => request_uuid,
             :headers => headers }
+          reconnect_once if (:disconnected == state) && !EM.reactor_running?
           raise Exceptions::ConnectivityFailure, "#{@type} client not connected" unless [:connected, :closing].include?(state)
           result = @http_client.send(verb, path, params, http_options.merge(options))
         rescue StandardError => e

data/lib/right_agent/core_payload_types/login_user.rb

@@ -40,7 +40,7 @@ module RightScale
       @public_key   = args[2]
       @common_name  = args[3] || ''
       @superuser    = args[4] || false
-      @expires_at   = Time.at(args[5]) if args[5] && (args[5] != 0) # nil -> 0 because of expires_at.to_i below
+      @expires_at   = Time.at(args[5].to_i) if args[5] && (args[5] != 0) # nil -> 0 because of expires_at.to_i below
       @public_keys  = args[6]
       @profile_data = args[7]
       @public_key_fingerprints = args[8]

data/lib/right_agent/error_tracker.rb

@@ -14,7 +14,7 @@ module RightScale
   # Tracker for unexpected errors
   # Logs them with appropriate trace information
   # Accumulates statistics about exceptions
-  # Reports exceptions to external Errbit service via HydraulicBrake
+  # Reports exceptions to external Errbit service via Airbrake
   class ErrorTracker
 
     include RightSupport::Ruby::EasySingleton
@@ -104,36 +104,38 @@ module RightScale
     # @return [TrueClass] always true
     def notify(exception, packet = nil, agent = nil, component = nil)
       if @notify_enabled
-        data = {
-          :error_message => exception.respond_to?(:message) ? exception.message : exception.to_s,
-          :backtrace => exception.respond_to?(:backtrace) ? exception.backtrace : caller,
-          :environment_name => ENV["RAILS_ENV"],
-        }
-        if agent
-          data[:cgi_data] = (@cgi_data || {}).merge(:agent_class => agent.class.name)
-        elsif @cgi_data
-          data[:cgi_data] = @cgi_data
-        end
-        data[:error_class] = exception.class.name if exception.is_a?(Exception)
-        data[:component] = component if component
         if packet && packet.is_a?(Packet)
-          data[:action] = packet.type.split("/").last if packet.respond_to?(:type)
+          action = packet.type.split("/").last if packet.respond_to?(:type)
           params = packet.respond_to?(:payload) && packet.payload
           uuid = packet.respond_to?(:token) && packet.token
         elsif packet.is_a?(Hash)
-          action = packet[:path] || packet["path"]
-          data[:action] = action.split("/").last if action
+          action_path = packet[:path] || packet["path"]
+          action = action_path.split("/").last if action_path
           params = packet[:data] || packet["data"]
           uuid = packet[:uuid] || packet["uuid"]
         else
           params = uuid = nil
         end
-        data[:parameters] = params.is_a?(Hash) ? filter(params) : {:param => params} if params
-        data[:session_data] = {:uuid => uuid} if uuid
-        HydraulicBrake.notify(data)
+
+        n = Airbrake.build_notice(
+          exception,
+          { component: component, action: action },
+          :right_agent )
+
+        n[:params] = params.is_a?(Hash) ? filter(params) : {:param => params} if params
+        n[:session] = { :uuid => uuid } if uuid
+
+        if agent
+          n[:environment] = (@cgi_data || {}).merge(:agent_class => agent.class.name)
+        elsif @cgi_data
+          n[:environment] = @cgi_data || {}
+        end
+
+        Airbrake.notify(n, {}, :right_agent)
       end
       true
     rescue Exception => e
+      raise if e.class.name =~ /^RSpec/ # keep us from going insane while running tests
       Log.error("Failed to notify Errbit", e, :trace)
     end
 
@@ -168,7 +170,7 @@ module RightScale
       @exception_stats.reset
     end
 
-    # Configure HydraulicBreak for exception notification
+    # Configure Airbrake for exception notification
     #
     # @param [String] agent_name uniquely identifying agent process on given server
     #
@@ -181,11 +183,11 @@ module RightScale
     #
     # @return [TrueClass] always true
     #
-    # @raise [RuntimeError] hydraulic_brake gem missing
+    # @raise [RuntimeError] airbrake gem missing
     def notify_init(agent_name, options)
       if options[:airbrake_endpoint] && options[:airbrake_api_key]
-        unless require_succeeds?("hydraulic_brake")
-          raise RuntimeError, "hydraulic_brake gem missing - required if airbrake options used in ErrorTracker"
+        unless require_succeeds?("airbrake-ruby")
+          raise RuntimeError, "airbrake-ruby gem missing - required if airbrake options used in ErrorTracker"
         end
 
         @cgi_data = {
@@ -194,21 +196,23 @@ module RightScale
           :agent_name => agent_name
         }
         @cgi_data[:shard_id] = options[:shard_id] if options[:shard_id]
-        @cgi_data[:sha] = CURRENT_SOURCE_SHA if defined?(CURRENT_SOURCE_SHA)
-
-        uri = URI.parse(options[:airbrake_endpoint])
-        HydraulicBrake.configure do |config|
-          config.secure = (uri.scheme == "https")
-          config.host = uri.host
-          config.port = uri.port
-          config.api_key = options[:airbrake_api_key]
-          config.project_root = AgentConfig.root_dir
-        end
         @filter_params = (options[:filter_params] || []).map { |p| p.to_s }
         @notify_enabled = true
+
+        return true if Airbrake.send(:configured?, :right_agent)
+
+        Airbrake.configure(:right_agent) do |config|
+          config.host = options[:airbrake_endpoint]
+          config.project_id = options[:airbrake_api_key]
+          config.project_key = options[:airbrake_api_key]
+          config.root_directory = AgentConfig.root_dir
+          config.environment = ENV['RAILS_ENV']
+          config.app_version = CURRENT_SOURCE_SHA if defined?(CURRENT_SOURCE_SHA)
+        end
       else
         @notify_enabled = false
       end
+
       true
     end
 

data/lib/right_agent/log.rb

@@ -416,22 +416,21 @@ module RightScale
 
     # Initialize logger
     #
-    # === Parameters
-    # identity(String):: Log identity
-    # path(String):: Log directory path
-    # opts[:force](TrueClass|FalseClass):: Whether to re-initialize if logger
-    #                                      is already initialized
-    # opts[:print](TrueClass|FalseClass):: Whether to print to STDOUT log destination
+    # @param [String] identity RightNet identity (for log file name or syslog program name)
+    # @param [String] path directory to create log files in
+    # @option opts [Boolean] :force whether to re-initialize if logger is already initialized
+    # @option opts [Boolean] :print whether to print log-location info to STDOUT
     #
-    # === Return
-    # logger(RightScale::Multiplexer):: logger instance
+    # @return [RightScale::Multiplexer] logger instance
     def init(identity=nil, path=nil, opts={})
       if opts[:force] || !@initialized
         @initialized = true
         @level_frozen = false
-        logger = nil
+        logger = opts[:logger]
 
-        if @log_to_file_only || Platform.windows?
+        if !logger.nil?
+          $stderr.puts "Logging to already-initialized #{logger.class.name}" if opts[:print]
+        elsif @log_to_file_only || Platform.windows?
           if path
             file = File.join(path, "#{identity}.log")
           else

data/right_agent.gemspec

@@ -25,8 +25,8 @@ require 'rbconfig'
 
 Gem::Specification.new do |spec|
   spec.name      = 'right_agent'
-  spec.version   = '2.6.3'
-  spec.date      = '2015-09-16'
+  spec.version   = '2.7.0'
+  spec.date      = '2016-05-20'
   spec.authors   = ['Lee Kirchhoff', 'Raphael Simon', 'Tony Spataro', 'Scott Messier']
   spec.email     = 'lee@rightscale.com'
   spec.homepage  = 'https://github.com/rightscale/right_agent'
@@ -44,7 +44,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency('faye-websocket', '~> 0.7.0')
   spec.add_dependency('eventmachine', ['>= 0.12.10', '< 2.0'])
   spec.add_dependency('net-ssh', '~> 2.0')
-  spec.add_dependency('addressable', '~> 2.3', '< 2.4')
+  spec.add_dependency('addressable', '~> 2.3')
 
   # TEAL HACK: rake gem may override current RUBY_PLATFORM to allow building
   # gems for all supported platforms from any platform. rubygems 1.8.x makes it

data/spec/clients/base_retry_client_spec.rb

@@ -34,6 +34,7 @@ describe RightScale::BaseRetryClient do
     @log.should_receive(:warning).by_default.and_return { |m| raise RightScale::Log.format(*m) }
     @url = "http://test.com"
     @timer = flexmock("timer", :cancel => true, :interval= => 0).by_default
+    flexmock(EM).should_receive(:reactor_running?).and_return(true).by_default
     flexmock(EM::PeriodicTimer).should_receive(:new).and_return(@timer).by_default
     @http_client = flexmock("http client", :get => true, :check_health => true, :close => true).by_default
     flexmock(RightScale::BalancedHttpClient).should_receive(:new).and_return(@http_client).by_default
@@ -338,82 +339,102 @@ describe RightScale::BaseRetryClient do
       @client.instance_variable_set(:@reconnecting, nil)
     end
 
-    it "waits random interval for initial reconnect attempt" do
-      flexmock(@client).should_receive(:rand).with(15).and_return(10).once
-      flexmock(EM::PeriodicTimer).should_receive(:new).with(10, Proc).and_return(@timer).once
-      @client.send(:reconnect).should be_true
-    end
-
-    it "attempts to connect even if currently connected" do
-      flexmock(EM::PeriodicTimer).should_receive(:new).and_return(@timer).and_yield
-      @client.send(:create_http_client)
-      @client.send(:check_health).should == :connected
-      flexmock(@client).should_receive(:check_health).once
-      @client.send(:reconnect).should be_true
-    end
-
-    it "recreates HTTP client and checks health" do
-      flexmock(EM::PeriodicTimer).should_receive(:new).and_return(@timer).and_yield
-      flexmock(RightScale::BalancedHttpClient).should_receive(:new).and_return(@http_client).once
-      @http_client.should_receive(:check_health).once
-      @client.send(:reconnect).should be_true
-    end
-
-    context "when health check successful" do
-      it "enables use of client" do
-        flexmock(EM::PeriodicTimer).should_receive(:new).and_return(@timer).and_yield
-        flexmock(@client).should_receive(:enable_use).once
+    context 'given EventMachine is running' do
+      it "waits random interval for initial reconnect attempt" do
+        flexmock(@client).should_receive(:rand).with(15).and_return(10).once
+        flexmock(EM::PeriodicTimer).should_receive(:new).with(10, Proc).and_return(@timer).once
         @client.send(:reconnect).should be_true
       end
 
-      it "rechecks state after enables use" do
+      it "attempts to connect even if currently connected" do
         flexmock(EM::PeriodicTimer).should_receive(:new).and_return(@timer).and_yield
-        flexmock(@client).should_receive(:enable_use).and_return { @client.instance_variable_set(:@state, :disconnected) }.once
+        @client.send(:create_http_client)
+        @client.send(:check_health).should == :connected
+        flexmock(@client).should_receive(:check_health).once
         @client.send(:reconnect).should be_true
-        @client.instance_variable_get(:@reconnecting).should be true
       end
 
-      it "disables timer" do
-        @client.send(:reconnect); @client.instance_variable_set(:@reconnecting, nil) # to get @reconnect_timer initialized
-        @client.instance_variable_set(:@reconnecting, nil)
-        @timer.should_receive(:cancel).once
+      it "recreates HTTP client and checks health" do
         flexmock(EM::PeriodicTimer).should_receive(:new).and_return(@timer).and_yield
+        flexmock(RightScale::BalancedHttpClient).should_receive(:new).and_return(@http_client).once
+        @http_client.should_receive(:check_health).once
         @client.send(:reconnect).should be_true
-        @client.instance_variable_get(:@reconnecting).should be_nil
       end
 
-      it "does not reset timer interval" do
-        @timer.should_receive(:interval=).never
-        flexmock(EM::PeriodicTimer).should_receive(:new).and_return(@timer).and_yield
+      context "when health check successful" do
+        it "enables use of client" do
+          flexmock(EM::PeriodicTimer).should_receive(:new).and_return(@timer).and_yield
+          flexmock(@client).should_receive(:enable_use).once
+          @client.send(:reconnect).should be_true
+        end
+
+        it "rechecks state after enables use" do
+          flexmock(EM::PeriodicTimer).should_receive(:new).and_return(@timer).and_yield
+          flexmock(@client).should_receive(:enable_use).and_return { @client.instance_variable_set(:@state, :disconnected) }.once
+          @client.send(:reconnect).should be_true
+          @client.instance_variable_get(:@reconnecting).should be true
+        end
+
+        it "disables timer" do
+          @client.send(:reconnect); @client.instance_variable_set(:@reconnecting, nil) # to get @reconnect_timer initialized
+          @client.instance_variable_set(:@reconnecting, nil)
+          @timer.should_receive(:cancel).once
+          flexmock(EM::PeriodicTimer).should_receive(:new).and_return(@timer).and_yield
+          @client.send(:reconnect).should be_true
+          @client.instance_variable_get(:@reconnecting).should be_nil
+        end
+
+        it "does not reset timer interval" do
+          @timer.should_receive(:interval=).never
+          flexmock(EM::PeriodicTimer).should_receive(:new).and_return(@timer).and_yield
+          @client.send(:reconnect).should be_true
+        end
+      end
+
+      context "when reconnect fails" 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, :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, :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
+          @client.send(:reconnect).should be_true
+        end
+      end
+
+      it "does nothing if already reconnecting" do
+        flexmock(EM::PeriodicTimer).should_receive(:new).and_return(@timer).once
+        @client.send(:reconnect).should be_true
+        @client.instance_variable_get(:@reconnecting).should be_true
         @client.send(:reconnect).should be_true
+        @client.instance_variable_get(:@reconnecting).should be_true
       end
     end
 
-    context "when reconnect fails" 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, :caller).once
-        @client.send(:reconnect).should be_true
-        @client.state.should == :disconnected
+    context 'given EventMachine is inactive' do
+      before(:each) do
+        flexmock(EM).should_receive(:reactor_running?).and_return(false)
       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, :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
+      it "tries once" do
         @client.send(:reconnect).should be_true
       end
-    end
 
-    it "does nothing if already reconnecting" do
-      flexmock(EM::PeriodicTimer).should_receive(:new).and_return(@timer).once
-      @client.send(:reconnect).should be_true
-      @client.instance_variable_get(:@reconnecting).should be_true
-      @client.send(:reconnect).should be_true
-      @client.instance_variable_get(:@reconnecting).should be_true
+      it "raises exceptions" do
+        lambda do
+          flexmock(@client).should_receive(:create_http_client).and_raise(Exception)
+
+          @client.send(:reconnect)
+        end.should raise_error(Exception)
+      end
     end
   end
 
@@ -431,6 +452,26 @@ describe RightScale::BaseRetryClient do
       @client.init(:test, @auth_client, @options)
     end
 
+    context 'given EventMachine is inactive' do
+      before(:each) do
+        flexmock(EM).should_receive(:reactor_running?).and_return(false)
+      end
+
+      it 'reconnects if necessary' do
+        @client.instance_variable_set(:@state, :disconnected)
+        @http_client.should_receive(:get).with(@path, @params, Hash).once
+        @client.send(:make_request, :get, @path, @params)
+      end
+
+      it 'raises connection errors' do
+        @client.instance_variable_set(:@state, :disconnected)
+        @http_client.should_receive(:check_health).and_raise(Exception)
+        lambda {
+          @client.send(:make_request, :get, @path, @params)
+        }.should raise_error(Exception)
+      end
+    end
+
     it "raises exception if terminating" do
       @client.close
       lambda { @client.send(:make_request, :get, @path) }.should raise_error(RightScale::Exceptions::Terminating)

data/spec/error_tracker_spec.rb

@@ -20,7 +20,7 @@
 # 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 'airbrake-ruby'
 
 require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
 
@@ -39,7 +39,7 @@ describe RightScale::ErrorTracker do
     @trace_level = RightScale::Agent::TRACE_LEVEL
     @tracker = RightScale::ErrorTracker.instance
     @log = flexmock(RightScale::Log)
-    @brake = flexmock(HydraulicBrake)
+    @brake = flexmock(Airbrake)
     @options = {
       :shard_id => @shard_id,
       :trace_level => @trace_level,
@@ -161,82 +161,97 @@ describe RightScale::ErrorTracker do
       @exception = RuntimeError.new("error")
       @tracker.init(@agent, @agent_name, @options)
       @cgi_data = @tracker.instance_variable_get(:@cgi_data)
+      ENV['RAILS_ENV'] = 'development'
     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
+    after(:each) do
+      ENV['RAILS_ENV'] = nil
+    end
+
+    it "sends notification using Airbrake" do
+      @brake.should_receive(:notify).with(on { |a|
+        a[:errors].first[:type] == "RuntimeError" &&
+        a[:environment] == @cgi_data
+      }, {}, :right_agent).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
+      @brake.should_receive(:notify).with(on { |a|
+        a[:errors].first[:message] == "error" &&
+        a[:context][:action] == 'bar' &&
+        a[:params] == { :pay => 'load' } &&
+        a[:session] == { :uuid => 'token' }
+      }, {}, :right_agent).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
+      @brake.should_receive(:notify).with(on { |a|
+        a[:errors].first[:message] == "error" &&
+        a[:errors].first[:type] == "RuntimeError" &&
+        a[:context][:action] == 'bar' &&
+        a[:params] == { :pay => 'load' } &&
+        a[:session] == { :uuid => 'token' }
+      }, {}, :right_agent).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
+      @brake.should_receive(:notify).with(on { |a|
+        a[:environment] == @cgi_data.merge(:agent_class => 'AgentMock')
+      }, {}, :right_agent).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
+      @brake.should_receive(:notify).with(on { |a|
+        a[:context][:component] == 'component'
+      }, {}, :right_agent).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
+      @brake.should_receive(:notify).with(on { |a|
+        a[:params] == { :param => 'payload' }
+      }, {}, :right_agent).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
+      @brake.should_receive(:notify).with(on { |a|
+        a[:params] == { :param => 'payload' }
+      }, {}, :right_agent).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
+      @brake.should_receive(:notify).with(on { |a|
+        a[:params] == {}
+      }, {}, :right_agent).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
+      @brake.should_receive(:notify).with(on { |a|
+        a[:params] == {}
+      }, {}, :right_agent).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
+      @brake.should_receive(:notify).with(on { |a|
+        a[:errors].first[:message] == "error" &&
+        a[:errors].first[:type] == "RuntimeError" &&
+        a[:environment] == {}
+      }, {}, :right_agent).once
       @tracker.notify(@exception).should be true
     end
 
@@ -285,7 +300,7 @@ describe RightScale::ErrorTracker do
 
   context :notify_init do
     class ConfigMock
-      attr_accessor :secure, :host, :port, :api_key, :project_root
+      attr_accessor :host, :api_key, :project_id, :project_key, :root_directory, :environment
     end
 
     it "does not initialize if Airbrake endpoint or API key is undefined" do
@@ -296,7 +311,10 @@ describe RightScale::ErrorTracker do
       @tracker.instance_variable_get(:@notify_enabled).should be false
     end
 
-    it "initializes cgi data and configures HydraulicBrake" do
+    it "initializes cgi data and configures Airbrake" do
+      # dirty, but we need to make sure this is unset in order to progress
+      Airbrake.instance_variable_set(:@notifiers, {})
+
       config = ConfigMock.new
       @brake.should_receive(:configure).and_yield(config).once
       @tracker.send(:notify_init, @agent_name, @options).should be true
@@ -305,20 +323,19 @@ describe RightScale::ErrorTracker do
       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
+      config.host.should == "https://airbrake.com"
+      config.project_id.should == @api_key
+      config.project_key.should == @api_key
+      config.root_directory.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)
+    it "raises exception if airbrake-ruby is not available" do
+      flexmock(@tracker).should_receive(:require_succeeds?).with("airbrake-ruby").and_return(false)
       lambda do
         @tracker.send(:notify_init, @agent_name, @options)
-      end.should raise_error(RuntimeError, /hydraulic_brake gem missing/)
+      end.should raise_error(RuntimeError, /airbrake-ruby gem missing/)
     end
   end
 

data/spec/spec_helper.rb

@@ -23,6 +23,12 @@
 require 'rubygems'
 require 'bundler/setup'
 
+begin
+  require 'pry'
+rescue LoadError
+  #no-op; optional dependency
+end
+
 require 'rspec'
 require 'flexmock'
 require 'simplecov'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: right_agent
 version: !ruby/object:Gem::Version
-  version: 2.6.3
+  version: 2.7.0
 platform: ruby
 authors:
 - Lee Kirchhoff
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-16 00:00:00.000000000 Z
+date: 2016-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: right_support
@@ -116,9 +116,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.3'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -126,9 +123,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.3'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2.4'
 - !ruby/object:Gem::Dependency
   name: ffi
   requirement: !ruby/object:Gem::Requirement
@@ -376,8 +370,6 @@ files:
 - spec/serialize/secure_serializer_spec.rb
 - spec/serialize/serializable_spec.rb
 - spec/serialize/serializer_spec.rb
-- spec/spec.opts
-- spec/spec.win32.opts
 - spec/spec_helper.rb
 - spec/tracer_spec.rb
 homepage: https://github.com/rightscale/right_agent
@@ -403,9 +395,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.2.5
 signing_key: 
 specification_version: 4
 summary: Agent for interfacing server with RightScale system
 test_files: []
-has_rdoc: true

data/spec/spec.opts

@@ -1,2 +0,0 @@
---colour
---format=nested

data/spec/spec.win32.opts

@@ -1 +0,0 @@
---format=nested