logging 2.0.0 → 2.1.0

data/lib/logging/version.rb

@@ -1,5 +1,5 @@
 module Logging
-  VERSION = "2.0.0".freeze
+  VERSION = "2.1.0".freeze
 
   # Returns the version string for the library.
   def self.version

data/logging.gemspec

@@ -9,6 +9,7 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   s.authors = ["Tim Pease"]
   s.date = "2015-03-29"
+  s.license = "MIT"
   s.description = "Logging is a flexible logging library for use in Ruby programs based on the\ndesign of Java's log4j library. It features a hierarchical logging system,\ncustom level names, multiple output destinations per log event, custom\nformatting, and more."
   s.email = "tim.pease@gmail.com"
   s.extra_rdoc_files = ["History.txt"]

data/script/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require "irb"
+require "rubygems"
+
+$LOAD_PATH.unshift "lib"
+require "logging"
+
+IRB.start

data/test/appenders/{test_periodic_flushing.rb → test_async_flushing.rb}

@@ -4,14 +4,15 @@ require File.expand_path('../setup', File.dirname(__FILE__))
 module TestLogging
 module TestAppenders
 
-  class TestPeriodicFlushing < Test::Unit::TestCase
+  class TestAsyncFlushing < Test::Unit::TestCase
     include LoggingTestCase
 
     def setup
       super
-      @appender = Logging.appenders.string_io(
-        'test_appender', :flush_period => 2
-      )
+      @appender = Logging.appenders.string_io \
+        'test_appender',
+        :flush_period => 2
+
       @appender.clear
       @sio = @appender.sio
       @levels = Logging::LEVELS
@@ -42,12 +43,12 @@ module TestAppenders
       assert_equal 200, @appender.auto_flushing
     end
 
-    def test_periodic_flusher_running
-      flusher = @appender.instance_variable_get(:@periodic_flusher)
-      assert_instance_of Logging::Appenders::Buffering::PeriodicFlusher, flusher
+    def test_async_flusher_running
+      flusher = @appender.instance_variable_get(:@async_flusher)
+      assert_instance_of Logging::Appenders::Buffering::AsyncFlusher, flusher
 
       sleep 0.250  # give the flusher thread another moment to start
-      assert flusher.waiting?, 'the periodic flusher should be waiting for a signal'
+      assert flusher.waiting?, 'the async flusher should be waiting for a signal'
     end
 
     def test_append
@@ -129,13 +130,65 @@ module TestAppenders
       assert_nil(readline)
     end
 
-  private
-    def readline
-      @appender.readline
+    def test_setting_flush_period_to_nil
+      flusher = @appender.instance_variable_get(:@async_flusher)
+      assert_instance_of Logging::Appenders::Buffering::AsyncFlusher, flusher
+
+      @appender.flush_period = nil
+
+      assert_nil @appender.instance_variable_get(:@async_flusher)
     end
 
-  end  # class TestPeriodicFlushing
+    def test_setting_negative_flush_period
+      assert_raise(ArgumentError) { @appender.flush_period = -1 }
+    end
+
+    def test_async_writes
+      @appender.auto_flushing = 3
+      @appender.flush_period = nil
+      @appender.async = true
+
+      event = Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                    [1, 2, 3, 4], false)
+
+      flusher = @appender.instance_variable_get(:@async_flusher)
+      assert_instance_of Logging::Appenders::Buffering::AsyncFlusher, flusher
 
-end  # module TestAppenders
-end  # module TestLogging
+      @appender.append event
+      assert_nil(readline)
 
+      event.level = @levels['debug']
+      event.data = 'the big log message'
+      @appender.append event
+      sleep 0.250
+      assert_nil(readline)
+
+      event.level = @levels['info']
+      event.data = 'just FYI'
+      @appender.append event  # might write here, might not
+      sleep 0.250             # so sleep a little to let the write occur
+
+      assert_equal " WARN  TestLogger : <Array> #{[1, 2, 3, 4]}\n", readline
+      assert_equal "DEBUG  TestLogger : the big log message\n", readline
+      assert_equal " INFO  TestLogger : just FYI\n", readline
+
+      event.level = @levels['warn']
+      event.data = 'this is your last warning!'
+      @appender.append event
+      assert_nil(readline)
+
+      @appender.close_method = :close_write
+      @appender.close
+
+      assert_equal " WARN  TestLogger : this is your last warning!\n", readline
+
+      assert_nil @appender.instance_variable_get(:@async_flusher)
+    end
+
+  private
+    def readline
+      @appender.readline
+    end
+  end
+end
+end

data/test/appenders/test_buffered_io.rb

@@ -10,9 +10,12 @@ module TestAppenders
 
     def setup
       super
