sgeorgi-logging 1.4.2

data/lib/logging/utils.rb

@@ -0,0 +1,201 @@
+
+# --------------------------------------------------------------------------
+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 File
+
+  # Returns <tt>true</tt> if another process holds an exclusive lock on the
+  # file. Returns <tt>false</tt> if this is not the case.
+  #
+  # If a <tt>block</tt> of code is passed to this method, it will be run iff
+  # this process can obtain an exclusive lock on the file. The block will be
+  # run while this lock is held, and the exclusive lock will be released when
+  # the method returns.
+  #
+  # The exclusive lock is requested in a non-blocking mode. This method will
+  # return immediately (and the block will not be executed) if an exclusive
+  # lock cannot be obtained.
+  #
+  def flock?( &block )
+    status = flock(LOCK_EX|LOCK_NB)
+    case status
+    when false; true
+    when 0; block ? block.call : false
+    else
+      raise SystemCallError, "flock failed with status: #{status}"
+    end
+  ensure
+    flock LOCK_UN
+  end
+
+  # Execute the <tt>block</tt> in the context of a shared lock on this file. A
+  # shared lock will be obtained on the file, the block executed, and the lock
+  # released.
+  #
+  def flock_sh( &block )
+    flock LOCK_SH
+    block.call
+  ensure
+    flock LOCK_UN
+  end
+
+  # :stopdoc:
+  if %r/mswin|mingw/ =~ RUBY_PLATFORM
+    undef :flock?, :flock_sh
+    def flock?() yield; end
+    def flock_sh() yield; end
+  end
+  # :startdoc:
+
+end
+
+# --------------------------------------------------------------------------
+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/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/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/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