redcar 0.2.9dev

data/lib/logging/lib/logging/utils.rb

@@ -0,0 +1,153 @@
+
+# --------------------------------------------------------------------------
+class Hash
+
+  # call-seq:
+  #    getopt( key, default = nil, :as => class )
+  #
+  # Returns the value associated with the _key_. If the has does not contain
+  # the _key_, then the _default_ value is returned.
+  #
+  # Optionally, the value can be converted into to an instance of the given
+  # _class_. The supported classes are:
+  #
+  #     Integer
+  #     Float
+  #     Array
+  #     String
+  #     Symbol
+  #
+  # If the value is +nil+, then no converstion will be performed.
+  #
+  def getopt( *args )
+    opts = args.last.instance_of?(Hash) ? args.pop : {}
+    key, default = args
+
+    val = if has_key?(key);                self[key]
+          elsif has_key?(key.to_s);        self[key.to_s]
+          elsif has_key?(key.to_s.intern); self[key.to_s.intern]
+          else default end
+
+    return if val.nil?
+    return val unless opts.has_key?(:as)
+
+    case opts[:as].name.intern
+    when :Integer; Integer(val)
+    when :Float;   Float(val)
+    when :Array;   Array(val)
+    when :String;  String(val)
+    when :Symbol;  String(val).intern
+    else val end
+  end
+end
+
+# --------------------------------------------------------------------------
+class String
+
+  # call-seq:
+  #    reduce( width, ellipses = '...' )    #=> string
+  #
+  # Reduce the size of the current string to the given _width_ by removing
+  # characters from the middle of the string and replacing them with
+  # _ellipses_. If the _width_ is greater than the length of the string, the
+  # string is returned unchanged. If the _width_ is less than the length of
+  # the _ellipses_, then the _ellipses_ are returned.
+  #
+  def reduce( width, ellipses = '...')
+    raise ArgumentError, "width cannot be negative: #{width}" if width < 0
+
+    return self if length <= width
+
+    remove = length - width + ellipses.length
+    return ellipses.dup if remove >= length
+
+    left_end = (length + 1 - remove) / 2
+    right_start = left_end + remove
+
+    left = self[0,left_end]
+    right = self[right_start,length-right_start]
+
+    left << ellipses << right
+  end
+end
+
+# --------------------------------------------------------------------------
+class Module
+
+  # call-seq:
+  #    logger_name    #=> string
+  #
+  # Returns a predictable logger name for the current module or class. If
+  # used within an anonymous class, the first non-anonymous class name will
+  # be used as the logger name. If used within a meta-class, the name of the
+  # actual class will be used as the logger name. If used within an
+  # anonymous module, the string 'anonymous' will be returned.
+  #
+  def logger_name
+    return name unless name.nil? or name.empty?
+
+    # check if this is a metaclass (or eigenclass)
+    if ancestors.include? Class
+      inspect =~ %r/#<Class:([^#>]+)>/
+      return $1
+    end
+
+    # see if we have a superclass
+    if respond_to? :superclass
+      return superclass.logger_name
+    end
+
+    # we are an anonymous module
+    ::Logging.log_internal(-2) {
+      'cannot return a predictable, unique name for anonymous modules'
+    }
+    return 'anonymous'
+  end
+end
+
+# --------------------------------------------------------------------------
+module Kernel
+
+  # call-seq:
+  #    require?( string )
+  #
+  # Attempt to the load the library named _string_ using the standard
+  # Kernel#require method. Returns +true+ if the library was successfully
+  # loaded. Returns +false+ if the library could not be loaded. This method
+  # will never raise an exception.
+  #
+  def require?( string )
+    require string
+    return true
+  rescue LoadError
+    return false
+  end
+end  # module Kernel
+
+# --------------------------------------------------------------------------
+class ReentrantMutex < Mutex
+
+  def initialize
+    super
+    @locker = nil
+  end
+
+  alias :original_synchronize :synchronize
+
+  def synchronize
+    if @locker == Thread.current
+      yield
+    else
+      original_synchronize {
+        begin
+          @locker = Thread.current
+          yield
+        ensure
+          @locker = nil
+        end
+      }
+    end
+  end
+end  # class ReentrantMutex
+
+# EOF

data/lib/logging/lib/spec/logging_helper.rb

