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

data/lib/right_agent/connectivity_checker.rb

@@ -38,13 +38,12 @@ module RightScale
     # Timer while waiting for RightNet router ping response
     attr_accessor :ping_timer
 
-    def initialize(sender, check_interval, ping_stats, exception_stats)
+    def initialize(sender, check_interval, ping_stats)
       @sender = sender
       @check_interval = check_interval
       @ping_timeouts = {}
       @ping_timer = nil
       @ping_stats = ping_stats
-      @exception_stats = exception_stats
       @last_received = Time.now
       @message_received_callbacks = []
       restart_inactivity_timer if @check_interval > 0
@@ -98,17 +97,16 @@ module RightScale
               @ping_timer = nil
               @ping_timeouts[@ping_id] = (@ping_timeouts[@ping_id] || 0) + 1
               if @ping_timeouts[@ping_id] >= max_ping_timeouts
-                Log.error("Mapper ping via broker #{@ping_id} timed out after #{PING_TIMEOUT} seconds and now " +
-                          "reached maximum of #{max_ping_timeouts} timeout#{max_ping_timeouts > 1 ? 's' : ''}, " +
-                          "attempting to reconnect")
+                ErrorTracker.log(self, "Mapper ping via broker #{@ping_id} timed out after #{PING_TIMEOUT} seconds and now " +
+                                       "reached maximum of #{max_ping_timeouts} timeout#{max_ping_timeouts > 1 ? 's' : ''}, " +
+                                       "attempting to reconnect")
                 host, port, index, priority = @sender.client.identity_parts(@ping_id)
                 @sender.agent.connect(host, port, index, priority, force = true)
               else
                 Log.warning("Mapper ping via broker #{@ping_id} timed out after #{PING_TIMEOUT} seconds")
               end
             rescue Exception => e
-              Log.error("Failed to reconnect to broker #{@ping_id}", e, :trace)
-              @exception_stats.track("ping timeout", e)
+              ErrorTracker.log(self, "Failed to reconnect to broker #{@ping_id}", e)
             end
           else
             @ping_timer = nil
@@ -125,8 +123,7 @@ module RightScale
               @ping_id = nil
             end
           rescue Exception => e
-            Log.error("Failed to cancel router ping", e, :trace)
-            @exception_stats.track("cancel ping", e)
+            ErrorTracker.log(self, "Failed to cancel router ping", e)
           end
         end
         request = Request.new("/router/ping", nil, {:from => @sender.identity, :token => AgentIdentity.generate})
@@ -167,8 +164,7 @@ module RightScale
         begin
           check(id = nil, max_ping_timeouts = 1)
         rescue Exception => e
-          Log.error("Failed connectivity check", e, :trace)
-          @exception_stats.track("check connectivity", e)
+          ErrorTracker.log(self, "Failed connectivity check", e)
         end
       end
       true

data/lib/right_agent/core_payload_types/dev_repository.rb

@@ -72,5 +72,37 @@ module RightScale
     def serialized_members
       [ @repo_type, @url, @tag, @cookbooks_path, @ssh_key, @username, @password, @repo_sha, @positions ]
     end
+
+    # Maps the given DevRepository to a has that can be consumed by the RightScraper gem
+    #
+    # === Returns
+    # (Hash)::
+    #   :repo_type (Symbol):: Type of repository: one of :git, :svn, :download or :local
+    #     * :git denotes a 'git' repository that should be retrieved via 'git clone'
+    #     * :svn denotes a 'svn' repository that should be retrieved via 'svn checkout'
+    #     * :download denotes a tar ball that should be retrieved via HTTP GET (HTTPS if uri starts with https://)
+    #     * :local denotes cookbook that is already local and doesn't need to be retrieved
+    #   :url (String):: URL to repository (e.g. git://github.com/opscode/chef-repo.git)
+    #   :tag (String):: git commit or svn branch that should be used to retrieve repository
+    #                       Optional, use 'master' for git and 'trunk' for svn if tag is nil.
+    #                       Not used for raw repositories.
+    #   :cookbooks_path (Array):: Path to cookbooks inside repostory
+    #                                             Optional (use location of repository as cookbook path if nil)
+    #   :first_credential (String):: Either the Private SSH key used to retrieve git repositories, or the Username used to retrieve svn and raw repositories
+    #   :second_credential (String):: Password used to retrieve svn and raw repositories
+    def to_scraper_hash
+      repo = {}
+      repo[:repo_type]            = repo_type.to_sym unless repo_type.nil?
+      repo[:url]                  = url
+      repo[:tag]                  = tag
+      repo[:resources_path]       = cookbooks_path
+      if !ssh_key.nil?
+        repo[:first_credential]   = ssh_key
+      elsif !(username.nil? && password.nil?)
+        repo[:first_credential]   = dev_repo.username
+        repo[:second_credential]  = dev_repo.password
+      end
+      repo
+    end
   end
 end

