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

data/lib/right_agent/agent_config.rb

@@ -64,7 +64,7 @@ module RightScale
   module AgentConfig
 
     # Current agent protocol version
-    PROTOCOL_VERSION = 23
+    PROTOCOL_VERSION = 24
 
     # Current agent protocol version
     #

data/lib/right_agent/agent_tag_manager.rb

@@ -185,7 +185,7 @@ module RightScale
       request = RightScale::RetryableRequest.new("/router/query_tags", payload, request_options)
       request.callback { |result| yield raw ? request.raw_response : result }
       request.errback do |message|
-        Log.error("Failed to query tags (#{message})")
+        ErrorTracker.log(self, "Failed to query tags (#{message})")
         yield((raw ? request.raw_response : nil) || message)
       end
       request.run

data/lib/right_agent/clients/api_client.rb

@@ -83,7 +83,6 @@ module RightScale
     # @option options [Array] :retry_intervals between successive retries; defaults to DEFAULT_RETRY_INTERVALS
     # @option options [Boolean] :retry_enabled for requests that fail to connect or that return a retry result
     # @option options [Numeric] :reconnect_interval for reconnect attempts after lose connectivity
-    # @option options [Proc] :exception_callback for unexpected exceptions
     #
     # @raise [ArgumentError] auth client does not support this client type
     def initialize(auth_client, options)
@@ -102,6 +101,7 @@ module RightScale
     # @param [String, Hash, NilClass] target for request, which may be identity of specific
     #   target, hash for selecting potentially multiple targets, or nil if routing solely
     #   using type; hash may contain:
+    #   [String] :agent_id serialized identity of specific target
     #   [Array] :tags that must all be associated with a target for it to be selected
     #   [Hash] :scope for restricting routing which may contain:
     #     [Integer] :account id that agents must be associated with to be included
@@ -140,6 +140,7 @@ module RightScale
     # @param [String, Hash, NilClass] target for request, which may be identity of specific
     #   target, hash for selecting targets of which one is picked randomly, or nil if routing solely
     #   using type; hash may contain:
+    #   [String] :agent_id serialized identity of specific target
     #   [Array] :tags that must all be associated with a target for it to be selected
     #   [Hash] :scope for restricting routing which may contain:
     #     [Integer] :account id that agents must be associated with to be included

data/lib/right_agent/clients/auth_client.rb

@@ -175,7 +175,6 @@ module RightScale
     #
     # @return [Hash] current statistics
     #   [Hash, NilClass] "state" Activity stats or nil if none
-    #   [Hash, NilClass] "exceptions" Exceptions stats or nil if none
     def stats(reset = false)
       stats = {}
       @stats.each { |k, v| stats[k] = v.all }
@@ -189,9 +188,7 @@ module RightScale
     #
     # @return [TrueClass] always true
     def reset_stats
-      @stats = {
-        "state" => RightSupport::Stats::Activity.new,
-        "exceptions" => RightSupport::Stats::Exceptions.new(agent = nil, @exception_callback)}
+      @stats = {"state" => RightSupport::Stats::Activity.new}
       true
     end
 
@@ -246,8 +243,7 @@ module RightScale
             begin
               callback.call(:auth, @state)
             rescue StandardError => e
-              Log.error("Failed status callback", e)
-             @stats["exceptions"].track("status", e)
+              ErrorTracker.log(self, "Failed status callback", e, nil, :caller)
             end
           end
         end

data/lib/right_agent/clients/balanced_http_client.rb

@@ -59,6 +59,9 @@ module RightScale
     # Text used for filtered parameter value
     FILTERED_PARAM_VALUE = "<hidden>"
 
+    # Parameters whose contents are also to have filtering applied
+    CONTENT_FILTERED_PARAMS = ["payload"]
+
     # Environment variables to examine for proxy settings, in order
     PROXY_ENVIRONMENT_VARIABLES = ['HTTPS_PROXY', 'https_proxy', 'HTTP_PROXY', 'http_proxy', 'ALL_PROXY']
 
@@ -71,7 +74,8 @@ module RightScale
     # @option options [String] :health_check_path in URI for health check resource;
     #   defaults to DEFAULT_HEALTH_CHECK_PATH
     # @option options [Array] :filter_params symbols or strings for names of request parameters
-    #   whose values are to be hidden when logging; can be augmented on individual requests
+    #   whose values are to be hidden when logging; also applied to contents of any parameters
+    #   in CONTENT_FILTERED_PARAMS; can be augmented on individual requests
     # @option options [Boolean] :non_blocking i/o is to be used for HTTP requests by applying
     #   EM::HttpRequest and fibers instead of RestClient; requests remain synchronous
     def initialize(urls, options = {})
