right_support 1.1.2 → 1.2.0

data/lib/right_support/net.rb

@@ -29,8 +29,10 @@ module RightSupport
   end
 end
 
-Dir[File.expand_path('../net/*.rb', __FILE__)].each do |filename|
-  require filename
-end
+require 'right_support/net/address_helper'
+require 'right_support/net/http_client'
+require 'right_support/net/string_encoder'
+require 'right_support/net/balancing'
+require 'right_support/net/request_balancer'
 
 RightSupport::Net.extend(RightSupport::Net::AddressHelper)

data/lib/right_support/net/balancing/health_check.rb

@@ -31,45 +31,55 @@ module RightSupport::Net::Balancing
     DEFAULT_YELLOW_STATES = 4
     DEFAULT_RESET_TIME    = 300
     
-    def initialize(endpoints, yellow_states=nil, reset_time=nil)
+    def initialize(endpoints, yellow_states=nil, reset_time=nil, on_health_change=nil)
       @endpoints = Hash.new
       @yellow_states = yellow_states || DEFAULT_YELLOW_STATES
       @reset_time = reset_time || DEFAULT_RESET_TIME
-      endpoints.each { |ep| @endpoints[ep] = {:n_level => 0,:timestamp => 0 }}
+      @on_health_change = on_health_change
+      @min_n_level = 0
+      endpoints.each { |ep| @endpoints[ep] = {:n_level => @min_n_level, :timestamp => 0} }
     end
     
     def sweep
-      @endpoints.each { |k,v| decrease_state(k,0,Time.now) if Float(Time.now - v[:timestamp]) > @reset_time }
+      @endpoints.each { |k,v| decrease_state(k, 0, Time.now) if Float(Time.now - v[:timestamp]) > @reset_time }
     end
     
     def sweep_and_return_yellow_and_green
       sweep
       @endpoints.select { |k,v| v[:n_level] < @yellow_states }
     end
-    
-    def decrease_state(endpoint,t0,t1)
-      unless @endpoints[endpoint][:n_level] == 0
-        @endpoints[endpoint][:n_level]    -= 1
-        @endpoints[endpoint][:timestamp]  = t1
-      end
+
+    def decrease_state(endpoint, t0, t1)
+      update_state(endpoint, -1, t1) unless @endpoints[endpoint][:n_level] == 0
     end
-    
-    def increase_state(endpoint,t0,t1)
-      unless @endpoints[endpoint][:n_level] == @yellow_states
-        @endpoints[endpoint][:n_level]    += 1
-        @endpoints[endpoint][:timestamp]  = t1
+
+    def increase_state(endpoint, t0, t1)
+      update_state(endpoint, 1, t1) unless @endpoints[endpoint][:n_level] == @yellow_states
+    end
+
+    def update_state(endpoint, change, t1)
+      @endpoints[endpoint][:timestamp] = t1
+      n_level = @endpoints[endpoint][:n_level] += change
+      if @on_health_change &&
+         (n_level < @min_n_level ||
+         (n_level > @min_n_level && n_level == @endpoints.map { |(k, v)| v[:n_level] }.min))
+        @min_n_level = n_level
+        @on_health_change.call(state_color(n_level))
       end
     end
 
+    def state_color(n_level)
+      color = 'green' if n_level == 0
+      color = 'red' if n_level == @yellow_states
+      color = "yellow-#{n_level}" if n_level > 0 && n_level < @yellow_states
+      color
+    end
+
     # Returns a hash of endpoints and their colored health status
     # Useful for logging and debugging
     def get_stats
       stats = {}
-      @endpoints.each do |k, v|
-        stats[k] = 'green' if v[:n_level] == 0
-        stats[k] = 'red' if v[:n_level] == @yellow_states
-        stats[k] = "yellow-#{v[:n_level]}" if v[:n_level] > 0 && v[:n_level] < @yellow_states
-      end
+      @endpoints.each { |k, v| stats[k] = state_color(v[:n_level]) }
       stats
     end
     
@@ -90,16 +100,23 @@ module RightSupport::Net::Balancing
   #      retain yellow state and improve it's health
   #    * on failure: change state to red if it's health was sickest (@yellow_states), else
   #      retain yellow state and decrease it's health
