logging 0.1.0

data/lib/logging/root_logger.rb

@@ -0,0 +1,69 @@
+# $Id: root_logger.rb 13 2007-01-15 17:19:37Z tim_pease $
+
+require 'logging'
+require 'logging/logger'
+
+module Logging
+
+  #
+  # The root logger exists to ensure that all loggers have a parent and a
+  # defined logging level. If a logger is additive, eventually its log
+  # events will propogate up to the root logger.
+  #
+  class RootLogger < Logger
+
+    # undefine the methods that the root logger does not need
+    %w(additive additive= parent parent=).each do |m|
+      undef_method m.intern
+    end
+
+    #
+    # call-seq:
+    #    RootLogger.new
+    #
+    # Returns a new root logger instance. This method will be called only
+    # once when the +Repository+ singleton instance is created.
+    #
+    def initialize( )
+      unless ::Logging.const_defined? 'MAX_LEVEL_LENGTH'
+        ::Logging.define_levels %w(debug info warn error fatal)
+      end
+
+      @name = 'root'
+      @appenders = []
+      @additive = false
+      @trace = false
+      self.level = 0
+    end
+
+    #
+    # call-seq:
+    #    log <=> other
+    #
+    # Compares this logger by name to another logger. The normal return codes
+    # for +String+ objects apply.
+    #
+    def <=>( other )
+      case other
+      when self: 0
+      when ::Logging::Logger: -1
+      else raise ArgumentError, 'expecting a Logger instance' end
+    end
+
+    #
+    # call-seq:
+    #    level = :all
+    #
+    # Set the level for the root logger. The functionality of this method is
+    # the same as +Logger#level=+, but setting the level to +nil+ for the
+    # root logger is not allowed. The level is silently set to :all.
+    #
+    def level=( level )
+      level ||= 0
+      super
+    end
+
+  end  # class RootLogger
+end  # module Logging
+
+# EOF

data/test/appenders/test_console.rb

@@ -0,0 +1,40 @@
+# $Id: test_console.rb 2 2007-01-09 18:10:50Z tim_pease $
+
+require 'test/setup.rb'
+
+module TestLogging
+module TestAppenders
+
+  class TestStdOut < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def test_initialize
+      appender = ::Logging::Appenders::StdOut.new
+      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?
+    end
+
+  end  # class TestStdOut
+
+  class TestStdErr < Test::Unit::TestCase
+
+    def test_initialize
+      appender = ::Logging::Appenders::StdErr.new
+      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?
+    end
+
+  end  # class TestStdErr
+
+end  # module TestAppenders
+end  # module TestLogging
+
+# EOF

data/test/appenders/test_file.rb

@@ -0,0 +1,76 @@
+# $Id: test_file.rb 2 2007-01-09 18:10:50Z tim_pease $
+
+require 'test/setup.rb'
+require 'fileutils'
+
+module TestLogging
+module TestAppenders
+
+  class TestFile < Test::Unit::TestCase
+    include LoggingTestCase
+
+    TMP = 'tmp'
+
+    def setup
+      super
+      FileUtils.rm_rf TMP if File.exist?(TMP)
+      FileUtils.mkdir(TMP)
+      FileUtils.mkdir [File.join(TMP, 'dir'), File.join(TMP, 'uw_dir')]
+      FileUtils.chmod 0555, File.join(TMP, 'uw_dir')
+      FileUtils.touch File.join(TMP, 'uw_file')
+      FileUtils.chmod 0444, File.join(TMP, 'uw_file')
+    end
+
+    def teardown
+      FileUtils.rm_rf TMP
+    end
+
+    def test_initialize
+      log = File.join(TMP, 'uw_dir', 'file.log')
+      assert_raise(StandardError) {::Logging::Appenders::File.new log}
+
+      log = File.join(TMP, 'dir')
+      assert_raise(StandardError) {::Logging::Appenders::File.new log}
+
+      log = File.join(TMP, 'uw_file')
+      assert_raise(StandardError) {::Logging::Appenders::File.new log}
+
+      log = File.join(TMP, 'file.log')
+      appender = ::Logging::Appenders::File.new log
+      assert_equal log, appender.name
+      appender << "This will be the first line\n"
+      appender << "This will be the second line\n"
+      File.open(log, 'r') do |file|
+        assert_equal "This will be the first line\n", file.readline
+        assert_equal "This will be the second line\n", file.readline
+        assert_raise(EOFError) {file.readline}
+      end
+      appender.close
+
+      appender = ::Logging::Appenders::File.new log
+      assert_equal log, appender.name
+      appender << "This will be the third line\n"
+      File.open(log, 'r') do |file|
+        assert_equal "This will be the first line\n", file.readline
+        assert_equal "This will be the second line\n", file.readline
+        assert_equal "This will be the third line\n", file.readline
+        assert_raise(EOFError) {file.readline}
+      end
+      appender.close
+
+      appender = ::Logging::Appenders::File.new log, :truncate => true
+      assert_equal log, appender.name
+      appender << "The file was truncated\n"
+      File.open(log, 'r') do |file|
+        assert_equal "The file was truncated\n", file.readline
+        assert_raise(EOFError) {file.readline}
+      end
+      appender.close
+    end
+
+  end  # class TestFile
+
+end  # module TestAppenders
+end  # module TestLogging
+
+# EOF