@@ -140,9 +144,9 @@ module RightScale
     # @option options [Numeric] :open_timeout maximum wait for connection; defaults to DEFAULT_OPEN_TIMEOUT
     # @option options [Numeric] :request_timeout maximum wait for response; defaults to DEFAULT_REQUEST_TIMEOUT
     # @option options [String] :request_uuid uniquely identifying request; defaults to random generated UUID
-    # @option options [Array] :filter_params symbols or strings for names of request
-    #   parameters whose values are to be hidden when logging in addition to the ones
-    #   provided during object initialization
+    # @option options [Array] :filter_params symbols or strings for names of request parameters whose
+    #   values are to be hidden when logging in addition to the ones provided during object initialization;
+    #   also applied to contents of any parameters named :payload
     # @option options [Hash] :headers to be added to request
     # @option options [Numeric] :poll_timeout maximum wait for individual poll; defaults to :request_timeout
     # @option options [Symbol] :log_level to use when logging information about the request other than errors;
@@ -178,7 +182,7 @@ module RightScale
       e2 = HttpExceptions.convert(e)
       log_failure(used[:host], path, params, filter, request_uuid, started_at, e2)
       raise e2
-    rescue Exception => e
+    rescue StandardError => e
       log_failure(used[:host], path, params, filter, request_uuid, started_at, e)
       raise
     end
@@ -345,7 +349,7 @@ module RightScale
     def log_failure(host, path, params, filter, request_uuid, started_at, exception)
       code = exception.respond_to?(:http_code) ? exception.http_code : "nil"
       duration = "%.0fms" % ((Time.now - started_at) * 1000)
-      Log.error("Failed <#{request_uuid}> in #{duration} | #{code} " + log_text(path, params, filter, host, exception))
+      ErrorTracker.log(self, "Failed <#{request_uuid}> in #{duration} | #{code} " + log_text(path, params, filter, host, exception))
       true
     end
 
@@ -359,8 +363,7 @@ module RightScale
     #
     # @return [String] Log text
     def log_text(path, params, filter, host = nil, exception = nil)
-      filtered_params = (exception || Log.level == :debug) ? filter(params, filter).inspect : nil
-      text = filtered_params ? "#{path} #{filtered_params}" : path
+      text = "#{path} #{filter(params, filter).inspect}"
       text = "[#{host}#{text}]" if host
       text << " | #{self.class.exception_text(exception)}" if exception
       text
@@ -368,8 +371,9 @@ module RightScale
 
     # Apply parameter hiding filter
     #
-    # @param [Hash, Object] params to be filtered
-    # @param [Array] filter names of params as strings (not symbols) whose value is to be hidden
+    # @param [Hash, Object] params to be filtered with strings or symbols as keys
+    # @param [Array] filter names of params as strings (not symbols) whose value is to be hidden;
+    #   also filter the contents of any CONTENT_FILTERED_PARAMS
     #
     # @return [Hash] filtered parameters
     def filter(params, filter)
@@ -377,7 +381,14 @@ module RightScale
         params
       else
         filtered_params = {}
-        params.each { |k, p| filtered_params[k] = filter.include?(k.to_s) ? FILTERED_PARAM_VALUE : p }
+        params.each do |k, p|
+          s = k.to_s
+          if filter.include?(s)
+            filtered_params[k] = FILTERED_PARAM_VALUE
+          else
+            filtered_params[k] = CONTENT_FILTERED_PARAMS.include?(s) ? filter(p, filter) : p
+          end
+        end
         filtered_params
       end
     end

data/lib/right_agent/clients/base_retry_client.rb

@@ -76,8 +76,8 @@ module RightScale
     # @option options [Boolean] :non_blocking i/o is to be used for HTTP requests by applying
     #   EM::HttpRequest and fibers instead of RestClient; requests remain synchronous
     # @option options [Array] :filter_params symbols or strings for names of request parameters
-    #   whose values are to be hidden when logging; can be augmented on individual requests
-    # @option options [Proc] :exception_callback for unexpected exceptions
+    #   whose values are to be hidden when logging; also applied to contents of any parameters
+    #   named :payload; can be augmented on individual requests
     #
     # @return [Boolean] whether currently connected
     #
@@ -159,13 +159,10 @@ module RightScale
     #   [Hash, NilClass] "reconnects" Activity stats or nil if none
     #   [Hash, NilClass] "request failures" Activity stats or nil if none
     #   [Hash, NilClass] "request sent" Activity stats or nil if none