+  # A callback option is provided to receive notification of changes in the overall
+  # health of the endpoints. The overall health starts out green. When the last
+  # endpoint transitions from green to yellow, a callback is made to report the overall
+  # health as yellow (or level of yellow). When the last endpoint transitions from yellow
+  # to red, a callback is made to report the transition to red. Similarly transitions are
+  # reported on the way back down, e.g., yellow is reported as soon as the first endpoint
+  # transitions from red to yellow, and so on.
 
   class HealthCheck
     
-    def initialize(endpoints,options = {})
+    def initialize(endpoints, options = {})
       yellow_states = options[:yellow_states]
       reset_time = options[:reset_time]
 
       @health_check = options.delete(:health_check)
 
-      @stack = EndpointsStack.new(endpoints,yellow_states,reset_time)
+      @stack = EndpointsStack.new(endpoints, yellow_states, reset_time, options[:on_health_change])
       @counter = rand(0xffff) % endpoints.size
       @last_size = endpoints.size
     end
@@ -128,11 +145,11 @@ module RightSupport::Net::Balancing
     end
 
     def good(endpoint, t0, t1)
-      @stack.decrease_state(endpoint,t0,t1)
+      @stack.decrease_state(endpoint, t0, t1)
     end
 
     def bad(endpoint, t0, t1)
-      @stack.increase_state(endpoint,t0,t1)
+      @stack.increase_state(endpoint, t0, t1)
     end
     
     def health_check(endpoint)

data/lib/right_support/net/request_balancer.rb

@@ -22,6 +22,8 @@ module RightSupport::Net
   # default list of fatal exceptions and default logic for deciding whether a
   # given exception is fatal! There are some subtleties.
   class RequestBalancer
+    include RightSupport::Log::Mixin
+
     DEFAULT_RETRY_PROC = lambda do |ep, n|
       n < ep.size
     end
@@ -68,16 +70,6 @@ module RightSupport::Net
         :health_check => DEFAULT_HEALTH_CHECK_PROC
     }
 
-    @@logger = nil
-    
-    def self.logger
-      @@logger
-    end
-
-    def self.logger=(logger)
-      @@logger = logger
-    end
-
     def self.request(endpoints, options={}, &block)
       new(endpoints, options).request(&block)
     end
@@ -92,8 +84,12 @@ module RightSupport::Net
     # === Options
     # retry:: a Class, array of Class or decision Proc to determine whether to keep retrying; default is to try all endpoints
     # fatal:: a Class, array of Class, or decision Proc to determine whether an exception is fatal and should not be retried
-    # on_exception(Proc):: notification hook that accepts three arguments: whether the exception is fatal, the exception itself, and the endpoint for which the exception happened
-    # health_check(Proc):: callback that allows balancer to check an endpoint health; should raise an exception if the endpoint is not healthy
+    # on_exception(Proc):: notification hook that accepts three arguments: whether the exception is fatal, the exception itself,
+    #   and the endpoint for which the exception happened
+    # health_check(Proc):: callback that allows balancer to check an endpoint health; should raise an exception if the endpoint
+    #   is not healthy
+    # on_health_change(Proc):: callback that is made when the overall health of the endpoints transition to a different level;
+    #   its single argument contains the new minimum health level
     #
     def initialize(endpoints, options={})
       @options = DEFAULT_OPTIONS.merge(options)
@@ -104,7 +100,7 @@ module RightSupport::Net
 
       @options[:policy] ||= RightSupport::Net::Balancing::RoundRobin
       @policy = @options[:policy]
-      @policy = @policy.new(endpoints,options) if @policy.is_a?(Class)
+      @policy = @policy.new(endpoints, options) if @policy.is_a?(Class)
       unless test_policy_duck_type(@policy)
         raise ArgumentError, ":policy must be a class/object that responds to :next, :good and :bad"
       end
@@ -122,7 +118,11 @@ module RightSupport::Net
       end
 
       unless test_callable_arity(options[:health_check], 1, false)
-        raise ArgumentError, ":health_check callback must accept one parameters"
+        raise ArgumentError, ":health_check callback must accept one parameter"
+      end
+
+      unless test_callable_arity(options[:on_health_change], 1, false)
+        raise ArgumentError, ":on_health_change callback must accept one parameter"
       end
 
       @endpoints = endpoints
@@ -169,15 +169,15 @@ module RightSupport::Net
         if need_health_check
           begin
             unless @policy.health_check(endpoint)
-              log_error("RequestBalancer: health check failed to #{endpoint} because of non-true return value")
+              logger.error "RequestBalancer: health check failed to #{endpoint} because of non-true return value"
               next
             end
           rescue Exception => e
