TwP-logging 0.9.8 → 0.9.8.1

data/test/appenders/test_file.rb

@@ -11,7 +11,7 @@ module TestAppenders
 
     def setup
       super
-      ::Logging.init
+      Logging.init
 
       FileUtils.mkdir [File.join(TMP, 'dir'), File.join(TMP, 'uw_dir')]
       FileUtils.chmod 0555, File.join(TMP, 'uw_dir')
@@ -22,26 +22,26 @@ module TestAppenders
     def test_class_assert_valid_logfile
       log = File.join(TMP, 'uw_dir', 'file.log')
       assert_raise(ArgumentError) do
-        ::Logging::Appenders::File.assert_valid_logfile(log)
+        Logging.appenders.file.assert_valid_logfile(log)
       end
 
       log = File.join(TMP, 'dir')
       assert_raise(ArgumentError) do
-        ::Logging::Appenders::File.assert_valid_logfile(log)
+        Logging.appenders.file.assert_valid_logfile(log)
       end
 
       log = File.join(TMP, 'uw_file')
       assert_raise(ArgumentError) do
-        ::Logging::Appenders::File.assert_valid_logfile(log)
+        Logging.appenders.file.assert_valid_logfile(log)
       end
 
       log = File.join(TMP, 'file.log')
-      assert ::Logging::Appenders::File.assert_valid_logfile(log)
+      assert Logging.appenders.file.assert_valid_logfile(log)
     end
 
     def test_initialize
       log = File.join(TMP, 'file.log')
-      appender = ::Logging::Appenders::File.new(NAME, 'filename' => log)
+      appender = Logging.appenders.file(NAME, 'filename' => log)
       assert_equal 'logfile', appender.name
       appender << "This will be the first line\n"
       appender << "This will be the second line\n"
@@ -53,7 +53,7 @@ module TestAppenders
       end
       cleanup
 
-      appender = ::Logging::Appenders::File.new NAME, :filename => log
+      appender = Logging.appenders.file(NAME, :filename => log)
       assert_equal 'logfile', appender.name
       appender << "This will be the third line\n"
       appender.flush
@@ -65,8 +65,8 @@ module TestAppenders
       end
       cleanup
 
-      appender = ::Logging::Appenders::File.new NAME, :filename => log,
-                                                      :truncate => true
+      appender = Logging.appenders.file(NAME, :filename => log,
+                                              :truncate => true)
       assert_equal 'logfile', appender.name
       appender << "The file was truncated\n"
       appender.flush
@@ -79,9 +79,9 @@ module TestAppenders
 
     private
     def cleanup
-      unless ::Logging::Appender[NAME].nil?
-        ::Logging::Appender[NAME].close false
-        ::Logging::Appender[NAME] = nil
+      unless Logging.appenders[NAME].nil?
+        Logging.appenders[NAME].close false
+        Logging.appenders[NAME] = nil
       end
     end
 

data/test/appenders/test_growl.rb

@@ -11,15 +11,14 @@ module TestAppenders
 
     def setup
       super
-      ::Logging.init
-      @levels = ::Logging::LEVELS
 
-      @appender = ::Logging::Appenders::Growl.new('growl',
+      @appender = Logging.appenders.growl('growl',
           :coalesce => true, :separator => "\000",
-          :layout => Logging::Layouts::Pattern.new(:pattern => "%5l - Test\000%m")
+          :layout => Logging.layouts.pattern(:pattern => "%5l - Test\000%m")
       )
       @appender.level = :all
       @growl = @appender.instance_variable_get(:@growl).dup
+      @levels = Logging::LEVELS
     end
 
     def test_initialize
@@ -29,10 +28,10 @@ module TestAppenders
     end
 
     def test_append
-      info = ::Logging::LogEvent.new('TestLogger', @levels['info'],
-                                     'info message', false)
-      warn = ::Logging::LogEvent.new('TestLogger', @levels['warn'],
-                                     'warning message', false)
+      info = Logging::LogEvent.new('TestLogger', @levels['info'],
+                                   'info message', false)
+      warn = Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                   'warning message', false)
 
       flexmock(@appender).should_receive(:system => true).once.with(
           @growl % ['WARN - Test', "warning message\nwarning message\nwarning message", 0])
@@ -54,8 +53,8 @@ module TestAppenders
 
     def test_append_without_coalescing
       @appender.instance_variable_set(:@coalesce, false)
-      event = ::Logging::LogEvent.new('TestLogger', @levels['warn'],
-                                      'warning message', false)
+      event = Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                    'warning message', false)
 
       flexmock(@appender).should_receive(:system => true).twice.with(
           @growl % ['WARN - Test', 'warning message', 0])
