logging 0.9.8 → 1.0.0

data/test/appenders/test_console.rb

@@ -8,9 +8,9 @@ module TestAppenders
     include LoggingTestCase
 
     def test_initialize
-      ::Logging::Repository.instance
+      Logging::Repository.instance
 
-      appender = ::Logging::Appenders::Stdout.new
+      appender = Logging.appenders.stdout
       assert_equal 'stdout', appender.name
       assert_same STDOUT, appender.instance_variable_get(:@io)
 
@@ -18,14 +18,14 @@ module TestAppenders
       assert_equal true, appender.closed?
       assert_equal false, STDOUT.closed?
 
-      appender = ::Logging::Appenders::Stdout.new('foo')
+      appender = Logging.appenders.stdout('foo')
       assert_equal 'foo', appender.name
 
-      appender = ::Logging::Appenders::Stdout.new(:level => :warn)
+      appender = Logging.appenders.stdout(:level => :warn)
       assert_equal 'stdout', appender.name
       assert_equal 2, appender.level
 
-      appender = ::Logging::Appenders::Stdout.new('bar', :level => :error)
+      appender = Logging.appenders.stdout('bar', :level => :error)
       assert_equal 'bar', appender.name
       assert_equal 3, appender.level
     end
@@ -36,9 +36,9 @@ module TestAppenders
     include LoggingTestCase
 
     def test_initialize
-      ::Logging::Repository.instance
+      Logging::Repository.instance
 
-      appender = ::Logging::Appenders::Stderr.new
+      appender = Logging.appenders.stderr
       assert_equal 'stderr', appender.name
       assert_same STDERR, appender.instance_variable_get(:@io)
 
@@ -46,14 +46,14 @@ module TestAppenders
       assert_equal true, appender.closed?
       assert_equal false, STDERR.closed?
 
-      appender = ::Logging::Appenders::Stderr.new('foo')
+      appender = Logging.appenders.stderr('foo')
       assert_equal 'foo', appender.name
 
-      appender = ::Logging::Appenders::Stderr.new(:level => :warn)
+      appender = Logging.appenders.stderr(:level => :warn)
       assert_equal 'stderr', appender.name
       assert_equal 2, appender.level
 
-      appender = ::Logging::Appenders::Stderr.new('bar', :level => :error)
+      appender = Logging.appenders.stderr('bar', :level => :error)
       assert_equal 'bar', appender.name
       assert_equal 3, appender.level
     end

data/test/appenders/test_email.rb

@@ -11,8 +11,6 @@ module TestAppenders
 
     def setup
       super
-      ::Logging.init
-      @levels = ::Logging::LEVELS
 
       flexmock(Net::SMTP).new_instances do |m|
         m.should_receive(:start).at_least.once.with(
@@ -20,25 +18,26 @@ module TestAppenders
         m.should_receive(:sendmail).at_least.once.with(String, 'me', ['you'])
       end
 
-      @appender = ::Logging::Appenders::Email.new('email',
+      @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.new('email')
+        Logging.appenders.email('email')
       }
       assert_raise(ArgumentError, 'Must specify to address') {
-        ::Logging::Appenders::Email.new('email', :from => 'me')
+        Logging.appenders.email('email', :from => 'me')
       }
       assert_nothing_raised {
-        ::Logging::Appenders::Email.new('email', :from => 'me', :to => 'you')
+        Logging.appenders.email('email', :from => 'me', :to => 'you')
       }
 
-      appender = ::Logging::Appenders::Email.new('email',
+      appender = Logging.appenders.email('email',
           'from' => 'me', 'to' => 'you'
       )
 
@@ -53,7 +52,7 @@ module TestAppenders
       assert_equal(:cram_md5, appender.authtype)
       assert_equal("Message of #{$0}", appender.subject)
 
-      appender = ::Logging::Appenders::Email.new('email',
+      appender = Logging.appenders.email('email',
           'from' => 'lbrinn@gmail.com', 'to' => 'everyone',
           :buffsize => '1000', :immediate_at => 'error, fatal',
           :server => 'smtp.google.com', :port => '443',
@@ -75,7 +74,7 @@ module TestAppenders
       assert_equal(:tls, appender.authtype)
       assert_equal("I'm rich and you're not", appender.subject)
 
-      appender = ::Logging::Appenders::Email.new('email',
+      appender = Logging.appenders.email('email',
           'from' => 'me', 'to' => 'you', :auto_flushing => 42
       )
       assert_equal(42, appender.auto_flushing)
@@ -85,8 +84,8 @@ module TestAppenders
       # 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)
+      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)
@@ -102,10 +101,10 @@ module TestAppenders
       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)
+      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
@@ -140,8 +139,8 @@ module TestAppenders
     end
 
     def test_flush
-      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
       @appender << 'test message'
       assert_equal(2, @appender.buffer.length)
@@ -152,8 +151,8 @@ module TestAppenders
     end
 
     def test_close
-      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
       @appender << 'test message'
       assert_equal(2, @appender.buffer.length)

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