-            log_error("RequestBalancer: health check failed to #{endpoint} because of #{e.class.name}: #{e.message}")
+            logger.error "RequestBalancer: health check failed to #{endpoint} because of #{e.class.name}: #{e.message}"
             next
           end
 
-          log_info("RequestBalancer: health check succeeded to #{endpoint}")
+          logger.info "RequestBalancer: health check succeeded to #{endpoint}"
         end
 
         begin
@@ -200,7 +200,7 @@ module RightSupport::Net
 
       exceptions = exceptions.map { |e| e.class.name }.uniq.join(', ')
       msg = "No available endpoints from #{@endpoints.inspect}! Exceptions: #{exceptions}"
-      log_error("RequestBalancer: #{msg}")
+      logger.error "RequestBalancer: #{msg}"
       raise NoResult, msg
     end
 
@@ -247,7 +247,7 @@ module RightSupport::Net
       fatal = fatal.any?{ |c| e.is_a?(c) } if fatal.respond_to?(:any?)
       duration = sprintf('%.4f', Time.now - t0)
       msg = "RequestBalancer: rescued #{fatal ? 'fatal' : 'retryable'} #{e.class.name} during request to #{endpoint}: #{e.message} after #{duration} seconds"
-      log_error msg
+      logger.error msg
       @options[:on_exception].call(fatal, e, endpoint) if @options[:on_exception]
 
       if fatal
@@ -269,19 +269,6 @@ module RightSupport::Net
       return true if optional && !callable.respond_to?(:call)
       return callable.respond_to?(:arity) && (callable.arity == arity)
     end
-
-    # Log an info message with the class logger, if provided.  Can't duck type because some loggers
-    # use fallback methods to perform their logging and don't respond_to?() :info or :error
-    def log_info(*args)
-      self.class.logger.__send__(:info, *args) unless self.class.logger.nil?
-    end
-
-    # Log an error message with the class logger, if provided. Can't duck type because some loggers
-    # use fallback methods to perform their logging and don't respond_to?() :info or :error
-    def log_error(*args)
-      self.class.logger.__send__(:error, *args) unless self.class.logger.nil?
-    end
-
   end # RequestBalancer
 
 end # RightScale

data/lib/right_support/rack.rb

@@ -29,6 +29,5 @@ module RightSupport
   end
 end
 
-Dir[File.expand_path('../rack/*.rb', __FILE__)].each do |filename|
-  require filename
-end
+require 'right_support/rack/custom_logger'
+require 'right_support/rack/request_logger'

data/lib/right_support/rack/custom_logger.rb

@@ -28,19 +28,30 @@ module RightSupport::Rack
   # to a file-based Logger and doesn't allow you to control anything other than the
   # filename.
   class CustomLogger
-    # Initialize an instance of the middleware.
+    # Initialize an instance of the middleware. For backward compatibility, the order of the
+    # logger and level parameters can be switched.
     #
     # === Parameters
     # app(Object):: the inner application or middleware layer; must respond to #call
-    # level(Integer):: one of the Logger constants: DEBUG, INFO, WARN, ERROR, FATAL
-    # logger(Logger):: (optional) the Logger object to use, if other than default
+    # logger(Logger):: (optional) the Logger object to use, defaults to a STDERR logger
+    # level(Integer):: (optional) a Logger level-constant (INFO, ERROR) to set the logger to
     #
-    def initialize(app, level = ::Logger::INFO, logger = nil)
-      @app, @level = app, level
+    def initialize(app, arg1=nil, arg2=nil)
+      if arg1.is_a?(Integer)
+        level = arg1
+      elsif arg1.is_a?(Logger)
+        logger = arg1
+      end
 
-      logger ||= ::Logger.new(env['rack.errors'])
-      logger.level = @level
+      if arg2.is_a?(Integer)
+        level = arg2
+      elsif arg2.is_a?(Logger)
+        logger = arg2
+      end
+
+      @app    = app
       @logger = logger
+      @level  = level
     end
 
     # Add a logger to the Rack environment and call the next middleware.
@@ -51,8 +62,18 @@ module RightSupport::Rack
     # === Return
     # always returns whatever value is returned by the next layer of middleware
     def call(env)
+      #emulate the behavior of Rack::CommonLogger middleware, which instantiates a
+      #default logger if one has not been provided in the initializer
+      @logger = ::Logger.new(env['rack.errors'] || STDERR) unless @logger
+
+      if @level
+        old_level = @logger.level
+        @logger.level = @level
+      end
       env['rack.logger'] = @logger