@@ -108,8 +107,8 @@ module TestAppenders
 
     def test_disabling
       @appender.instance_variable_set(:@coalesce, false)
-      event = ::Logging::LogEvent.new('TestLogger', @levels['warn'],
-                                      'warning message', false)
+      event = Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                    'warning message', false)
 
       flexmock(@appender).should_receive(:system => false).once.with(
           @growl % ['WARN - Test', 'warning message', 0])

data/test/appenders/test_io.rb

@@ -9,16 +9,15 @@ module TestAppenders
 
     def setup
       super
-      ::Logging.init
-      @levels = ::Logging::LEVELS
 
-      @appender = ::Logging::Appenders::StringIo.new 'test_appender'
+      @appender = Logging.appenders.string_io('test_appender')
       @sio = @appender.sio
+      @levels = Logging::LEVELS
     end
 
     def test_append
-      event = ::Logging::LogEvent.new('TestLogger', @levels['warn'],
-                                      [1, 2, 3, 4], false)
+      event = Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                    [1, 2, 3, 4], false)
       @appender.append event
       assert_equal " WARN  TestLogger : <Array> #{[1, 2, 3, 4]}\n", readline
       assert_nil(readline)
@@ -36,14 +35,14 @@ module TestAppenders
     def test_append_error
       # setup an internal logger to capture error messages from the IO
       # appender
-      log = Logging::Appenders::StringIo.new('__internal_io')
-      Logging::Logger[Logging].add_appenders(log)
-      Logging::Logger[Logging].level = 'all'
+      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)
+      event = Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                    [1, 2, 3, 4], false)
       @appender.append event
 
       assert_equal "INFO  Logging : appender \"test_appender\" has been disabled", log.readline.strip
@@ -62,7 +61,7 @@ module TestAppenders
       assert_equal true, @appender.closed?
 
       [STDIN, STDERR, STDOUT].each do |io|
-        @appender = ::Logging::Appenders::IO.new 'test', io
+        @appender = Logging.appenders.io('test', io)
         @appender.close
         assert_equal false, io.closed?
         assert_equal true, @appender.closed?
@@ -87,9 +86,9 @@ module TestAppenders
     def test_concat_error
       # setup an internal logger to capture error messages from the IO
       # appender
-      log = Logging::Appenders::StringIo.new('__internal_io')
-      Logging::Logger[Logging].add_appenders(log)
-      Logging::Logger[Logging].level = 'all'
+      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
@@ -114,7 +113,7 @@ module TestAppenders
 
     def test_initialize
       assert_raise(EOFError) {@sio.readline}
-      assert_raise(TypeError) {::Logging::Appenders::IO.new 'test', []}
+      assert_raise(TypeError) {Logging.appenders.io('test', [])}
     end
 
     private

data/test/appenders/test_rolling_file.rb

@@ -11,7 +11,7 @@ module TestAppenders
 
     def setup
       super
-      ::Logging.init
+      Logging.init
 
       @fn = File.join(TMP, 'test.log')
       @fn_fmt = File.join(TMP, 'test.%d.log')
@@ -22,7 +22,7 @@ module TestAppenders
       assert_equal [], Dir.glob(@glob)
 
       # create a new appender
-      ap = ::Logging::Appenders::RollingFile.new(NAME, :filename => @fn)
+      ap = Logging.appenders.rolling_file(NAME, :filename => @fn)
       assert File.exist?(@fn)
       assert_equal 0, File.size(@fn)
 
@@ -32,7 +32,7 @@ module TestAppenders
       cleanup
 
       # make sure we append to the current file (not truncate)
-      ap = ::Logging::Appenders::RollingFile.new(NAME, :filename => @fn)
+      ap = Logging.appenders.rolling_file(NAME, :filename => @fn)
       assert_equal [@fn], Dir.glob(@glob)
       assert_equal 20, File.size(@fn)
 
@@ -43,8 +43,7 @@ module TestAppenders
 
       # setting the truncate option to true should roll the current log file
       # and create a new one
-      ap = ::Logging::Appenders::RollingFile.new(NAME,
-               :filename => @fn, :truncate => true)
+      ap = Logging.appenders.rolling_file(NAME, :filename => @fn, :truncate => true)
 
       log1 = sprintf(@fn_fmt, 1)
       assert_equal [log1, @fn], Dir.glob(@glob).sort
@@ -67,8 +66,7 @@ module TestAppenders
       FileUtils.touch(@fn)
 
       # keep only five files
