right_support 0.8.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 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.

data/README.rdoc

@@ -0,0 +1,66 @@
+RightSupport is a library of reusable, unit-tested Ruby code that RightScale has found broadly useful.
+
+== What Does It Do?
+
+=== Logging
+
+SystemLogger is a rewrite of the seattle.rb SyslogLogger class that features the following improvements:
+ * Contains several bugfixes vs. SyslogLogger 1.4.0
+ * Inherits from standard Ruby Logger class for guaranteed compatibility
+ * Can be configured with options about how to handle newlines, ANSI escape codes, etc
+
+  @logger = SystemLogger.new('my_cool_app', :split=>true, :color=>false)
+  @logger.info "Hello world\nThis will appear on separate lines\nand without \e[33;0mbeautiful colors" 
+
+CustomLogger is a Rack middleware that allows a Rack app to use any log sink it wishes. The
+stock Rack logger middleware is inflexible and gives the end user no control over which logger is used
+or where the log entries go.
+
+  require 'right_support/rack/custom_logger'
+
+  my_logger = MyAwesomeLogger.new
+  use RightSupport::Rack::CustomLogger, Logger::INFO, my_logger
+
+== Input Validation
+
+The Validation module contains several format-checkers that can be used to validate
+your web app's models before saving, check for preconditions in your controllers, and
+so forth.
+
+You can use it as a mixin by including the appropriate child module of
+RightSupport::Validation, but you really don't want to do that, do you? Instead, you
+want to call the module methods of RightSupport::Validation, which contains all of
+the same mixin methods.
+
+  the_key = STDIN.read
+  raise ArgumentError unless RightSupport::Validation.ssh_public_key?(the_key)
+
+== Request Balancing
+
+The RequestBalancer class will randomly choose endpoints for a network request,
+which lets you perform easy client-side load balancing:
+
+  include RightSupport::Net
+
+  urls = ['http://localhost', 'http://otherhost']
+  RequestBalancer.request(urls, :fatal=>RestClient::ResourceNotFound) do |url|
+    REST.get(url)
+  end
+
+The balancer will keep trying requests until one of them succeeds without throwing
+any exceptions. (NB: a nil return value counts as success!!)
+
+== HTTP REST Client
+
+ We provide a very thin wrapper around the rest-client gem that enables simple but
+ robust rest requests with a timeout, headers, etc. 
+
+ The RightSupport::Net::REST module is interface-compatible with the RestClient
+ module, but allows an optional timeout to be specified as an extra parameter.
+
+   # Default timeout is 5 seconds
+   RightSupport::Net::REST.get('http://localhost')
+
+   # Make sure the REST request fails after 1 second so we can report an error
+   # and move on!
+   RightSupport::Net::REST.get('http://localhost', {'X-Hello'=>'hi!'}, 1)

data/lib/right_support/filter_logger.rb

@@ -0,0 +1,122 @@
+#
+# Copyright (c) 2011 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
+  # A logger than encapsulates an underlying Logger object and filters log entries
+  # before they are passed to the underlying Logger. Can be used to for various log-
+  # processing tasks such as filtering sensitive data or tagging log lines with a
+  # context marker.
+  class FilterLogger < Logger
+    # Initialize a new instance of this class.
+    #
+    # === Parameters
+    # actual_logger(Logger):: The actual, underlying Logger object
+    #
+    def initialize(actual_logger)
+      @actual_logger = actual_logger
+
+    end
+
+    # Add a log line, filtering the severity and message before calling through
+    # to the underlying logger's #add method.
+    #
+    # === Parameters
+    # severity(Integer):: one of the Logger severity constants
+    # message(String):: the message to log, or nil
+    # progname(String):: the program name, or nil
+    #
+    # === Block
+    # If message == nil and a block is given, yields to the block in order to
+    # capture the log message. This matches the behavior of Logger, but ensures
+    # the severity and message are still filtered.
+    #
+    # === Return
+    # the result of the underlying logger's #add
+    def add(severity, message = nil, progname = nil, &block)
+      severity ||= UNKNOWN
+      return true if severity < level
+
+      if message.nil?
+        if block_given?
+          message = yield
+        else
+          message = progname
+        end
+      end
+
+      severity, message = filter(severity, message)
+      return @actual_logger.add(severity, message) if message
+    end
+
+    # Proxies to the encapsulated Logger object. See Logger#<< for info.
+    def <<(msg)
+      @actual_logger << msg
+    end
+
+    # Proxies to the encapsulated Logger object. See Logger#close for info.
+    def close
+      @actual_logger.close
+    end
+
+    # Proxies to the encapsulated Logger object. See Logger#level for info.
+    def level
+      @actual_logger.level
+    end
+
+    # Proxies to the encapsulated Logger object. See Logger#level= for info.
+    def level=(new_level)
+      @actual_logger.level = new_level
+    end
+
+    # Proxies to the encapsulated Logger object. See Logger#debug? for info.
+    def debug?; @actual_logger.debug?; end
+
+    # Proxies to the encapsulated Logger object. See Logger#info? for info.
+    def info?; @actual_logger.info?; end
+
+    # Proxies to the encapsulated Logger object. See Logger#warn? for info.
+    def warn?; @actual_logger.warn?; end
+
+    # Proxies to the encapsulated Logger object. See Logger#error? for info.
+    def error?; @actual_logger.error?; end
+
+    # Proxies to the encapsulated Logger object. See Logger#fatal? for info.
+    def fatal?; @actual_logger.fatal?; end
+
+    protected
+
+    # Filter a log line, transforming its severity and/or message before it is
+    # passed to the underlying logger.
+    #
+    # === Parameters
+    # severity(Integer):: one of the severity constants defined by Logger
+    # messgae(String):: the log message
+    #
+    # === Return
+    # Returns a pair consisting of the filtered [severity, message].
+    def filter(severity, message)
+      return [severity, message]
+    end
+  end
+end