-      return @app.call(env)
+      status, header, body = @app.call(env)
+      @logger.level = old_level if @level
+      return [status, header, body]
     end
   end
 end

data/lib/right_support/rack/request_logger.rb

@@ -0,0 +1,113 @@
+#
+# Copyright (c) 2012 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 'logger'
+
+module RightSupport::Rack
+  # A Rack middleware that logs information about every HTTP request received and
+  # every exception raised while processing a request.
+  #
+  # The middleware can be configured to use its own logger, but defaults to using
+  # env['rack.logger'] for logging if it is present. If 'rack.logger' is not set,
+  # this middleware will set it before calling the next middleware. Therefore,
+  # RequestLogger can be used standalone to fulfill all logging needs, or combined
+  # with Rack::Logger or another middleware that provides logging services.
+  class RequestLogger
+    # Initialize an instance of the middleware. For backward compatibility, the order of the
+    # logger and level parameters can be switched.
+    #
+    # === Parameters
+    # app(Object):: the inner application or middleware layer; must respond to #call
+    # logger(Logger):: (optional) the Logger object to use, defaults to a STDERR logger
+    # level(Integer):: (optional) a Logger level-constant (INFO, ERROR) to set the logger to
+    #
+    def initialize(app, options={})
+      @app    = app
+      @logger = options[:logger]
+    end
+
+    # Add a logger to the Rack environment and call the next middleware.
+    #
+    # === Parameters
+    # env(Hash):: the Rack environment
+    #
+    # === Return
+    # always returns whatever value is returned by the next layer of middleware
+    def call(env)
+      if @logger
+        logger = @logger
+      elsif env['rack.logger']
+        logger = env['rack.logger']
+      end
+
+      env['rack.logger'] ||= logger
+
+      began_at = Time.now
+      status, header, body = @app.call(env)
+      log_request(logger, env, status, began_at)
+      log_exception(logger, env['sinatra.error']) if env['sinatra.error']
+
+      return [status, header, body]
+    rescue Exception => e
+      log_exception(logger, e)
+      raise e
+    end
+
+    private
+
+    # NON Logger functions below
+    def log_request(logger, env, status, began_at)
+      duration = Time.now - began_at
+
+      # Assuming remote addresses are IPv4, make them all align to the same width
+      remote_addr = env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-"
+      remote_addr = remote_addr.ljust(15)
+
+      # Log the fact that a query string was present, but do not log its contents
+      # because it may have sensitive data.
+      if (query = env["QUERY_STRING"]) && !query.empty?
+        query_info = '?...'
+      else
+        query_info = ''
+      end
+
+      params = [
+        remote_addr,
+        env["REQUEST_METHOD"],
+        env["PATH_INFO"],
+        query_info,
+        env["HTTP_VERSION"],
+        status,
+        duration
+      ]
+
+      logger.info %Q{%s "%s %s%s %s" %d %0.3f} % params
+    end
+
+    def log_exception(logger, e)
+      msg = ["#{e.class} - #{e.message}", *e.backtrace].join("\n")
+      logger.error(msg)
+    rescue
+      #no-op, something is seriously messed up by this point...
+    end
+  end
+end

data/lib/right_support/ruby.rb

@@ -29,6 +29,7 @@ module RightSupport
   end
 end
 
-Dir[File.expand_path('../ruby/*.rb', __FILE__)].each do |filename|
-  require filename
-end
+# object_extensions must be first
+require 'right_support/ruby/object_extensions'
+require 'right_support/ruby/string_extensions'
+require 'right_support/ruby/easy_singleton'

data/lib/right_support/ruby/easy_singleton.rb

@@ -0,0 +1,24 @@
+require 'singleton'
+
+module RightSupport::Ruby
+  module EasySingleton
+    module ClassMethods
+      def method_missing(meth, *args)
+        if self.instance && self.instance.respond_to?(meth)
+          self.instance.__send__(meth, *args)
+        else
+          super
+        end
+      end
+
+      def respond_to?(meth)
+        super(meth) || self.instance.respond_to?(meth)
+      end
+    end
+
+    def self.included(base)
+      base.__send__(:include, ::Singleton) unless base.ancestors.include?(::Singleton)
+      base.__send__(:extend, ClassMethods)
+    end
+  end
+end