@@ -0,0 +1,34 @@
+
+module Spec
+  module LoggingHelper
+
+    # Capture log messages from the Logging framework and make them
+    # available via a @log_output instance variable. The @log_output
+    # supports a readline method to access the log messags.
+    #
+    def capture_log_messages( opts = {} )
+      from = opts.getopt(:from, 'root')
+      to = opts.getopt(:to, '__rspec__')
+      exclusive = opts.getopt(:exclusive, true)
+
+      appender = Logging::Appenders[to] || Logging::Appenders::StringIo.new(to)
+      logger = Logging::Logger[from]
+      if exclusive
+        logger.appenders = appender
+      else
+        logger.add_appenders(appender)
+      end
+
+      before(:all) do
+        @log_output = Logging::Appenders[to]
+      end
+
+      before(:each) do
+        @log_output.reset
+      end
+    end
+
+  end  # module LoggingHelper
+end  # module Spec
+
+# EOF

data/lib/logging/test/appenders/test_buffered_io.rb

@@ -0,0 +1,176 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestAppenders
+
+  class TestBufferedIO < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      @appender = Logging.appenders.string_io(
+        'test_appender', :auto_flushing => 3, :immediate_at => :error
+      )
+      @appender.clear
+      @sio = @appender.sio
+      @levels = Logging::LEVELS
+      begin readline rescue EOFError end
+    end
+
+    def test_append
+      event = Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                    [1, 2, 3, 4], false)
+      @appender.append event
+      assert_nil(readline)
+
+      @appender.append event
+      assert_nil(readline)
+
+      event.level = @levels['debug']
+      event.data = 'the big log message'
+      @appender.append event
+
+      assert_equal " WARN  TestLogger : <Array> #{[1, 2, 3, 4]}\n", readline
+      assert_equal " WARN  TestLogger : <Array> #{[1, 2, 3, 4]}\n", readline
+      assert_equal "DEBUG  TestLogger : the big log message\n", readline
+      assert_nil(readline)
+
+      @appender.close
+      assert_raise(RuntimeError) {@appender.append event}
+    end
+
+    def test_append_error
+      # setup an internal logger to capture error messages from the IO
+      # appender
+      log = Logging.appenders.string_io('__internal_io')
+      Logging.logger[Logging].add_appenders(log)
+      Logging.logger[Logging].level = 'all'
+
+
+      # close the string IO object so we get an error
+      @sio.close
+      event = Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                    [1, 2, 3, 4], false)
+      @appender.append event
+      assert_nil(log.readline)
+
+      @appender.append event
+      assert_nil(log.readline)
+
+      @appender.append event
+      assert_equal "INFO  Logging : appender \"test_appender\" has been disabled", log.readline.strip
+      assert_equal "ERROR  Logging : <IOError> not opened for writing", log.readline.strip
+
+      assert_equal false, @appender.closed?
+      assert_equal 5, @appender.level
+    end
+
+    def test_auto_flushing
+      assert_raise(ArgumentError) {
+        @appender.auto_flushing = Object.new
+      }
+
+      assert_raise(ArgumentError) {
+        @appender.auto_flushing = -1
+      }
+    end
+
+    def test_close
+      assert_equal false, @sio.closed?
+      assert_equal false, @appender.closed?
+
+      @appender.close
+      assert_equal true, @sio.closed?
+      assert_equal true, @appender.closed?
+
+      [STDIN, STDERR, STDOUT].each do |io|
+        @appender = Logging.appenders.io('test', io)
+        @appender.close
+        assert_equal false, io.closed?
+        assert_equal true, @appender.closed?
+      end
+    end
+
+    def test_concat
+      @appender << "this is a test message\n"
+      assert_nil(readline)
+
+      @appender << "this is another message\n"
+      assert_nil(readline)
+
+      @appender << "some other line\n"
+
+      assert_equal "this is a test message\n", readline
+      assert_equal "this is another message\n", readline
+      assert_equal "some other line\n", readline
+      assert_nil(readline)
+
+      @appender.close
+      assert_raise(RuntimeError) {@appender << 'message'}
+    end
+
+    def test_concat_error
+      # setup an internal logger to capture error messages from the IO
+      # appender
+      log = Logging.appenders.string_io('__internal_io')
+      Logging.logger[Logging].add_appenders(log)
+      Logging.logger[Logging].level = 'all'
+
+      # close the string IO object so we get an error
+      @sio.close
+      @appender << 'oopsy'
+      assert_nil(log.readline)
+
+      @appender << 'whoopsy'
+      assert_nil(log.readline)
+
+      @appender << 'pooh'
+      assert_equal "INFO  Logging : appender \"test_appender\" has been disabled", log.readline.strip
+      assert_equal "ERROR  Logging : <IOError> not opened for writing", log.readline.strip
+
+      # and the appender does not close itself
+      assert_equal false, @appender.closed?
+      assert_equal 5, @appender.level
+    end
+
+    def test_flush
+      ary = []
+      @sio.instance_variable_set :@ary, ary
+      def @sio.flush() @ary << :flush end
+
+      @appender << "this is a test message\n"
+      assert_nil(readline)
+
+      @appender.flush
+      assert_equal :flush, ary.pop
+      assert_equal "this is a test message\n", readline
+      assert_nil(readline)
+    end
+
+    def test_immediate_at
+      event = Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                    [1, 2, 3, 4], false)
+      @appender.append event
+      assert_nil(readline)
+
+      event.level = @levels['error']
+      event.data = 'an error message'
+      @appender.append event
+
+      assert_equal " WARN  TestLogger : <Array> #{[1, 2, 3, 4]}\n", readline
+      assert_equal "ERROR  TestLogger : an error message\n", readline
+      assert_nil(readline)
+    end
+
+    private
+    def readline
+      @appender.readline
+    end
+
+  end  # class TestBufferedIO
+
+end  # module TestAppenders
+end  # module TestLogging
+
+# EOF

