sgeorgi-logging 1.4.2

data/test/appenders/test_rolling_file.rb

@@ -0,0 +1,209 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestAppenders
+
+  class TestRollingFile < Test::Unit::TestCase
+    include LoggingTestCase
+
+    NAME = 'roller'
+
+    def setup
+      super
+      Logging.init
+
+      @fn = File.join(TMP, 'test.log')
+      @fn_fmt = File.join(TMP, 'test.%d.log')
+      @glob = File.join(TMP, '*.log')
+    end
+
+    def test_initialize
+      assert_equal [], Dir.glob(@glob)
+
+      # create a new appender
+      ap = Logging.appenders.rolling_file(NAME, :filename => @fn)
+      assert_equal @fn, ap.filename
+      assert File.exist?(@fn)
+      assert_equal 0, File.size(@fn)
+
+      ap << "Just a line of text\n"   # 20 bytes
+      ap.flush
+      assert_equal 20, File.size(@fn)
+      cleanup
+
+      # make sure we append to the current file (not truncate)
+      ap = Logging.appenders.rolling_file(NAME, :filename => @fn)
+      assert_equal @fn, ap.filename
+      assert_equal [@fn], Dir.glob(@glob)
+      assert_equal 20, File.size(@fn)
+
+      ap << "Just another line of text\n"   # 26 bytes
+      ap.flush
+      assert_equal 46, File.size(@fn)
+      cleanup
+
+      # setting the truncate option to true should roll the current log file
+      # and create a new one
+      ap = Logging.appenders.rolling_file(NAME, :filename => @fn, :truncate => true)
+
+      log1 = sprintf(@fn_fmt, 1)
+      assert_equal [log1, @fn], Dir.glob(@glob).sort
+      assert_equal 0, File.size(@fn)
+      assert_equal 46, File.size(log1)
+
+      ap << "Some more text in the new file\n"   # 31 bytes
+      ap.flush
+      assert_equal 31, File.size(@fn)
+      cleanup
+    end
+
+    def test_keep
+      assert_equal [], Dir.glob(@glob)
+
+      (1..12).each do |cnt|
+        name = sprintf(@fn_fmt, cnt)
+        File.open(name,'w') {|fd| fd.write 'X'*cnt}
+      end
+      FileUtils.touch(@fn)
+
+      # keep only five files
+      ap = Logging.appenders.rolling_file(NAME, :filename => @fn, :keep => 5)
+
+      # we still have 13 files because we did not truncate the log file,
+      # and hence, we did not roll all the log files
+      assert_equal 13, Dir.glob(@glob).length
+
+      # force the appender to roll the files
+      ap.send :copy_truncate
+      ap.instance_variable_get(:@roller).roll_files
+      assert_equal 6, Dir.glob(@glob).length
+
+      (1..5).each do |cnt|
+        name = sprintf(@fn_fmt, cnt)
+        assert_equal cnt-1, File.size(name)
+      end
+      cleanup
+    end
+
+    def test_age
+      d_glob = File.join(TMP, 'test.*.log')
+      dt_glob = File.join(TMP, 'test.*-*.log')
+      age_fn = @fn + '.age'
+
+      assert_equal [], Dir.glob(@glob)
+
+      assert_raise(ArgumentError) do
+        Logging.appenders.rolling_file(NAME, :filename => @fn, :age => 'bob')
+      end
+
+      ap = Logging.appenders.rolling_file(NAME, :filename => @fn, :age => 1)
+      ap << "random message\n"
+      assert_equal 1, Dir.glob(@glob).length
+
+      now = ::File.mtime(age_fn)
+      start = now - 42
+      ::File.utime(start, start, age_fn)
+      ap.instance_variable_set(:@age_fn_mtime, nil)
+      ap << "another random message\n"
+      assert_equal 1, Dir.glob(dt_glob).length
+
+      Dir.glob(d_glob).each {|fn| ::File.delete fn}
+      cleanup
+
+      ap = Logging.appenders.rolling_file(NAME, :filename => @fn, 'age' => 'daily')
+      ap << "random message\n"
+      assert_equal 1, Dir.glob(@glob).length
+
+      now = ::File.mtime(age_fn)
+      start = now - 3600 * 24
+      ::File.utime(start, start, age_fn)
+      ap.instance_variable_set(:@age_fn_mtime, nil)
+
+      sleep 0.250
+      ap << "yet another random message\n"
+      assert_equal 0, Dir.glob(dt_glob).length
+      assert_equal 1, Dir.glob(d_glob).length
+
+      Dir.glob(d_glob).each {|fn| ::File.delete fn}
+      cleanup
+
+      ap = Logging.appenders.rolling_file(NAME, :filename => @fn, :age => 'weekly')
+      ap << "random message\n"
+      assert_equal 1, Dir.glob(@glob).length
+
+      start = now - 3600 * 24 * 7
+      ::File.utime(start, start, age_fn)
+      ap.instance_variable_set(:@age_fn_mtime, nil)
+
+      sleep 0.250
+      ap << "yet another random message\n"
+      assert_equal 0, Dir.glob(dt_glob).length
+      assert_equal 1, Dir.glob(d_glob).length
+
+      Dir.glob(d_glob).each {|fn| ::File.delete fn}
+      cleanup
+
+      ap = Logging.appenders.rolling_file(NAME, :filename => @fn, :age => 'monthly')
+      ap << "random message\n"
+      assert_equal 1, Dir.glob(@glob).length
+
+      start = now - 3600 * 24 * 31
+      ::File.utime(start, start, age_fn)
+      ap.instance_variable_set(:@age_fn_mtime, nil)
+
+      sleep 0.250
+      ap << "yet another random message\n"
+      assert_equal 0, Dir.glob(dt_glob).length
+      assert_equal 1, Dir.glob(d_glob).length
+    end
+
+    def test_size
+      assert_equal [], Dir.glob(@glob)
+
+      ap = Logging.appenders.rolling_file(NAME, :filename => @fn, :size => 100)
+
+      ap << 'X' * 100; ap.flush
+      assert_equal 1, Dir.glob(@glob).length
+      assert_equal 100, File.size(@fn)
+
+      # this character is appended to the log file (bringing its size to 101)
+      # and THEN the file is rolled resulting in a new, empty log file
+      ap << 'X'
+      assert_equal 2, Dir.glob(@glob).length
+      assert_equal 0, File.size(@fn)
+
+      ap << 'X' * 100; ap.flush
+      assert_equal 2, Dir.glob(@glob).length
+      assert_equal 100, File.size(@fn)
+
+      ap << 'X'
+      assert_equal 3, Dir.glob(@glob).length
+      assert_equal 0, File.size(@fn)
+
+      cleanup
+    end
+
+    def test_file_removed
+      assert_equal [], Dir.glob(@glob)
+
+      ap = Logging.appenders.rolling_file(NAME, :filename => @fn, :size => 100)
+
+      ap << 'X' * 100; ap.flush
+      assert_equal 1, Dir.glob(@glob).length
+      assert_equal 100, File.size(@fn)
+    end
+
+    private
+    def cleanup
+      unless Logging.appenders[NAME].nil?
+        Logging.appenders[NAME].close false
+        Logging.appenders[NAME] = nil
+      end
+    end
+
+  end  # class TestRollingFile
+end  # module TestAppenders
+end  # module TestLogging
+
+# EOF