data/test/appenders/test_io.rb

@@ -0,0 +1,113 @@
+# $Id: test_io.rb 15 2007-01-15 19:03:45Z tim_pease $
+
+require 'test/setup.rb'
+require 'stringio'
+
+module TestLogging
+module TestAppenders
+
+  class TestIO < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      ::Logging.define_levels %w(debug info warn error fatal)
+      @levels = ::Logging::LEVELS
+
+      @sio = StringIO.new
+      @appender = ::Logging::Appenders::IO.new 'test_appender', @sio
+      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_equal " WARN  TestLogger : <Array> 1234\n", readline
+      assert_raise(EOFError) {readline}
+
+      event.level = @levels['debug']
+      event.data = ['the big log message', [1, 2, 3, 4]]
+      @appender.append event
+      assert_equal "DEBUG  TestLogger : the big log message\n", readline
+      assert_equal "DEBUG  TestLogger : <Array> 1234\n", readline
+      assert_raise(EOFError) {readline}
+
+      @appender.close
+      assert_raise(RuntimeError) {@appender.append event}
+    end
+
+    def test_append_error
+      @sio.close
+      event = ::Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                      [[1, 2, 3, 4]], false)
+      assert_raise(IOError) {@appender.append event}
+      assert_equal true, @appender.closed?
+    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.new '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_equal "this is a test message\n", readline
+      assert_raise(EOFError) {readline}
+
+      @appender << "this is another message\n"
+      @appender << "some other line\n"
+      assert_equal "this is another message\n", readline
+      assert_equal "some other line\n", readline
+      assert_raise(EOFError) {readline}
+
+      @appender.close
+      assert_raise(RuntimeError) {@appender << 'message'}
+    end
+
+    def test_concat_error
+      @sio.close
+      assert_raise(IOError) {@appender << 'oopsy'}
+      assert_equal true, @appender.closed?
+    end
+
+    def test_flush
+      ary = []
+      @sio.instance_variable_set :@ary, ary
+      def @sio.flush() @ary << :flush end
+
+      @appender.flush
+      assert_equal :flush, ary.pop
+    end
+
+    def test_initialize
+      assert_raise(EOFError) {@sio.readline}
+      assert_raise(TypeError) {::Logging::Appenders::IO.new 'test', []}
+    end
+
+    private
+    def readline
+      @pos ||= 0
+      @sio.seek @pos
+      line = @sio.readline
+      @pos = @sio.tell
+      line
+    end
+
+  end  # class TestIO
+
+end  # module TestAppenders
+end  # module TestLogging
+
+# EOF

data/test/benchmark.rb

@@ -0,0 +1,80 @@
+# $Id: benchmark.rb 2 2007-01-09 18:10:50Z tim_pease $
+
+begin
+  require 'logging'
+rescue LoadError
+  require 'rubygems'
+  require 'logging'
+end
+
+begin
+  require 'rubygems'
+  require 'log4r'
+  $log4r = true
+rescue LoadError
+  $log4r = false
+end
+
+require 'benchmark'
+require 'stringio'
+require 'logger'
+
+module Logging
+  class Benchmark
+
+    def run
+      this_many = 100_000
+
+      sio = StringIO.new
+
+      ::Logging::Logger[:root].level = 'warn'
+      logging = ::Logging::Logger[self]
+      logging.add ::Logging::Appenders::IO.new('benchmark', sio)
+
+      logger = ::Logger.new sio
+      logger.level = ::Logger::WARN
+
+      log4r = if $log4r
+        x = ::Log4r::Logger.new('benchmark')
+        x.level = ::Log4r::WARN
+        x.add ::Log4r::IOOutputter.new('benchmark', sio)
+        x
+      end
+
+      puts "== Debug (not logged) ==\n"
+      ::Benchmark.bm(10) do |bm|
+        bm.report('Logging:') {this_many.times {logging.debug 'not logged'}}
+        bm.report('Logger:') {this_many.times {logger.debug 'not logged'}}
+        bm.report('Log4r:') {this_many.times {log4r.debug 'not logged'}} if log4r
+      end
+
+      puts "\n== Warn (logged) ==\n"
+      ::Benchmark.bm(10) do |bm|
+        sio.seek 0
+        bm.report('Logging:') {this_many.times {logging.warn 'logged'}}
+        sio.seek 0
+        bm.report('Logger:') {this_many.times {logger.warn 'logged'}}
+        sio.seek 0
+        bm.report('Log4r:') {this_many.times {log4r.warn 'logged'}} if log4r
+      end
+
+      puts "\n== Concat ==\n"
+      ::Benchmark.bm(10) do |bm|
+        sio.seek 0
+        bm.report('Logging:') {this_many.times {logging << 'logged'}}
+        sio.seek 0
+        bm.report('Logger:') {this_many.times {logger << 'logged'}}
+        puts "Log4r:      not supported" if log4r
+      end
+    end
+
+  end  # class Benchmark
+end  # module Logging
+
+
+if __FILE__ == $0
+  bm = ::Logging::Benchmark.new
+  bm.run
+end
+
+# EOF