data/lib/right_support/kernel_extensions.rb

@@ -0,0 +1,30 @@
+module RightSupport
+  module KernelExtensions
+    # Attempt to require one or more source files; if the require succeeds (or
+    # if the files have already been successfully required), yield to the block.
+    #
+    # This method is useful to conditionally define code depending on the availability
+    # of gems or standard-library source files. 
+    #
+    # === Parameters
+    # Uses a parameters glob to pass all of its parameters transparently through to
+    # Kernel#require.
+    #
+    # === Block
+    # The block will be called if the require succeeds (if it does not raise LoadError).
+    #
+    # === Return
+    # Preserves the return value of Kernel#require (generally either true or false).
+    def if_require_succeeds(*args)
+      result = require(*args)
+      yield if block_given?
+      return result
+    rescue LoadError => e
+      return false
+    end
+  end
+end
+
+class Object
+  include RightSupport::KernelExtensions
+end

data/lib/right_support/net/request_balancer.rb

@@ -0,0 +1,47 @@
+module RightSupport::Net
+  class NoResponse < Exception; end
+
+  # Utility class that allows network requests to be randomly distributed across
+  # a set of network endpoints. Generally used for REST requests by passing an
+  # Array of HTTP service endpoint URLs.
+  #
+  # The balancer does not actually perform requests by itself, which makes this
+  # class usable for various network protocols, and potentially even for non-
+  # networking purposes. The block does all the work; the balancer merely selects
+  # a random request endpoint to pass to the block.
+  class RequestBalancer
+    def self.request(endpoints, options={}, &block)
+      new(endpoints, options).request(&block)
+    end
+
+    def initialize(endpoints, options={})
+      raise ArgumentError, "Must specify at least one endpoint" unless endpoints && !endpoints.empty?
+      @endpoints = endpoints.shuffle
+      @options = options.dup
+    end
+
+    def request
+      raise ArgumentError, "Must call this method with a block" unless block_given?
+
+      exception = nil
+      result    = nil
+
+      @endpoints.each do |host|
+        begin
+          result = yield(host)
+          break unless result.nil?
+        rescue Exception => e
+          fatal = @options[:fatal]
+          safe  = @options[:safe]
+          raise e if (fatal && e.kind_of?(fatal)) && !(safe && e.kind_of?(safe))
+          exception = e
+        end
+      end
+
+      return result if result
+      raise exception if exception
+      raise NoResponse, "Tried all URLs with neither result nor exception!"
+    end
+  end # RequestBalancer
+
+end # RightScale

data/lib/right_support/net/rest.rb