data/lib/right_agent/dispatcher.rb

@@ -27,8 +27,8 @@ module RightScale
 
     include ProtocolVersionMixin
 
-    class InvalidRequestType < Exception; end
-    class DuplicateRequest < Exception; end
+    class InvalidRequestType < RuntimeError; end
+    class DuplicateRequest < RuntimeError; end
 
     # (ActorRegistry) Registry for actors
     attr_reader :registry
@@ -88,7 +88,7 @@ module RightScale
       actor, method, idempotent = route(request)
       received_at = @request_stats.update(method, (token if request.is_a?(Request)))
       if (dup = duplicate?(request, method, idempotent))
-        raise DuplicateRequest.new(dup)
+        raise DuplicateRequest, dup
       end
       unless (result = expired?(request, method))
         result = perform(request, actor, method, idempotent)
@@ -110,23 +110,17 @@ module RightScale
     #     or nil if empty
     #   "dispatch failures"(Hash|nil):: Dispatch failure activity stats with keys "total", "percent", "last", and "rate"
     #     with percentage breakdown per failure type, or nil if none
-    #   "exceptions"(Hash|nil):: Exceptions raised per category, or nil if none
-    #     "total"(Integer):: Total for category
-    #     "recent"(Array):: Most recent as a hash of "count", "type", "message", "when", and "where"
     #   "rejects"(Hash|nil):: Request reject activity stats with keys "total", "percent", "last", and "rate"
     #     with percentage breakdown per reason ("duplicate (<method>)", "retry duplicate (<method>)", or
     #     "stale (<method>)"), or nil if none
     #   "requests"(Hash|nil):: Request activity stats with keys "total", "percent", "last", and "rate"
     #     with percentage breakdown per request type, or nil if none
-    #   "response time"(Float):: Average number of seconds to respond to a request recently
     def stats(reset = false)
       stats = {
         "dispatched cache"  => (@dispatched_cache.stats if @dispatched_cache),
         "dispatch failures" => @dispatch_failure_stats.all,
-        "exceptions"        => @exception_stats.stats,
         "rejects"           => @reject_stats.all,
-        "requests"          => @request_stats.all,
-        "response time"     => @request_stats.avg_duration
+        "requests"          => @request_stats.all
       }
       reset_stats if reset
       stats
@@ -142,7 +136,6 @@ module RightScale
       @reject_stats = RightSupport::Stats::Activity.new
       @request_stats = RightSupport::Stats::Activity.new
       @dispatch_failure_stats = RightSupport::Stats::Activity.new
-      @exception_stats = RightSupport::Stats::Exceptions.new(@agent, @agent.exception_callback)
       true
     end
 
@@ -209,7 +202,7 @@ module RightScale
       method = method.to_sym
       actor = @registry.actor_for(prefix)
       if actor.nil? || !actor.respond_to?(method)
-        raise InvalidRequestType.new("Unknown actor or method for dispatching request <#{request.token}> of type #{request.type}")
+        raise InvalidRequestType, "Unknown actor or method for dispatching request <#{request.token}> of type #{request.type}"
       end
       [actor, method, actor.class.idempotent?(method)]
     end
@@ -231,40 +224,10 @@ module RightScale
       else
         actor.send(method, request.payload, request)
       end
-    rescue Exception => e
+    rescue StandardError => e
+      ErrorTracker.log(self, "Failed dispatching #{request.trace}", e, request)
       @dispatch_failure_stats.update("#{request.type}->#{e.class.name}")