-      @appender = Logging.appenders.string_io(
-        'test_appender', :auto_flushing => 3, :immediate_at => :error
-      )
+      @appender = Logging.appenders.string_io \
+        'test_appender',
+        :auto_flushing => 3,
+        :immediate_at  => :error,
+        :encoding      => 'UTF-8'
+
       @appender.clear
       @sio = @appender.sio
       @levels = Logging::LEVELS

data/test/appenders/test_console.rb

@@ -4,6 +4,14 @@ require File.expand_path('../setup', File.dirname(__FILE__))
 module TestLogging
 module TestAppenders
 
+  class TestConsole < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def test_initialize
+      assert_raise(RuntimeError) { Logging::Appenders::Console.new("test") }
+    end
+  end
+
   class TestStdout < Test::Unit::TestCase
     include LoggingTestCase
 

data/test/appenders/test_file.rb

@@ -20,24 +20,30 @@ module TestAppenders
       FileUtils.chmod 0444, File.join(TMP, 'uw_file')
     end
 
+    def test_factory_method_validates_input
+      assert_raise(ArgumentError) do
+        Logging.appenders.file
+      end
+    end
+
     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(log).class.assert_valid_logfile(log)
       end
 
       log = File.join(TMP, 'dir')
       assert_raise(ArgumentError) do
-        Logging.appenders.file.assert_valid_logfile(log)
+        Logging.appenders.file(log).class.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(log).class.assert_valid_logfile(log)
       end
 
       log = File.join(TMP, 'file.log')
-      assert Logging.appenders.file.assert_valid_logfile(log)
+      assert Logging.appenders.file(log).class.assert_valid_logfile(log)
     end
 
     def test_initialize
@@ -100,14 +106,13 @@ module TestAppenders
 
       def test_encoding
         log = File.join(TMP, 'file-encoding.log')
-        #appender = Logging.appenders.file(NAME, :filename => log, :encoding => 'ISO-8859-16')
         appender = Logging.appenders.file(NAME, :filename => log, :encoding => 'ASCII')
 
         appender << "A normal line of text\n"
         appender << "ümlaut\n"
         appender.close
 
-        lines = File.readlines(log)
+        lines = File.readlines(log, :encoding => 'UTF-8')
         assert_equal "A normal line of text\n", lines[0]
         assert_equal "ümlaut\n", lines[1]
 

data/test/appenders/test_rolling_file.rb

@@ -18,6 +18,12 @@ module TestAppenders
       @glob = File.expand_path('*.log', TMP)
     end
 
+    def test_factory_method_validates_input
+      assert_raise(ArgumentError) do
+        Logging.appenders.rolling_file
+      end
+    end
+
     def test_initialize
       assert_equal [], Dir.glob(@glob)
 

data/test/appenders/test_syslog.rb

@@ -19,6 +19,12 @@ module TestAppenders
       @logopt |= ::Syslog::LOG_PERROR if defined?(::Syslog::LOG_PERROR)
     end
 
+    def test_factory_method_validates_input
+      assert_raise(ArgumentError) do
+        Logging.appenders.syslog
+      end
+    end
+
     def test_append
       return if RUBY_PLATFORM =~ %r/cygwin|java/i
 

data/test/benchmark.rb

@@ -1,4 +1,3 @@
-
 require 'rubygems'
 
 libpath = File.expand_path('../../lib', __FILE__)
@@ -22,16 +21,14 @@ module Logging
     def run
       this_many = 300_000
 
-      Logging.appenders.string_io(
-        'sio',
-        :layout => Logging.layouts.pattern(
-          :pattern => '%.1l, [%d] %5l -- %c: %m\n',
-          :date_pattern => "%Y-%m-%dT%H:%M:%S.%s"
-        )
-      )
+      pattern = Logging.layouts.pattern \
+        :pattern      => '%.1l, [%d #%p] %5l -- %c: %m\n',
+        :date_pattern => "%Y-%m-%dT%H:%M:%S.%s"
+
+      Logging.appenders.string_io('sio', :layout => pattern)
       sio = Logging.appenders['sio'].sio
 
-      logging = ::Logging.logger('benchmark')
+      logging = ::Logging.logger['benchmark']
       logging.level = :warn
       logging.appenders = 'sio'
 
@@ -39,16 +36,16 @@ module Logging
       logger.level = ::Logger::WARN
 
       log4r = if $log4r
-        x = ::Log4r::Logger.new('benchmark')
-        x.level = ::Log4r::WARN
-        x.add ::Log4r::IOOutputter.new(
+        l4r = ::Log4r::Logger.new('benchmark')
+        l4r.level = ::Log4r::WARN
+        l4r.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}"
+            :date_pattern => "%Y-%m-%dT%H:%M:%S.%6N"
           )
         )
-        x
+        l4r
       end
 
       puts "== Debug (not logged) ==\n"