@@ -0,0 +1,43 @@
+module RightSupport::Net
+  if_require_succeeds('restclient') do
+    HAS_REST_CLIENT = true
+  end
+
+  class NoProvider < Exception; end
+
+  #
+  # A wrapper for the rest-client gem that provides timeouts and other
+  # useful features while preserving the simplicity and ease of use of
+  # RestClient's simple, static (module-level) interface.
+  #
+  module REST
+    DEFAULT_TIMEOUT = 5
+    
+    def self.get(url, headers={}, timeout=DEFAULT_TIMEOUT, &block)
+      request(:method=>:get, :url=>url, :timeout=>timeout, :headers=>headers, &block)
+    end
+
+    def self.post(url, payload, headers={}, timeout=DEFAULT_TIMEOUT, &block)
+      request(:method=>:post, :url=>url, :payload=>payload,
+              :timeout=>timeout, :headers=>headers, &block)
+    end
+
+    def self.put(url, payload, headers={}, timeout=DEFAULT_TIMEOUT, &block)
+      request(:method=>:put, :url=>url, :payload=>payload,
+              :timeout=>timeout, :headers=>headers, &block)
+    end
+
+    def self.delete(url, headers={}, timeout=DEFAULT_TIMEOUT, &block)
+      request(:method=>:delete, :url=>url, :timeout=>timeout, :headers=>headers, &block)
+    end
+
+    def self.request(options, &block)
+      if HAS_REST_CLIENT
+        RestClient::Request.execute(options, &block)
+      else
+        raise NoProvider, "Cannot find a suitable HTTP client library"
+      end
+    end
+
+  end
+end

data/lib/right_support/net.rb

@@ -0,0 +1,34 @@
+#
+# Copyright (c) 2011 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.
+
+module RightSupport
+  #
+  # A namespace for useful networking tools.
+  #
+  module Net
+
+  end
+end
+
+Dir[File.expand_path('../net/*.rb', __FILE__)].each do |filename|
+  require filename
+end

data/lib/right_support/rack/custom_logger.rb

@@ -0,0 +1,62 @@
+#
+# Copyright (c) 2011 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
+  module Rack
+    # A Rack middleware that allows an arbitrary object to be used as the Rack logger.
+    # This is more flexible than Rack's built-in Logger middleware, which always logs
+    # 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.
+      #
+      # === 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
+      #
+      def initialize(app, level = ::Logger::INFO, logger = nil)
+        @app, @level = app, level
+
+        logger ||= ::Logger.new(env['rack.errors'])
+        logger.level = @level
+        @logger = 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)
+        env['rack.logger'] = @logger
+        return @app.call(env)
+      ensure
+        @logger.close
+      end
+    end
+  end
+end

data/lib/right_support/system_logger.rb