data/test/layouts/test_basic.rb

@@ -0,0 +1,46 @@
+# $Id: test_basic.rb 15 2007-01-15 19:03:45Z tim_pease $
+
+require 'test/setup.rb'
+
+module TestLogging
+module TestLayouts
+
+  class TestBasic < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      ::Logging.define_levels %w(debug info warn error fatal)
+      @layout = ::Logging::Layouts::Basic.new
+      @levels = ::Logging::LEVELS
+    end
+
+    def test_format
+      event = ::Logging::LogEvent.new( 'ArrayLogger', @levels['info'],
+                                       ['log message'], false)
+      assert_equal " INFO  ArrayLogger : log message\n", @layout.format(event)
+
+      event.data = [[1, 2, 3, 4]]
+      assert_equal " INFO  ArrayLogger : <Array> 1234\n", @layout.format(event)
+
+      event.level = @levels['debug']
+      event.data = [[1, 2, 3, 4], 'and some message']
+      log =  "DEBUG  ArrayLogger : <Array> 1234\n"
+      log << "DEBUG  ArrayLogger : and some message\n"
+      assert_equal log, @layout.format(event)
+
+      event.logger = 'Test'
+      event.level = @levels['fatal']
+      event.data = [[1, 2, 3, 4], 'and some message', Exception.new]
+      log =  "FATAL  Test : <Array> 1234\n"
+      log << "FATAL  Test : and some message\n"
+      log << "FATAL  Test : <Exception> Exception\n"
+      assert_equal log, @layout.format(event)
+    end
+
+  end  # class TestBasic
+
+end  # module TestLayouts
+end  # module TestLogging
+
+# EOF

data/test/layouts/test_pattern.rb