-    #   [Float, NilClass] "response time" average number of seconds to respond to a request or nil if none
     #   [Hash, NilClass] "state" Activity stats or nil if none
-    #   [Hash, NilClass] "exceptions" Exceptions stats or nil if none
     def stats(reset = false)
       stats = {}
       @stats.each { |k, v| stats[k] = v.all }
-      stats["response time"] = @stats["requests sent"].avg_duration
       reset_stats if reset
       stats
     end
@@ -180,8 +177,7 @@ module RightScale
         "reconnects"       => RightSupport::Stats::Activity.new,
         "request failures" => RightSupport::Stats::Activity.new,
         "requests sent"    => RightSupport::Stats::Activity.new,
-        "state"            => RightSupport::Stats::Activity.new,
-        "exceptions"       => RightSupport::Stats::Exceptions.new(agent = nil, @options[:exception_callback]) }
+        "state"            => RightSupport::Stats::Activity.new }
       true
     end
 
@@ -212,8 +208,7 @@ module RightScale
               begin
                 callback.call(@type, @state)
               rescue StandardError => e
-                Log.error("Failed status callback", e)
-                @stats["exceptions"].track("status", e)
+                ErrorTracker.log(self, "Failed status callback", e, nil, :caller)
               end
             end
             reconnect if @state == :disconnected
@@ -248,9 +243,8 @@ module RightScale
     def close_http_client(reason)
       @http_client.close(reason) if @http_client
       true
-    rescue Exception => e
-      Log.error("Failed closing connection", e, :trace)
-      @stats["exceptions"].track("status", e)
+    rescue StandardError => e
+      ErrorTracker.log(self, "Failed closing connection", e)
       false
     end
 
@@ -271,11 +265,10 @@ module RightScale
         @http_client.check_health
         self.state = :connected
       rescue BalancedHttpClient::NotResponding => e
-        Log.error("Failed #{@options[:server_name]} health check", e.nested_exception)
+        ErrorTracker.log(self, "Failed #{@options[:server_name]} health check", e.nested_exception)
         self.state = :disconnected
-      rescue Exception => e
-        Log.error("Failed #{@options[:server_name]} health check", e)
-        @stats["exceptions"].track("check health", e)
+      rescue StandardError => e
+        ErrorTracker.log(self, "Failed #{@options[:server_name]} health check", e, nil, :caller)
         self.state = :disconnected
       end
     end
@@ -298,9 +291,8 @@ module RightScale
               @reconnect_timer = @reconnecting = nil
             end
           rescue Exception => e
-            Log.error("Failed #{@options[:server_name]} reconnect", e)
+            ErrorTracker.log(self, "Failed #{@options[:server_name]} reconnect", e, nil, :caller)
             @stats["reconnects"].update("failure")
-            @stats["exceptions"].track("reconnect", e)
             self.state = :disconnected
           end
           @reconnect_timer.interval = @options[:reconnect_interval] if @reconnect_timer
@@ -472,8 +464,8 @@ module RightScale
         @stats["request failures"].update("#{type} - retry")
         raise Exceptions::RetryableError.new(retry_result.http_body, retry_result)
       else
-        Log.error("Retrying #{type} request <#{request_uuid}> in #{interval} seconds " +
-                  "in response to retryable error (#{retry_result.http_body})")
+        ErrorTracker.log(self, "Retrying #{type} request <#{request_uuid}> in #{interval} seconds " +
+                               "in response to retryable error (#{retry_result.http_body})")
         wait(interval)
       end
       # Change request_uuid so that retried request not rejected as duplicate
@@ -505,8 +497,8 @@ module RightScale
         self.state = :disconnected
         raise Exceptions::ConnectivityFailure.new(not_responding.message + " after #{attempts} attempts")
       else
-        Log.error("Retrying #{type} request <#{request_uuid}> in #{interval} seconds " +
-                  "in response to routing failure (#{BalancedHttpClient.exception_text(not_responding)})")
+        ErrorTracker.log(self, "Retrying #{type} request <#{request_uuid}> in #{interval} seconds " +
+                               "in response to routing failure (#{BalancedHttpClient.exception_text(not_responding)})")
         wait(interval)
       end
       true

data/lib/right_agent/clients/non_blocking_client.rb

@@ -205,6 +205,7 @@ module RightScale
       case error.to_s
       when "terminating", "reconnecting" then [200, nil]
       when "Errno::ETIMEDOUT" then [408, "Request timeout"]
+      when "Errno::ECONNREFUSED" then [503, "Connection refused"]
       else [500, (error && error.to_s) || "HTTP connection failure for #{verb.to_s.upcase}"]
       end
     end