data/lib/logging/test/appenders/test_console.rb

@@ -0,0 +1,66 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestAppenders
+
+  class TestStdout < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def test_initialize
+      Logging::Repository.instance
+
+      appender = Logging.appenders.stdout
+      assert_equal 'stdout', appender.name
+      assert_same STDOUT, appender.instance_variable_get(:@io)
+
+      appender.close
+      assert_equal true, appender.closed?
+      assert_equal false, STDOUT.closed?
+
+      appender = Logging.appenders.stdout('foo')
+      assert_equal 'foo', appender.name
+
+      appender = Logging.appenders.stdout(:level => :warn)
+      assert_equal 'stdout', appender.name
+      assert_equal 2, appender.level
+
+      appender = Logging.appenders.stdout('bar', :level => :error)
+      assert_equal 'bar', appender.name
+      assert_equal 3, appender.level
+    end
+
+  end  # class TestStdout
+
+  class TestStderr < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def test_initialize
+      Logging::Repository.instance
+
+      appender = Logging.appenders.stderr
+      assert_equal 'stderr', appender.name
+      assert_same STDERR, appender.instance_variable_get(:@io)
+
+      appender.close
+      assert_equal true, appender.closed?
+      assert_equal false, STDERR.closed?
+
+      appender = Logging.appenders.stderr('foo')
+      assert_equal 'foo', appender.name
+
+      appender = Logging.appenders.stderr(:level => :warn)
+      assert_equal 'stderr', appender.name
+      assert_equal 2, appender.level
+
+      appender = Logging.appenders.stderr('bar', :level => :error)
+      assert_equal 'bar', appender.name
+      assert_equal 3, appender.level
+    end
+
+  end  # class TestStderr
+
+end  # module TestAppenders
+end  # module TestLogging
+
+# EOF

data/lib/logging/test/appenders/test_email.rb