-      ap = ::Logging::Appenders::RollingFile.new(NAME,
-               :filename => @fn, :keep => 5)
+      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
@@ -89,12 +87,10 @@ module TestAppenders
       assert_equal [], Dir.glob(@glob)
 
       assert_raise(ArgumentError) do
-        ::Logging::Appenders::RollingFile.new(
-            NAME, :filename => @fn, :age => 'bob')
+        Logging.appenders.rolling_file(NAME, :filename => @fn, :age => 'bob')
       end
 
-      ap = ::Logging::Appenders::RollingFile.new(NAME,
-               :filename => @fn, :age => 1)
+      ap = Logging.appenders.rolling_file(NAME, :filename => @fn, :age => 1)
       ap << "random message\n"
       assert_equal 1, Dir.glob(@glob).length
 
@@ -103,8 +99,7 @@ module TestAppenders
       assert_equal 2, Dir.glob(@glob).length
 
       cleanup
-      ap = ::Logging::Appenders::RollingFile.new(NAME,
-               :filename => @fn, 'age' => 'daily')
+      ap = Logging.appenders.rolling_file(NAME, :filename => @fn, 'age' => 'daily')
       ap << "random message\n"
       assert_equal 2, Dir.glob(@glob).length
 
@@ -118,8 +113,7 @@ module TestAppenders
       assert_equal 3, Dir.glob(@glob).length
 
       cleanup
-      ap = ::Logging::Appenders::RollingFile.new(NAME,
-               :filename => @fn, :age => 'weekly')
+      ap = Logging.appenders.rolling_file(NAME, :filename => @fn, :age => 'weekly')
       ap << "random message\n"
       assert_equal 3, Dir.glob(@glob).length
 
@@ -131,8 +125,7 @@ module TestAppenders
       assert_equal 4, Dir.glob(@glob).length
 
       cleanup
-      ap = ::Logging::Appenders::RollingFile.new(NAME,
-               :filename => @fn, :age => 'monthly')
+      ap = Logging.appenders.rolling_file(NAME, :filename => @fn, :age => 'monthly')
       ap << "random message\n"
       assert_equal 4, Dir.glob(@glob).length
 
@@ -147,8 +140,7 @@ module TestAppenders
     def test_size
       assert_equal [], Dir.glob(@glob)
 
-      ap = ::Logging::Appenders::RollingFile.new(NAME,
-               :filename => @fn, :size => 100)
+      ap = Logging.appenders.rolling_file(NAME, :filename => @fn, :size => 100)
 
       ap << 'X' * 100; ap.flush
       assert_equal 1, Dir.glob(@glob).length
@@ -174,8 +166,7 @@ module TestAppenders
     def test_file_removed
       assert_equal [], Dir.glob(@glob)
 
-      ap = ::Logging::Appenders::RollingFile.new(NAME,
-               :filename => @fn, :size => 100)
+      ap = Logging.appenders.rolling_file(NAME, :filename => @fn, :size => 100)
 
       ap << 'X' * 100; ap.flush
       assert_equal 1, Dir.glob(@glob).length
@@ -194,9 +185,9 @@ module TestAppenders
 
     private
     def cleanup
-      unless ::Logging::Appender[NAME].nil?
-        ::Logging::Appender[NAME].close false
-        ::Logging::Appender[NAME] = nil
+      unless Logging.appenders[NAME].nil?
+        Logging.appenders[NAME].close false
+        Logging.appenders[NAME] = nil
       end
     end
 

data/test/appenders/test_syslog.rb

@@ -12,8 +12,8 @@ module TestAppenders
 
     def setup
       super
-      ::Logging.init
-      @levels = ::Logging::LEVELS
+      Logging.init
+      @levels = Logging::LEVELS
       @logopt = defined?(::Syslog::LOG_NDELAY) ?
                     (::Syslog::LOG_PERROR | ::Syslog::LOG_NDELAY) :
                     (::Syslog::LOG_PERROR)
@@ -30,8 +30,8 @@ module TestAppenders
         stderr[1].close
 
         appender = create_syslog
-        event = ::Logging::LogEvent.new('TestLogger', @levels['info'],
-                                        [1, 2, 3, 4], false)
+        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'
@@ -63,8 +63,8 @@ module TestAppenders
       appender = create_syslog
       appender.close false
 