@@ -0,0 +1,175 @@
+#
+# Copyright (c) 2011 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
+  if_require_succeeds('syslog') do
+    # A logger that forwards log entries to the Unix syslog facility, but complies
+    # with the interface of the Ruby Logger object and faithfully translates log
+    # severities and other concepts. Provides optional cleanup/filtering in order
+    # to keep the syslog from having weird characters or being susceptible to log
+    # forgery.
+    class SystemLogger < Logger
+      LOGGER_LEVELS = {
+        UNKNOWN => :alert,
+        FATAL   => :err,
+        ERROR   => :warning,
+        WARN    => :notice,
+        INFO    => :info,
+        DEBUG   => :debug
+      }
+
+      SYSLOG_LEVELS = LOGGER_LEVELS.invert
+      DEFAULT_SYSLOG_LEVEL = :alert
+
+      DEFAULT_OPTIONS = {:split=>false, :color=>false}
+
+      @@syslog = nil
+
+      # Initialize this process's syslog facilities and construct a new syslog
+      # logger object.
+      #
+      # === Parameters
+      # program_name(String):: the syslog program name, 'ruby' by default
+      # options(Hash):: (optional) configuration options to use, see below
+      #
+      # === Options
+      # :facility:: the syslog facility to use for messages, 'local0' by default
+      # :split(true|false):: if true, splits multi-line messages into separate syslog entries
+      # :color(true|false):: if true, passes ANSI escape sequences through to syslog
+      #
+      def initialize(program_name='ruby', options={})
+        @options = DEFAULT_OPTIONS.merge(options)
+        @level = Logger::DEBUG
+
+        facility = options[:facility] || 'local0'
+        fac_map = {'user'=>8}
+        (0..7).each { |i| fac_map['local'+i.to_s] = 128+8*i }
+        @@syslog ||= Syslog.open(program_name, nil, fac_map[facility.to_s])
+      end
+
+      # Log a message if the given severity is high enough.  This is the generic
+      # logging method.  Users will be more inclined to use #debug, #info, #warn,
+      # #error, and #fatal.
+      #
+      # === Parameters
+      # severity(Integer):: one of the severity constants defined by Logger
+      # message(Object):: the message to be logged
+      # progname(String):: ignored, the program name is fixed at initialization
+      #
+      # === Block
+      # If message is nil and a block is supplied, this method will yield to
+      # obtain the log message.
+      #
+      # === Return
+      # true:: always returns true
+      #
+      def add(severity, message = nil, progname = nil, &block)
+        severity ||= UNKNOWN
+        if @@syslog.nil? or severity < @level
+          return true
+        end
+
+        progname ||= @progname
+
+        if message.nil?
+          if block_given?
+            message = yield
+          else
+            message = progname
+            progname = @progname
+          end
+        end
+
+        parts = clean(message)
+        parts.each { |part| emit_syslog(severity, part) }
+        return true
+      end
+
+      # Emit a log entry at INFO severity.
+      #
+      # === Parameters
+      # msg(Object):: the message to log
+      #
+      # === Return
+      # true:: always returns true
+      #
+      def <<(msg)
+        info(msg)
+      end
+
+      # Do nothing. This method is provided for Logger interface compatibility.
+      #
+      # === Return
+      # true:: always returns true
+      #
+      def close
+        return true
+      end
+
+      private
+
+      # Call the syslog function to emit a syslog entry.
+      #
+      # === Parameters
+      # severity(Integer):: one of the Logger severity constants
+      # message(String):: the log message
+      #
+      # === Return
+      # true:: always returns true
+      def emit_syslog(severity, message)
+        level = SYSLOG_LEVELS[severity] || DEFAULT_SYSLOG_LEVEL
+        @@syslog.send(level, message)
+        return true
+      end
+
+      # Perform cleanup, output escaping and splitting on message.
+      # The operations that it performs can vary, depending on the
+      # options that were passed to this logger at initialization
+      # time.
+      #
+      # === Parameters
+      # message(String):: raw log message
+      #
+      # === Return
+      # log_lines([String]):: an array of String messages that should be logged separately to syslog
+      def clean(message)
+        message = message.to_s.dup
+        message.strip!
+        message.gsub!(/%/, '%%') # syslog(3) freaks on % (printf)
+
+        unless @options[:color]
+          message.gsub!(/\e\[[^m]*m/, '') # remove useless ansi color codes
+        end
+
+        if @options[:split]
+          bits = message.split(/[\n\r]+/)
+        else
+          bits = [message]
+        end
+
+        return bits
+      end  
+    end
+  end
+end

data/lib/right_support/tag_logger.rb

@@ -0,0 +1,72 @@
+#
+# Copyright (c) 2011 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
+  # A logger that prepends a tag to every message that is emitted. Can be used to
+  # correlate logs with a Web session ID, transaction ID or other context.
+  #
+  # The user of this logger is responsible for calling #tag= to set the tag as
+  # appropriate, e.g. in a Web request around-filter.
+  #
+  # This logger uses thread-local storage (TLS) to provide tagging on a per-thread
+  # basis; however, it does not account for EventMachine, neverblock, the use of
+  # Ruby fibers, or any other phenomenon that can "hijack" a thread's call stack.
+  #
+  class TagLogger < FilterLogger
+    # Prepend the current tag to the log message; return the same severity and
+    # the modified message.
+    #
+    # === Parameters
+    # severity(Integer):: one of the severity constants defined by Logger
+    # messgae(String):: the log message
+    #
+    # === Return
+    # Returns a pair consisting of the filtered [severity, message].
+    #
+    def filter(severity, message)
+      @tls_id ||= "tag_logger_#{self.object_id}"
+      tag = Thread.current[@tls_id] || ''
+      if tag
+        return [severity, tag + message]
+      else
+        return [severity, message]
+      end
+    end
+
+    attr_reader :tag
+    
+    # Set the tag for this logger.
+    #
+    # === Parameters
+    # tag(String|nil):: the new tag, or nil to remove the tag
+    #
+    # === Return
+    # String:: returns the new tag
+    def tag=(tag)
+      @tag = tag
+      @tls_id ||= "tag_logger_#{self.object_id}"
+      Thread.current[@tls_id] = @tag
+    end
+  end
+end

data/lib/right_support/validation/openssl.rb

@@ -0,0 +1,90 @@
+#
+# Copyright (c) 2011 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 'openssl'
+
+module RightSupport::Validation
+  # Validation methods pertaining to OpenSSL cryptography, e.g. various
+  # widely-used key formats and encoding/envelope formats.
+  module OpenSSL
+    # Determine whether a string is a PEM-encoded public or private key.
+    # Does not determine whether the key is valid, only that it is well-formed.
+    #
+    # === Parameters
+    # key_material(String):: the putative key material
+    #
+    # === Return
+    # If the key is well-formed, return the OpenSSL class that can be used
+    # to process the key material (e.g. OpenSSL::PKey::RSA). Otherwise, return
+    # false.
+    def pem_key?(key_material)
+      return false if key_material.nil? || key_material.empty?
+      m = /BEGIN ([A-Z]+) (PUBLIC|PRIVATE) KEY/.match(key_material)
+      return false unless m
+      case m[1]
+        when 'DSA' then return ::OpenSSL::PKey::DSA
+        when 'RSA' then return ::OpenSSL::PKey::RSA
+        else return false
+      end
+
+    end
+
+    # Determine whether a string is a valid PEM-encoded private key.
+    # Actually parses the key to prove validity as well as well-formedness.
+    # If the key is passphrase-protected, the passphrase is required in
+    # order to decrypt it; am incorrect passphrase will result in the key
+    # being recognized as not a valid key!
+    #
+    # === Parameters
+    # key_material(String):: the putative key material
+    # passphrase(String):: the encryption passphrase, if needed
+    #
+    # === Return
+    # If the key is well-formed and valid, return true. Otherwise, return false.
+    #
+    def pem_private_key?(key_material, passphrase=nil)
+      alg = pem_key?(key_material)
+      return false unless alg
+      key = alg.new(key_material, passphrase || 'dummy passphrase, should never work')
+      return key.private?
+    rescue ::OpenSSL::PKey::PKeyError, NotImplementedError
+      return false
+    end
+
+    # Determine whether a string is a valid PEM-encoded public key.
+    # Actually parses the key to prove validity as well as well-formedness.
+    #
+    # === Parameters
+    # key_material(String):: the putative key material
+    #
+    # === Return
+    # If the key is well-formed and valid, return true. Otherwise, return false.
+    def pem_public_key?(key_material)
+      alg = pem_key?(key_material)
+      return false unless alg
+      key = alg.new(key_material)
+      return key.public?
+    rescue ::OpenSSL::PKey::PKeyError, NotImplementedError
+      return false
+    end
+  end
+end

data/lib/right_support/validation/ssh.rb

@@ -0,0 +1,70 @@
+#
+# Copyright (c) 2011 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.
+
+if_require_succeeds('net/ssh') do
+  module RightSupport::Validation
+    # Validation methods pertaining to the Secure Shell (SSH) protocol.
+    module SSH
+      # Determine whether a string is a valid PEM-encoded private key.
+      # Actually parses the key to prove validity as well as well-formedness.
+      # Relies on the OpenSSL Validation module to parse the private key
+      # since PEM is a standard non-SSH-specific key format.
+      #
+      # === Parameters
+      # key_material(String):: the putative key material
+      # passphrase(String):: the encryption passphrase, if needed
+      #
+      # === Return
+      # If the key is well-formed and valid, return true. Otherwise, return false.
+      def ssh_private_key?(key_material, passphrase=nil)
+        return RightSupport::Validation.pem_private_key?(key_material, passphrase)
+      end
+
+      # Determine whether a string is a valid public key in SSH public-key
+      # notation as might be found in an SSH authorized_keys file.
+      #
+      # However, authorized-key options are not allowed as they would be in an
+      # actual line of the authorized_keys file. The caller is responsible for
+      # stripping out any options. The string can consist of the following three
+      # whitespace-separated fields:
+      #  * algorithm (e.g. "ssh-rsa")
+      #  * key material (base64-encoded blob)
+      #  * comments (e.g. "user@localhost"); optional
+      #
+      # This method actually parses the public key to prove validity as well as
+      # well-formedness.
+      #
+      # === Parameters
+      # key_material(String):: the putative key material
+      #
+      # === Return
+      # If the key is well-formed and valid, return true. Otherwise, return false.
+      def ssh_public_key?(key_material)
+        return false if key_material.nil? || key_material.empty?
+        ::Net::SSH::KeyFactory.load_data_public_key(key_material)
+        return true
+      rescue ::Net::SSH::Exception, ::OpenSSL::PKey::PKeyError, NotImplementedError
+        return false
+      end
+    end
+  end
+end

data/lib/right_support/validation.rb

@@ -0,0 +1,45 @@
+#
+# Copyright (c) 2011 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.
+
+module RightSupport
+  # The Validation module acts as a namespace for various submodules that provide
+  # validation functions. These submodules can be mixed into classes in order to
+  # add validation logic.
+  #
+  # As a convenience, to discourage mixin abuse, the Validation module includes
+  # all of its submodules into its eigenclass at load-time. This means that every
+  # validation method "is_foo" provided by _any_ submodule can be accessed simply
+  # with a call to Validation.is_foo.
+  #
+  module Validation
+
+  end
+end
+
+Dir[File.expand_path('../validation/*.rb', __FILE__)].each do |filename|
+  require filename
+end
+
+RightSupport::Validation.constants.each do |const|
+  const = RightSupport::Validation.const_get(const) #string to constant
+  RightSupport::Validation.extend(const)
+end

data/lib/right_support.rb

@@ -0,0 +1,9 @@
+require 'right_support/kernel_extensions'
+require 'right_support/filter_logger'
+require 'right_support/system_logger'
+require 'right_support/tag_logger'
+require 'right_support/rack/custom_logger'
+
+require 'right_support/validation'
+
+require 'right_support/net'

data/right_support.gemspec

@@ -0,0 +1,31 @@
+# -*- mode: ruby; encoding: utf-8 -*-
+
+require 'rubygems'
+
+spec = Gem::Specification.new do |s|
+  s.required_rubygems_version = nil if s.respond_to? :required_rubygems_version=
+  s.required_ruby_version = Gem::Requirement.new(">= 1.8.7")
+
+  s.name    = 'right_support'
+  s.version = '0.8.0'
+  s.date    = '2011-04-09'
+
+  s.authors = ['Tony Spataro']
+  s.email   = 'tony@rightscale.com'
+  s.homepage= 'https://github.com/xeger/right_support'
+
+  s.summary = %q{Reusable foundation code.}
+  s.description = %q{A toolkit of useful foundation code: logging, input validation, etc.}
+
+  s.add_development_dependency('rake', [">= 0.8.7"])
+  s.add_development_dependency('ruby-debug', [">= 0.10"])
+  s.add_development_dependency('rspec', ["~> 1.3"])
+  s.add_development_dependency('cucumber', ["~> 0.8"])
+  s.add_development_dependency('flexmock', ["~> 0.8"])
+  s.add_development_dependency('net-ssh', ["~> 2.0"])
+  s.add_development_dependency('rest-client', ["~> 1.6"])
+
+  basedir = File.dirname(__FILE__)
+  candidates = ['right_support.gemspec', 'LICENSE', 'README.rdoc'] + Dir['lib/**/*']
+  s.files = candidates.sort
+end

metadata

@@ -0,0 +1,188 @@
+--- !ruby/object:Gem::Specification 
+name: right_support
+version: !ruby/object:Gem::Version 
+  hash: 63
+  prerelease: false
+  segments: 
+  - 0
+  - 8
+  - 0
+  version: 0.8.0
+platform: ruby
+authors: 
+- Tony Spataro
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-09 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 0
+        - 8
+        - 7
+        version: 0.8.7
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 0
+        - 10
+        version: "0.10"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 1
+        - 3
+        version: "1.3"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 0
+        - 8
+        version: "0.8"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: flexmock
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 0
+        - 8
+        version: "0.8"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: net-ssh
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 1
+        - 6
+        version: "1.6"
+  type: :development
+  version_requirements: *id007
+description: "A toolkit of useful foundation code: logging, input validation, etc."
+email: tony@rightscale.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- README.rdoc
+- lib/right_support.rb
+- lib/right_support/filter_logger.rb
+- lib/right_support/kernel_extensions.rb
+- lib/right_support/net.rb
+- lib/right_support/net/request_balancer.rb
+- lib/right_support/net/rest.rb
+- lib/right_support/rack/custom_logger.rb
+- lib/right_support/system_logger.rb
+- lib/right_support/tag_logger.rb
+- lib/right_support/validation.rb
+- lib/right_support/validation/openssl.rb
+- lib/right_support/validation/ssh.rb
+- right_support.gemspec
+has_rdoc: true
+homepage: https://github.com/xeger/right_support
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 57
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Reusable foundation code.
+test_files: []
+