-      OperationResult.error(handle_exception(actor, method, request, e))
-    end
-
-    # Handle exception by logging it, calling the actors exception callback method,
-    # and gathering exception statistics
-    #
-    # === Parameters
-    # actor(Actor):: Actor that failed to process request
-    # method(Symbol):: Name of actor method being dispatched to
-    # request(Packet):: Packet that dispatcher is acting upon
-    # exception(Exception):: Exception that was raised
-    #
-    # === Return
-    # (String):: Error description for this exception
-    def handle_exception(actor, method, request, exception)
-      error = "Could not handle #{request.type} request"
-      Log.error(error, exception, :trace)
-      begin
-        if actor && actor.class.exception_callback
-          case actor.class.exception_callback
-          when Symbol, String
-            actor.send(actor.class.exception_callback, method, request, exception)
-          when Proc
-            actor.instance_exec(method, request, exception, &actor.class.exception_callback)
-          end
-        end
-        @exception_stats.track(request.type, exception)
-      rescue Exception => e
-        Log.error("Failed handling error for #{request.type}", e, :trace)
-        @exception_stats.track(request.type, e) rescue nil
-      end
-      Log.format(error, exception)
+      OperationResult.error("Could not handle #{request.type} request", e)
     end
 
   end # Dispatcher

data/lib/right_agent/enrollment_result.rb

@@ -20,8 +20,8 @@ module RightScale
     # Versions 5 and above use an identical format for the enrollment result
     SUPPORTED_VERSIONS = 5..AgentConfig.protocol_version
     
-    class IntegrityFailure < Exception; end
-    class VersionError < Exception; end
+    class IntegrityFailure < StandardError; end
+    class VersionError < StandardError; end
 
     attr_reader :r_s_version, :timestamp, :router_cert, :id_cert, :id_key
 

data/lib/right_agent/error_tracker.rb