-      event = ::Logging::LogEvent.new('TestLogger', @levels['warn'],
-                                      [1, 2, 3, 4], 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
@@ -149,7 +149,7 @@ module TestAppenders
     end
 
     def test_initialize_map
-      appender = ::Logging::Appenders::Syslog.new(
+      appender = Logging.appenders.syslog(
         'syslog_test',
         :logopt => @logopt,
         :map => {
@@ -171,8 +171,8 @@ module TestAppenders
     private
 
     def create_syslog
-      layout = ::Logging::Layouts::Pattern.new(:pattern => '%5l  %c : %m')
-      ::Logging::Appenders::Syslog.new(
+      layout = Logging.layouts.pattern(:pattern => '%5l  %c : %m')
+      Logging.appenders.syslog(
           'syslog_test',
           :logopt => @logopt,
           :facility => ::Syslog::LOG_USER,
@@ -184,7 +184,7 @@ module TestAppenders
       syslog.instance_variable_get :@map
     end
 
-  end  # class TestIO
+  end  # class TestSyslog
 
 end  # module TestAppenders
 end  # module TestLogging

data/test/layouts/test_basic.rb

@@ -9,14 +9,13 @@ module TestLayouts
 
     def setup
       super
-      ::Logging.init
-      @layout = ::Logging::Layouts::Basic.new
-      @levels = ::Logging::LEVELS
+      @layout = Logging.layouts.basic({})
+      @levels = Logging::LEVELS
     end
 
     def test_format
-      event = ::Logging::LogEvent.new( 'ArrayLogger', @levels['info'],
-                                       'log message', false)
+      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]

data/test/layouts/test_json.rb

@@ -0,0 +1,112 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestLayouts
+
+  class TestJson < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      @layout = Logging.layouts.json({})
+      @levels = Logging::LEVELS
+      @date_fmt = '\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}'
+      Thread.current[:name] = nil
+    end
+
+    def test_initializer
+      assert_raise(ArgumentError) {
+        Logging.layouts.parseable.new :style => :foo
+      }
+    end
+
+    def test_format
+      fmt = %Q[\\{"timestamp":"#@date_fmt","level":"%s","logger":"%s","message":"%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',
+                                 Regexp.escape("<Array> #{[1,2,3,4]}")))
+      assert_match rgxp, @layout.format(event)
+
+      event.level = @levels['debug']
+      event.data = 'and another message'
+      rgxp  = Regexp.new(sprintf(fmt, 'DEBUG', 'ArrayLogger',
+                         'and another message'))
+      assert_match rgxp, @layout.format(event)
+
+      event.logger = 'Test'
+      event.level = @levels['fatal']
+      event.data = Exception.new
+      rgxp  = Regexp.new(sprintf(fmt, 'FATAL', 'Test', '<Exception> Exception'))
+      assert_match rgxp, @layout.format(event)
+    end
+
+    def test_items
+      assert_equal %w[timestamp level logger message], @layout.items
+    end
+
+    def test_items_eq
+      event = Logging::LogEvent.new('TestLogger', @levels['info'],
+                                    ['log message'], false)
+
+      @layout.items = %w[timestamp]
+      assert_equal %w[timestamp], @layout.items
+      assert_match %r/\{"timestamp":"#@date_fmt"\}\n/, @layout.format(event)
+
+      # 'foo' is not a recognized item
+      assert_raise(ArgumentError) {
+        @layout.items = %w[timestamp logger foo]
+      }
+    end
+
+    def test_items_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.items = %w[logger]
+      assert_equal %Q[{"logger":"TestLogger"}\n], @layout.format(event)
+
+      @layout.items = %w[file]
+      assert_equal %Q[{"file":"test_file.rb"}\n], @layout.format(event)
+
+      @layout.items = %w[level]
+      assert_equal %Q[{"level":"INFO"}\n], @layout.format(event)
+
+      @layout.items = %w[line]
+      assert_equal %Q[{"line":123}\n], @layout.format(event)
+
+      @layout.items = %w[message]
+      assert_equal %Q[{"message":"log message"}\n], @layout.format(event)
+
+      @layout.items = %w[method]
+      assert_equal %Q[{"method":"method_name"}\n], @layout.format(event)
+
+      @layout.items = %w[pid]
+      assert_match %r/\A\{"pid":\d+\}\n\z/, @layout.format(event)
+
+      @layout.items = %w[millis]
+      assert_match %r/\A\{"millis":\d+\}\n\z/, @layout.format(event)
+
+      @layout.items = %w[thread_id]
+      assert_match %r/\A\{"thread_id":-?\d+\}\n\z/, @layout.format(event)
+
+      @layout.items = %w[thread]
+      assert_equal %Q[{"thread":null}\n], @layout.format(event)
+      Thread.current[:name] = "Main"
+      assert_equal %Q[{"thread":"Main"}\n], @layout.format(event)
+    end
+
+  end  # class TestJson
+end  # module TestLayouts
+end  # module TestLogging
+
+# EOF