data/lib/right_agent/clients/right_http_client.rb

@@ -49,12 +49,8 @@ module RightScale
     # @option options [Boolean] :non_blocking i/o is to be used for HTTP requests by applying
     #   EM::HttpRequest and fibers instead of RestClient; requests remain synchronous
     # @option options [Boolean] :long_polling_only never attempt to create a WebSocket, always long-polling instead
-    # @option options [Array] :filter_params symbols or strings for names of request parameters
-    #   whose values are to be hidden when logging
-    # @option options [Proc] :exception_callback for unexpected exceptions with following parameters:
-    #   [Exception] exception raised
-    #   [Packet, NilClass] packet being processed
-    #   [Agent, NilClass] agent in which exception occurred
+    # @option options [Array] :filter_params symbols or strings for names of request parameters whose
+    #   values are to be hidden when logging; also applied to contents of any parameters named :payload
     #
     # @return [TrueClass] always true
     #
@@ -271,11 +267,11 @@ module RightScale
     # @return [Hash] status of various clients
     def update_status(type, state)
       @status[type] = state
-      @status_callbacks.each do |callback|
+      (@status_callbacks || []).each do |callback|
         begin
           callback.call(type, state)
         rescue RuntimeError => e
-          Log.error("Failed status callback", e)
+          ErrorTracker.log(self, "Failed status callback", e, nil, :caller)
         end
       end
       @status

data/lib/right_agent/clients/router_client.rb

@@ -88,7 +88,8 @@ module RightScale
     # @option options [Numeric] :reconnect_interval for reconnect attempts after lose connectivity
     # @option options [Boolean] :non_blocking i/o is to be used for HTTP requests by applying
     #   EM::HttpRequest and fibers instead of RestClient; requests remain synchronous
-    # @option options [Proc] :exception_callback for unexpected exceptions
+    # @option options [Array] :filter_params symbols or strings for names of request parameters whose
+    #   values are to be hidden when logging; also applied to contents of any parameters named :payload
     #
     # @raise [ArgumentError] auth client does not support this client type
     def initialize(auth_client, options)
@@ -261,8 +262,6 @@ module RightScale
     #   [Hash, NilClass] "reconnects" Activity stats or nil if none
     #   [Hash, NilClass] "request failures" Activity stats or nil if none
     #   [Hash, NilClass] "request sent" Activity stats or nil if none
-    #   [Float, NilClass] "response time" average number of seconds to respond to a request or nil if none
-    #   [Hash, NilClass] "exceptions" Exceptions stats or nil if none
     def stats(reset = false)
       events = @stats["events"].all
       stats = super(reset)
@@ -337,11 +336,10 @@ module RightScale
         end
         @listen_failures = 0
       rescue Exception => e
-        Log.error("Failed to listen", e, :trace)
-        @stats["exceptions"].track("listen", e)
+        ErrorTracker.log(self, "Failed to listen", e)
         @listen_failures += 1
         if @listen_failures > MAX_LISTEN_FAILURES
-          Log.error("Exceeded maximum repeated listen failures (#{MAX_LISTEN_FAILURES}), stopping listening")
+          ErrorTracker.log(self, "Exceeded maximum repeated listen failures (#{MAX_LISTEN_FAILURES}), stopping listening")
           @listen_state = :cancel
           self.state = :failed
           return false
@@ -440,8 +438,7 @@ module RightScale
       connect(routing_keys, &handler)
       update_listen_state(:check, 1)
     rescue Exception => e
-      Log.error("Failed creating WebSocket", e)
-      @stats["exceptions"].track("websocket", e)
+      ErrorTracker.log(self, "Failed creating WebSocket", e, nil, :caller)
       backoff_connect_interval
       update_listen_state(:long_poll)
     end
@@ -477,7 +474,7 @@ module RightScale
       @websocket = Faye::WebSocket::Client.new(url.to_s, protocols = nil, options)
 
       @websocket.onerror = lambda do |event|
-        Log.error("WebSocket error (#{event.data})") if event.data
+        ErrorTracker.log(self, "WebSocket error (#{event.data})") if event.data
       end
 
       @websocket.onclose = lambda do |event|
@@ -488,8 +485,7 @@ module RightScale
           msg << ((event.reason.nil? || event.reason.empty?) ? ")" : ": #{event.reason})")
           Log.info(msg)
         rescue Exception => e
-          Log.error("Failed closing WebSocket", e, :trace)
-          @stats["exceptions"].track("event", e)
+          ErrorTracker.log(self, "Failed closing WebSocket", e)
         end
         @websocket = nil
       end