@@ -0,0 +1,230 @@
+# Copyright (c) 2014 RightScale, Inc, All Rights Reserved Worldwide.
+#
+# THIS PROGRAM IS CONFIDENTIAL AND PROPRIETARY TO RIGHTSCALE
+# AND CONSTITUTES A VALUABLE TRADE SECRET.  Any unauthorized use,
+# reproduction, modification, or disclosure of this program is
+# strictly prohibited.  Any use of this program by an authorized
+# licensee is strictly subject to the terms and conditions,
+# including confidentiality obligations, set forth in the applicable
+# License Agreement between RightScale.com, Inc. and
+# the licensee.
+
+module RightScale
+
+  # Tracker for unexpected errors
+  # Logs them with appropriate trace information
+  # Accumulates statistics about exceptions
+  # Reports exceptions to external Errbit service via HydraulicBrake
+  class ErrorTracker
+
+    include RightSupport::Ruby::EasySingleton
+
+    # Text used for filtered parameter value
+    FILTERED_PARAM_VALUE = "<hidden>"
+
+    # Container for exception statistics
+    attr_reader :exception_stats
+
+    # Initialize error tracker
+    #
+    # @param [Object] agent object using this tracker
+    # @param [String] agent_name uniquely identifying agent process on given server
+    #
+    # @option options [Integer, NilClass] :shard_id identifying shard of database in use
+    # @option options [Hash] :trace_level for restricting backtracing and Errbit reporting
+    #   with exception class as key and :no_trace, :caller, or :trace as value; exceptions
+    #   with :no_trace are not backtraced when logging nor are they recorded in stats
+    #   or reported to Errbit
+    # @option options [Array<Symbol, String>] :filter_params names whose values are to be
+    #   filtered when notifying
+    # @option options [String] :airbrake_endpoint URL for Airbrake for reporting exceptions
+    #   to Errbit
+    # @option options [String] :airbrake_api_key for using the Airbrake API to access Errbit
+    #
+    # @return [TrueClass] always true
+    def init(agent, agent_name, options = {})
+      @agent = agent
+      @trace_level = options[:trace_level] || {}
+      notify_init(agent_name, options)
+      reset_stats
+      true
+    end
+
+    # Log error and optionally track in stats
+    # Errbit notification is left to the callback configured in the stats tracker
+    # Logging works even if init was never called
+    #
+    # @param [String, Object] component reporting error; non-string is snake-cased
+    # @param [String] description of failure for use in logging
+    # @param [Exception, String] exception to be logged and tracked in stats;
+    #   string errors are logged but not tracked in stats
+    # @param [Packet, Hash, NilClass] packet associated with exception
+    # @param [Symbol, NilClass] trace level override unless excluded by configured
+    #   trace levels
+    #
+    # @return [Boolean] true if successfully logged, otherwise false
+    def log(component, description, exception = nil, packet = nil, trace = nil)
+      if exception.nil?
+        Log.error(description)
+      elsif exception.is_a?(String)
+        Log.error(description, exception)
+      else
+        trace = (@trace_level && @trace_level[exception.class]) || trace || :trace
+        Log.error(description, exception, trace)
+        track(component, exception, packet) if trace != :no_trace
+      end
+      true
+    rescue StandardError => e
+      Log.error("Failed to log error", e, :trace) rescue nil
+      false
+    end
+
+    # Track error in stats
+    #
+    # @param [String] component reporting error
+    # @param [Exception] exception to be tracked
+    # @param [Packet, Hash, NilClass] packet associated with exception
+    #
+    # @return [TrueClass] always true
+    def track(component, exception, packet = nil)
+      if @exception_stats
+        component = component.class.name.split("::").last.snake_case unless component.is_a?(String)
+        @exception_stats.track(component, exception, packet)
+      end
+      true
+    end
+
+    # Notify Errbit of error if notification enabled
+    #
+    # @param [Exception, String] exception raised
+    # @param [Packet, Hash] packet associated with exception
+    # @param [Object] agent object reporting error
+    # @param [String] component or service area where error occurred
+    #
+    # @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)
+          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
+          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)
+      end
+      true
+    rescue Exception => e
+      Log.error("Failed to notify Errbit", e, :trace)
+    end
+
+    # Create proc for making callback to notifier
+    #
+    # @return [Proc] notifier callback
+    def notify_callback
+      Proc.new do |exception, packet, agent, component|
+        notify(exception, packet, agent, component)
+      end
+    end
+
+    # Get exception statistics
+    #
+    # @param reset [Boolean] Whether to reset the statistics after getting the current ones
+    #
+    # @return [Hash] current statistics
+    def stats(reset = false)
+      stats = {"exceptions" => @exception_stats && @exception_stats.all}
+      reset_stats if reset
+      stats
+    end
+
+    protected
+
+    # Reset statistics
+    # Do not recreate exception stats since may be referenced externally
+    #
+    # @return [TrueClass] always true
+    def reset_stats
+      @exception_stats ||= RightSupport::Stats::Exceptions.new(@agent, notify_callback)
+      @exception_stats.reset
+    end
+
+    # Configure HydraulicBreak for exception notification
+    #
+    # @param [String] agent_name uniquely identifying agent process on given server
+    #
+    # @option options [Integer, NilClass] :shard_id identifying shard of database in use
+    # @option options [Array<Symbol, String>] :filter_params names whose values are to be
+    #   filtered when notifying
+    # @option options [String] :airbrake_endpoint URL for Airbrake for reporting exceptions
+    #   to Errbit
+    # @option options [String] :airbrake_api_key for using the Airbrake API to access Errbit
+    #
+    # @return [TrueClass] always true
+    #
+    # @raise [RuntimeError] hydraulic_brake 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"
+        end
+
+        @cgi_data = {
+          :process    => $0,
+          :pid        => Process.pid,
+          :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
+      else
+        @notify_enabled = false
+      end
+      true
+    end
+
+    # Apply parameter filter
+    #
+    # @param [Hash] params to be filtered
+    #
+    # @return [Hash] filtered parameters
+    def filter(params)
+      if @filter_params
+        filtered_params = {}
+        params.each { |k, p| filtered_params[k] = @filter_params.include?(k.to_s) ? FILTERED_PARAM_VALUE : p }
+        filtered_params
+      end
+    end
+
+  end # ErrorTracker
+
+end # RightScale

data/lib/right_agent/exceptions.rb

@@ -36,7 +36,7 @@ module RightScale
     end
 
     # Internal application error
-    class Application < StandardError; end
+    class Application < NestedException; end
 
     # Agent command IO error
     class IO < RuntimeError; end