@@ -76,14 +73,41 @@ module Logging
         bm.report('Logger:') {this_many.times {logger << 'logged'}}
         puts "Log4r:      not supported" if log4r
       end
-    end
 
-  end  # class Benchmark
-end  # module Logging
+      write_size         = 250
+      auto_flushing_size = 500
+
+      logging_async = ::Logging.logger['AsyncFile']
+      logging_async.level = :info
+      logging_async.appenders = Logging.appenders.file \
+          'benchmark_async.log',
+          :layout => pattern,
+          :write_size => write_size,
+          :auto_flushing => auto_flushing_size,
+          :async => true
+
+      logging_sync = ::Logging.logger['SyncFile']
+      logging_sync.level = :info
+      logging_sync.appenders = Logging.appenders.file \
+          'benchmark_sync.log',
+          :layout => pattern,
+          :write_size => write_size,
+          :auto_flushing => auto_flushing_size,
+          :async => false
+
+      puts "\n== File ==\n"
+      ::Benchmark.bm(20) do |bm|
+        bm.report('Logging (Async):') {this_many.times { |n| logging_async.info "Iteration #{n}"}}
+        bm.report('Logging (Sync):')  {this_many.times { |n| logging_sync.info  "Iteration #{n}"}}
+      end
 
+      File.delete('benchmark_async.log')
+      File.delete('benchmark_sync.log')
+    end
+  end
+end
 
 if __FILE__ == $0
   bm = ::Logging::Benchmark.new
   bm.run
 end
-

data/test/performance.rb

@@ -0,0 +1,66 @@
+#
+# The peformance script is used to output a performance analysis page for the
+# Logging framework. You can run this script simply:
+#
+#   ruby test/performance.rb
+#
+# This will write a file called "performance.html" that you can open in your web
+# browser. You will need the `ruby-prof` gem installed in order to run this
+# script.
+# ------------------------------------------------------------------------------
+require 'rubygems'
+
+libpath = File.expand_path('../../lib', __FILE__)
+$:.unshift libpath
+require 'logging'
+
+begin
+  gem 'log4r'
+  require 'log4r'
+  $log4r = true
+rescue LoadError
+  $log4r = false
+end
+
+require 'logger'
+require 'ruby-prof'
+
+module Logging
+  class Performance
+
+    # number of iterations
+    attr_reader :this_many
+
+    # performance output file name
+    attr_reader :output_file
+
+    def initialize
+      @this_many   = 300_000
+      @output_file = "performance.html"
+    end
+
+    def run
+      pattern = Logging.layouts.pattern \
+        :pattern      => '%.1l, [%d#%p] %5l -- %c: %m\n',
+        :date_pattern => "%Y-%m-%dT%H:%M:%S.%s"
+
+      Logging.appenders.string_io("sio", :layout => pattern)
+
+      logger = ::Logging.logger["Performance"]
+      logger.level = :warn
+      logger.appenders = "sio"
+
+      result = RubyProf.profile do
+        this_many.times {logger.warn 'logged'}
+      end
+
+      printer = RubyProf::GraphHtmlPrinter.new(result)
+      File.open(output_file, "w") { |fd| printer.print(fd) }
+    end
+  end
+end
+
+if __FILE__ == $0
+  perf = Logging::Performance.new
+  perf.run
+end

data/test/setup.rb

@@ -1,42 +1,34 @@
-
 # Equivalent to a header guard in C/C++
 # Used to prevent the class/module from being loaded more than once
 unless defined? LOGGING_TEST_SETUP
 LOGGING_TEST_SETUP = true
 
-require 'rubygems'
-require 'test/unit'
-begin
-  require 'turn'
-rescue LoadError; end
-
-# This line is needed for Ruby 1.9 -- hashes throw a "KeyError" in 1.9
-# whereas they throw an "IndexError" in 1.8
-#
-KeyError = IndexError if not defined? KeyError
+require "rubygems"
+require "test/unit"
 
-require File.join(File.dirname(__FILE__), %w[.. lib logging])
+if Test::Unit::TestCase.respond_to? :test_order=
+  Test::Unit::TestCase.test_order = :random
+end
 
+require File.expand_path("../../lib/logging", __FILE__)
 
 module TestLogging
-module LoggingTestCase
+  module LoggingTestCase
 
-  TMP = 'tmp'
+    TMP = 'tmp'
 
-  def setup
-    super
-    Logging.reset
-    FileUtils.rm_rf TMP
-    FileUtils.mkdir TMP
-  end
+    def setup
+      super
+      Logging.reset
+      FileUtils.rm_rf TMP
+      FileUtils.mkdir TMP
+    end
 
-  def teardown
-    super
-    FileUtils.rm_rf TMP
+    def teardown
+      super
+      FileUtils.rm_rf TMP
+    end
   end
+end
 
-end  # LoggingTestCase
-end  # TestLogging
-
-end  # defined?
-
+end