@@ -0,0 +1,175 @@
+# $Id: test_pattern.rb 13 2007-01-15 17:19:37Z tim_pease $
+
+require 'test/setup.rb'
+
+module TestLogging
+module TestLayouts
+
+  class TestPattern < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      ::Logging.define_levels %w(debug info warn error fatal)
+      @layout = ::Logging::Layouts::Pattern.new
+      @levels = ::Logging::LEVELS
+      @date_fmt = '\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}'
+    end
+
+    def test_date_method
+      assert_nil @layout.date_method
+    end
+
+    def test_date_method_eq
+      @layout.date_method = :to_f
+      assert_equal :to_f, @layout.date_method
+      assert_instance_of Float, @layout.format_date
+
+      @layout.date_method = 'usec'
+      assert_equal 'usec', @layout.date_method
+      assert_instance_of Fixnum, @layout.format_date
+
+      @layout.date_method = :to_s
+      assert_equal :to_s, @layout.date_method
+      assert_instance_of String, @layout.format_date
+
+      # now, even if we have defined a date_pattern, the date_method should
+      # supersede the date_pattern
+      @layout.date_pattern = '%Y'
+
+      @layout.date_method = 'usec'
+      assert_equal 'usec', @layout.date_method
+      assert_instance_of Fixnum, @layout.format_date
+    end
+
+    def test_date_pattern
+      assert_equal '%Y-%m-%d %H:%M:%S', @layout.date_pattern
+    end
+
+    def test_date_pattern_eq
+      @layout.date_pattern = '%Y'
+      assert_equal '%Y', @layout.date_pattern
+      assert_match %r/\A\d{4}\z/, @layout.format_date
+
+      @layout.date_pattern = '%H:%M'
+      assert_equal '%H:%M', @layout.date_pattern
+      assert_match %r/\A\d{2}:\d{2}\z/, @layout.format_date
+    end
+
+    def test_format
+      fmt = '\[' + @date_fmt + '\] %s -- %s : %s\n'
+
+      event = ::Logging::LogEvent.new('ArrayLogger', @levels['info'],
+                                      ['log message'], false)
+      rgxp  = Regexp.new(sprintf(fmt, 'INFO ', 'ArrayLogger', 'log message'))
+      assert_match rgxp, @layout.format(event)
+
+      event.data = [[1, 2, 3, 4]]
+      rgxp  = Regexp.new(sprintf(fmt, 'INFO ', 'ArrayLogger', '<Array> 1234'))
+      assert_match rgxp, @layout.format(event)
+
+      event.level = @levels['debug']
+      event.data = [[1, 2, 3, 4], 'and some message']
+      rgxp  = Regexp.new(
+                  sprintf(fmt, 'DEBUG', 'ArrayLogger', '<Array> 1234') +
+                  sprintf(fmt, 'DEBUG', 'ArrayLogger', 'and some message'))
+      assert_match rgxp, @layout.format(event)
+
+      event.logger = 'Test'
+      event.level = @levels['fatal']
+      event.data = [[1, 2, 3, 4], 'and some message', Exception.new]
+      rgxp  = Regexp.new(
+                  sprintf(fmt, 'FATAL', 'Test', '<Array> 1234') +
+                  sprintf(fmt, 'FATAL', 'Test', 'and some message') +
+                  sprintf(fmt, 'FATAL', 'Test', '<Exception> Exception'))
+      assert_match rgxp, @layout.format(event)
+    end
+
+    def test_format_date
+      rgxp = Regexp.new @date_fmt
+      assert_match rgxp, @layout.format_date
+    end
+
+    def test_pattern
+      assert_equal "[%d] %-5l -- %c : %m\n", @layout.pattern
+    end
+
+    def test_pattern_eq
+      event = ::Logging::LogEvent.new('TestLogger', @levels['info'],
+                                      ['log message'], false)
+
+      @layout.pattern = '%d'
+      assert_equal '%d', @layout.pattern
+      assert_match Regexp.new(@date_fmt), @layout.format(event)
+    end
+
+    def test_pattern_all
+      event = ::Logging::LogEvent.new('TestLogger', @levels['info'],
+                                      ['log message'], false)
+      event.instance_variable_set :@file, 'test_file.rb'
+      event.instance_variable_set :@line, '123'
+      event.instance_variable_set :@method, 'method_name'
+
+      @layout.pattern = '%c'
+      assert_equal 'TestLogger', @layout.format(event)
+
+      @layout.pattern = '%d'
+      assert_match Regexp.new(@date_fmt), @layout.format(event)
+
+      @layout.pattern = '%F'
+      assert_equal 'test_file.rb', @layout.format(event)
+
+      @layout.pattern = '%l'
+      assert_equal 'INFO', @layout.format(event)
+
+      @layout.pattern = '%L'
+      assert_equal '123', @layout.format(event)
+
+      @layout.pattern = '%m'
+      assert_equal 'log message', @layout.format(event)
+
+      @layout.pattern = '%M'
+      assert_equal 'method_name', @layout.format(event)
+
+      @layout.pattern = '%p'
+      assert_match %r/\A\d+\z/, @layout.format(event)
+
+      @layout.pattern = '%r'
+      assert_match %r/\A\d+\z/, @layout.format(event)
+
+      @layout.pattern = '%t'
+      assert_match %r/\A\d+\z/, @layout.format(event)
+
+      @layout.pattern = '%%'
+      assert_equal '%', @layout.format(event)
+
+      # 'z' is not a recognized format character
+      assert_raise(ArgumentError) {
+        @layout.pattern = '[%d] %% %c - %l %z blah'
+      }
+      assert_equal '%', @layout.format(event)
+
+      @layout.pattern = '%5l'
+      assert_equal ' INFO', @layout.format(event)
+
+      @layout.pattern = '%-5l'
+      assert_equal 'INFO ', @layout.format(event)
+
+      @layout.pattern = '%.1l, %c'
+      assert_equal 'I, TestLogger', @layout.format(event)
+
+      @layout.pattern = '%7.7m'
+      assert_equal 'log mes', @layout.format(event)
+
+      event.data = ['tim']
+      assert_equal '    tim', @layout.format(event)
+
+      @layout.pattern = '%-7.7m'
+      assert_equal 'tim    ', @layout.format(event)
+    end
+
+  end  # class TestBasic
+end  # module TestLayouts
+end  # module TestLogging
+
+# EOF