@@ -0,0 +1,170 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+require 'flexmock'
+
+module TestLogging
+module TestAppenders
+
+  class TestEmail < Test::Unit::TestCase
+    include FlexMock::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+
+      flexmock(Net::SMTP).new_instances do |m|
+        m.should_receive(:start).at_least.once.with(
+            'test.logging', 'test', 'test', :cram_md5, Proc).and_yield(m)
+        m.should_receive(:sendmail).at_least.once.with(String, 'me', ['you'])
+      end
+
+      @appender = Logging.appenders.email('email',
+          'from' => 'me', 'to' => 'you',
+          :buffer_size => '3', :immediate_at => 'error, fatal',
+          :domain => 'test.logging', :acct => 'test', :passwd => 'test'
+      )
+      @levels = Logging::LEVELS
+    end
+
+    def test_initialize
+      assert_raise(ArgumentError, 'Must specify from address') {
+        Logging.appenders.email('email')
+      }
+      assert_raise(ArgumentError, 'Must specify to address') {
+        Logging.appenders.email('email', :from => 'me')
+      }
+      assert_nothing_raised {
+        Logging.appenders.email('email', :from => 'me', :to => 'you')
+      }
+
+      appender = Logging.appenders.email('email',
+          'from' => 'me', 'to' => 'you'
+      )
+
+      assert_equal(100, appender.auto_flushing)
+      assert_equal([], appender.instance_variable_get(:@immediate))
+      assert_equal('localhost', appender.server)
+      assert_equal(25, appender.port)
+
+      domain = ENV['HOSTNAME'] || 'localhost.localdomain'
+      assert_equal(domain, appender.domain)
+      assert_equal(nil, appender.acct)
+      assert_equal(:cram_md5, appender.authtype)
+      assert_equal("Message of #{$0}", appender.subject)
+
+      appender = Logging.appenders.email('email',
+          'from' => 'lbrinn@gmail.com', 'to' => 'everyone',
+          :buffsize => '1000', :immediate_at => 'error, fatal',
+          :server => 'smtp.google.com', :port => '443',
+          :domain => 'google.com', :acct => 'lbrinn',
+          :passwd => '1234', :authtype => 'tls',
+          :subject => "I'm rich and you're not"
+      )
+
+      assert_equal('lbrinn@gmail.com', appender.instance_variable_get(:@from))
+      assert_equal(['everyone'], appender.instance_variable_get(:@to))
+      assert_equal(1000, appender.auto_flushing)
+      assert_equal('1234', appender.instance_variable_get(:@passwd))
+      assert_equal([nil, nil, nil, true, true],
+                   appender.instance_variable_get(:@immediate))
+      assert_equal('smtp.google.com', appender.server)
+      assert_equal(443, appender.port)
+      assert_equal('google.com', appender.domain)
+      assert_equal('lbrinn', appender.acct)
+      assert_equal(:tls, appender.authtype)
+      assert_equal("I'm rich and you're not", appender.subject)
+
+      appender = Logging.appenders.email('email',
+          'from' => 'me', 'to' => 'you', :auto_flushing => 42
+      )
+      assert_equal(42, appender.auto_flushing)
+    end
+
+    def test_append
+      # with auto_flushing enabled, mail will be sent each time a log event
+      # occurs
+      @appender.auto_flushing = true
+      event = Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                    [1, 2, 3, 4], false)
+      @appender.append event
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+
+      # increase the buffer size and log a few events
+      @appender.auto_flushing = 3
+      @appender.append event
+      @appender.append event
+      assert_equal(2, @appender.buffer.length)
+
+      @appender.append event
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+
+      # error and fatal messages should be send immediately (no buffering)
+      error = Logging::LogEvent.new('ErrLogger', @levels['error'],
+                                    'error message', false)
+      fatal = Logging::LogEvent.new('FatalLogger', @levels['fatal'],
+                                    'fatal message', false)
+
+      @appender.append event
+      @appender.append fatal
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+
+      @appender.append error
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+
+      @appender.append event
+      assert_equal(1, @appender.buffer.length)
+    end
+
+    def test_concat
+      # with auto_flushing enabled, mail will be sent each time a log event
+      # occurs
+      @appender.auto_flushing = true
+      @appender << 'test message'
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+
+      # increase the buffer size and log a few events
+      @appender.auto_flushing = 3
+      @appender << 'another test message'
+      @appender << 'a second test message'
+      assert_equal(2, @appender.buffer.length)
+
+      @appender << 'a third test message'
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+    end
+
+    def test_flush
+      event = Logging::LogEvent.new('TestLogger', @levels['info'],
+                                    [1, 2, 3, 4], false)
+      @appender.append event
+      @appender << 'test message'
+      assert_equal(2, @appender.buffer.length)
+
+      @appender.flush
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+    end
+
+    def test_close
+      event = Logging::LogEvent.new('TestLogger', @levels['info'],
+                                    [1, 2, 3, 4], false)
+      @appender.append event
+      @appender << 'test message'
+      assert_equal(2, @appender.buffer.length)
+
+      @appender.close
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+      assert(@appender.closed?)
+    end
+
+  end  # class TestEmail
+end  # module TestLogging
+end  # module TestAppenders
+
+# EOF