@@ -508,8 +504,7 @@ module RightScale
           handler.call(event)
           @communicated_callbacks.each { |callback| callback.call } if @communicated_callbacks
         rescue Exception => e
-          Log.error("Failed handling WebSocket event", e, :trace)
-          @stats["exceptions"].track("event", e)
+          ErrorTracker.log(self, "Failed handling WebSocket event", e)
         end
       end
 
@@ -596,6 +591,7 @@ module RightScale
     end
 
     # Process result from long-polling attempt
+    # Not necessary to log failure since should already have been done by underlying HTTP client
     #
     # @param [Array, NilClass] result from long-polling attempt
     #
@@ -603,12 +599,10 @@ module RightScale
     def process_long_poll(result)
       case result
       when Exceptions::Unauthorized, Exceptions::ConnectivityFailure, Exceptions::RetryableError, Exceptions::InternalServerError
-        Log.error("Failed long-polling", result, :no_trace)
         update_listen_state(:choose, backoff_reconnect_interval)
         result = nil
       when Exception
-        Log.error("Failed long-polling", result, :trace)
-        @stats["exceptions"].track("long-polling", result)
+        ErrorTracker.track(self, result)
         update_listen_state(:choose, backoff_reconnect_interval)
         result = nil
       else

data/lib/right_agent/command/command_parser.rb

@@ -51,12 +51,12 @@ module RightScale
     def parse_chunk(chunk)
       @buildup << chunk
       chunks = @buildup.split(CommandSerializer::SEPARATOR, -1)
-      if do_call = chunks.size > 1
+      if (do_call = chunks.size > 1)
         commands = []
         (0..chunks.size - 2).each do |i|
           begin
             commands << CommandSerializer.load(chunks[i])
-          rescue Exception => e
+          rescue StandardError => e
             # log any exceptions caused by serializing individual chunks instead
             # of halting EM. each command is discrete so we need to keep trying
             # so long as there are more commands to process (although subsequent
@@ -77,7 +77,7 @@ module RightScale
         @buildup = chunks.last
       end
       do_call
-    rescue Exception => e
+    rescue StandardError => e
       # log any other exceptions instead of halting EM.
       Log.error("Failed parsing command chunk", e, :trace)
     end

data/lib/right_agent/command/command_runner.rb

@@ -79,7 +79,7 @@ module RightScale
               Log.error("Invalid cookie used by command protocol client (#{cmd_cookie})")
             end
           rescue Exception => e
-            Log.warning("Command failed (#{e.message}) at\n#{e.backtrace.join("\n")}")
+            Log.error("Command failed", e, :trace)
           end
         end
 

data/lib/right_agent/command/command_serializer.rb

@@ -37,12 +37,6 @@ module RightScale
     # === Return
     # data(String):: Corresponding serialized data
     def self.dump(command)
-      # Set the encoding before serialization otherwise YAML will serialize
-      # UTF8 characters as binary data.  This can cause some quirks we'd rather
-      # avoid, such as the deserialized binary data having no encoding on 
-      # deserialization
-      set_encoding(command)
-
       data = YAML::dump(command)
       data += SEPARATOR
     end
@@ -58,10 +52,6 @@ module RightScale
     # === Raise
     # (RightScale::Exceptions::IO): If serialized data is incorrect
     def self.load(data)
-      # Data coming from eventmachine is cleaned of it's encoding, so set it
-      # to UTF-8 manually before deserializing or you'll throw transcode errors.
-      set_encoding(data)
-
       command = YAML::load(data)
 
       raise RightScale::Exceptions::IO, "Invalid serialized command:\n#{data}" unless command
@@ -72,27 +62,5 @@ module RightScale
       raise RightScale::Exceptions::IO, "Invalid serialized command: #{e.message}\n#{data}"
     end
 
-    private
-    # Force set encodings on ruby strings.
-    #
-    # === Parameters
-    # obj(Object):: String, or Hash/Array of Strings
-    #
-    # === Return
-    # (nil):: Returns nothing, edits object in place 
-    def self.set_encoding(obj, encoding = "UTF-8")
-      if obj.is_a?(Hash)
-        obj.each do |k,v|
-          set_encoding(v, encoding)
-        end
-      elsif obj.is_a?(Array)
-        obj.each do |v|
-          set_encoding(v, encoding)
-        end
-      elsif obj.is_a?(String) && !obj.frozen?
-        obj.force_encoding(encoding) if obj.respond_to?(:force_encoding)
-      end
-    end
-
   end
 end