data/test/appenders/test_syslog.rb

@@ -0,0 +1,194 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+if HAVE_SYSLOG
+
+module TestLogging
+module TestAppenders
+
+  class TestSyslog < Test::Unit::TestCase
+    include LoggingTestCase
+    include ::Syslog::Constants
+
+    def setup
+      super
+      Logging.init
+      @levels = Logging::LEVELS
+      @logopt = defined?(::Syslog::LOG_NDELAY) ?
+                    (::Syslog::LOG_PERROR | ::Syslog::LOG_NDELAY) :
+                    (::Syslog::LOG_PERROR)
+    end
+
+    def test_append
+      return if RUBY_PLATFORM =~ %r/cygwin/
+
+      stderr = IO::pipe
+
+      pid = fork do
+        stderr[0].close
+        STDERR.reopen(stderr[1])
+        stderr[1].close
+
+        appender = create_syslog
+        event = Logging::LogEvent.new('TestLogger', @levels['info'],
+                                      [1, 2, 3, 4], false)
+        appender.append event
+        event.level = @levels['debug']
+        event.data = 'the big log message'
+        appender.append event
+
+        appender.level = :warn
+        event.level = @levels['info']
+        event.data = 'this message should not get logged'
+        appender.append event
+        event.level = @levels['warn']
+        event.data = 'this is your last warning'
+        appender.append event
+
+        exit!
+      end
+
+      stderr[1].close
+      Process.waitpid(pid)
+
+      assert_equal("syslog_test:  INFO  TestLogger : <Array> #{[1,2,3,4]}\n",
+                   stderr[0].gets)
+      assert_equal("syslog_test: DEBUG  TestLogger : the big log message\n",
+                   stderr[0].gets)
+      assert_equal("syslog_test:  WARN  TestLogger : this is your last warning\n",
+                   stderr[0].gets)
+    end
+
+    def test_append_error
+      appender = create_syslog
+      appender.close false
+
+      event = Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                    [1, 2, 3, 4], false)
+      assert_raise(RuntimeError) {appender.append event}
+      assert_equal true, appender.closed?
+    end
+
+    def test_close
+      appender = create_syslog
+      assert_equal false, appender.closed?
+
+      appender.close false
+      assert_equal true, appender.closed?
+    end
+
+    def test_concat
+      return if RUBY_PLATFORM =~ %r/cygwin/
+
+      stderr = IO::pipe
+
+      pid = fork do
+        stderr[0].close
+        STDERR.reopen(stderr[1])
+        stderr[1].close
+
+        appender = create_syslog
+        appender << 'this is a test message'
+        appender << 'this is another message'
+        appender << 'some other line'
+
+        exit!
+      end
+
+      stderr[1].close
+      Process.waitpid(pid)
+
+      assert_equal("syslog_test: this is a test message\n", stderr[0].gets)
+      assert_equal("syslog_test: this is another message\n", stderr[0].gets)
+      assert_equal("syslog_test: some other line\n", stderr[0].gets)
+    end
+
+    def test_concat_error
+      appender = create_syslog
+      appender.close false
+
+      assert_raise(RuntimeError) {appender << 'oopsy'}
+      assert_equal true, appender.closed?
+    end
+
+    def test_map_eq
+      appender = create_syslog
+
+      assert_equal(
+        [LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERR, LOG_CRIT],
+        get_map_from(appender)
+      )
+
+      appender.map = {
+        :debug => LOG_DEBUG,
+        :info  => 'LOG_NOTICE',
+        :warn  => :LOG_WARNING,
+        :error => 'log_err',
+        :fatal => :log_alert
+      }
+
+      assert_equal(
+        [LOG_DEBUG, LOG_NOTICE, LOG_WARNING, LOG_ERR, LOG_ALERT],
+        get_map_from(appender)
+      )
+    end
+
+    def test_map_eq_error
+      appender = create_syslog
+
+      # Object is not a valid syslog level
+      assert_raise(ArgumentError) do
+        appender.map = {:debug => Object}
+      end
+
+      # there is no syslog level named "info"
+      # it should be "log_info"
+      assert_raise(NameError) do
+        appender.map = {:info => 'lg_info'}
+      end
+    end
+
+    def test_initialize_map
+      appender = Logging.appenders.syslog(
+        'syslog_test',
+        :logopt => @logopt,
+        :map => {
+          :debug  =>  :log_debug,
+          :info   =>  :log_info,
+          :warn   =>  :log_warning,
+          :error  =>  :log_err,
+          :fatal  =>  :log_alert
+        }
+      )
+
+      assert_equal(
+        [LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERR, LOG_ALERT],
+        get_map_from(appender)
+      )
+    end
+
+
+    private
+
+    def create_syslog
+      layout = Logging.layouts.pattern(:pattern => '%5l  %c : %m')
+      Logging.appenders.syslog(
+          'syslog_test',
+          :logopt => @logopt,
+          :facility => ::Syslog::LOG_USER,
+          :layout => layout
+      )
+    end
+
+    def get_map_from( syslog )
+      syslog.instance_variable_get :@map
+    end
+
+  end  # class TestSyslog
+
+end  # module TestAppenders
+end  # module TestLogging
+
+end  # HAVE_SYSLOG
+
+# EOF

data/test/benchmark.rb

@@ -0,0 +1,86 @@
+
+begin
+  require 'logging'
+rescue LoadError
+  path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+  raise if $:.include? path
+  $: << path
+  retry
+end
+
+begin
+  require 'rubygems'
+  gem 'log4r'
+  require 'log4r'
+  $log4r = true
+rescue LoadError
+  $log4r = false
+end
+
+require 'benchmark'
+require 'logger'
+
+module Logging
+  class Benchmark
+
+    def run
+      this_many = 300_000
+
+      sio = StringIO.new
+
+      logging = ::Logging.logger sio
+      logging.level = :warn
+
+      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,
+          :formatter => ::Log4r::PatternFormatter.new(
+            :pattern => "%.1l, [%d #\#{Process.pid}] %5l : %M\n",
+            :date_pattern => "%Y-%m-%dT%H:%M:%S.\#{Time.now.usec}"
+          )
+        )
+        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