logging 2.0.0 → 2.3.0

data/test/appenders/test_rolling_file.rb

@@ -13,9 +13,15 @@ module TestAppenders
       super
       Logging.init
 
-      @fn = File.expand_path('test.log', TMP)
-      @fn_fmt = File.expand_path('test.%d.log', TMP)
-      @glob = File.expand_path('*.log', TMP)
+      @fn = File.expand_path('test.log', @tmpdir)
+      @fn_fmt = File.expand_path('test.%d.log', @tmpdir)
+      @glob = File.expand_path('*.log', @tmpdir)
+    end
+
+    def test_factory_method_validates_input
+      assert_raise(ArgumentError) do
+        Logging.appenders.rolling_file
+      end
     end
 
     def test_initialize
@@ -87,8 +93,8 @@ module TestAppenders
     end
 
     def test_age
-      d_glob = File.join(TMP, 'test.*.log')
-      dt_glob = File.join(TMP, 'test.*-*.log')
+      d_glob = File.join(@tmpdir, 'test.*.log')
+      dt_glob = File.join(@tmpdir, 'test.*-*.log')
       age_fn = @fn + '.age'
 
       assert_equal [], Dir.glob(@glob)
@@ -199,7 +205,7 @@ module TestAppenders
 
       begin
         pwd = Dir.pwd
-        Dir.chdir TMP
+        Dir.chdir @tmpdir
 
         ap << 'X' * 100; ap.flush
         assert_equal 1, Dir.glob(@glob).length
@@ -243,9 +249,9 @@ module TestAppenders
     end
 
     def test_custom_numberd_filename
-      fn = File.expand_path('test.log{{.%d}}', TMP)
-      filename = File.expand_path('test.log', TMP)
-      glob = File.expand_path('test.log.*', TMP)
+      fn = File.expand_path('test.log{{.%d}}', @tmpdir)
+      filename = File.expand_path('test.log', @tmpdir)
+      glob = File.expand_path('test.log.*', @tmpdir)
 
       assert_equal [], Dir.glob(glob)
       ap = Logging.appenders.rolling_file(NAME, :filename => fn, :size => 100, :keep => 2)
@@ -279,10 +285,10 @@ module TestAppenders
     end
 
     def test_custom_timestamp_filename
-      fn = File.expand_path('test{{.%S:%M}}.log', TMP)
-      filename = File.expand_path('test.log', TMP)
+      fn = File.expand_path('test{{.%S:%M}}.log', @tmpdir)
+      filename = File.expand_path('test.log', @tmpdir)
       age_file = filename + '.age'
-      glob = File.expand_path('test.*.log', TMP)
+      glob = File.expand_path('test.*.log', @tmpdir)
 
       assert_equal [], Dir.glob(glob)
       ap = Logging.appenders.rolling_file(NAME, :filename => fn, :age => 1, :keep => 2)

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/layouts/test_json.rb

@@ -78,7 +78,7 @@ module TestLayouts
                                     'log message', false)
       event.file = 'test_file.rb'
       event.line = 123
-      event.method = 'method_name'
+      event.method_name = 'method_name'
 
       @layout.items = %w[logger]
       assert_equal %Q[{"logger":"TestLogger"}\n], @layout.format(event)
@@ -166,6 +166,19 @@ module TestLayouts
       assert_match %r/"ndc":\[\]/, format
     end
 
+    def test_utc_offset
+      layout = Logging.layouts.json(:items => %w[timestamp])
+      event = Logging::LogEvent.new('TimestampLogger', @levels['info'], 'log message', false)
+      event.time = Time.utc(2016, 12, 1, 12, 0, 0).freeze
+
+      assert_equal %Q/{"timestamp":"2016-12-01T12:00:00.000000Z"}\n/, layout.format(event)
+
+      layout.utc_offset = "-06:00"
+      assert_equal %Q/{"timestamp":"2016-12-01T06:00:00.000000-06:00"}\n/, layout.format(event)
+
+      layout.utc_offset = "+01:00"
+      assert_equal %Q/{"timestamp":"2016-12-01T13:00:00.000000+01:00"}\n/, layout.format(event)
+    end
   end  # class TestJson
 end  # module TestLayouts
 end  # module TestLogging

data/test/layouts/test_nested_exceptions.rb

@@ -0,0 +1,124 @@
+
+require_relative '../setup'
+
+module TestLogging
+  module TestLayouts
+    class TestNestedExceptions < Test::Unit::TestCase
+      include LoggingTestCase
+
+      def test_basic_format_obj
+        err = nil
+        begin
+          begin
+            raise ArgumentError, 'nested exception'
+          rescue
+            raise StandardError, 'root exception'
+          end
+        rescue => e
+          err = e
+        end
+
+        layout = Logging.layouts.basic({})
+        log = layout.format_obj(err)
+        assert_not_nil log.index('<StandardError> root exception')
+
+        if err.respond_to?(:cause)
+          assert_not_nil log.index('<ArgumentError> nested exception')
+          assert(log.index('<StandardError> root exception') < log.index('<ArgumentError> nested exception'))
+        end
+      end
+
+      def test_cause_depth_limiting
+        err = nil
+        begin
+          begin
+            begin
+              raise TypeError, 'nested exception 2'
+            rescue
+              raise ArgumentError, 'nested exception 1'
+            end
+          rescue
+            raise StandardError, 'root exception'
+          end
+        rescue => e
+          err = e
+        end
+
+        layout = Logging.layouts.basic(cause_depth: 1)
+        log = layout.format_obj(err)
+        assert_not_nil log.index('<StandardError> root exception')
+
+        if err.respond_to?(:cause)
+          assert_not_nil log.index('<ArgumentError> nested exception 1')
+          assert_nil log.index('<TypeError> nested exception 2')
+          assert_equal '--- Further #cause backtraces were omitted ---', log.split("\n\t").last
+        end
+      end
+
+      def test_parseable_format_obj
+        err = nil
+        begin
+          begin
+            raise ArgumentError, 'nested exception'
+          rescue
+            raise StandardError, 'root exception'
+          end
+        rescue => e
+          err = e
+        end
+
+        layout = Logging.layouts.parseable.new
+        log = layout.format_obj(err)
+        assert_equal 'StandardError', log[:class]
+        assert_equal 'root exception', log[:message]
+        assert log[:backtrace].size > 0
+
+        if err.respond_to?(:cause)
+          assert_not_nil log[:cause]
+
+          log = log[:cause]
+          assert_equal 'ArgumentError', log[:class]
+          assert_equal 'nested exception', log[:message]
+          assert_nil log[:cause]
+          assert log[:backtrace].size > 0
+        end
+      end
+
+      def test_parseable_cause_depth_limiting
+        err = nil
+        begin
+          begin
+            begin
+              raise TypeError, 'nested exception 2'
+            rescue
+              raise ArgumentError, 'nested exception 1'
+            end
+          rescue
+            raise StandardError, 'root exception'
+          end
+        rescue => e
+          err = e
+        end
+
+        layout = Logging.layouts.parseable.new(cause_depth: 1)
+        log = layout.format_obj(err)
+
+        assert_equal 'StandardError', log[:class]
+        assert_equal 'root exception', log[:message]
+        assert log[:backtrace].size > 0
+
+        if err.respond_to?(:cause)
+          assert_not_nil log[:cause]
+
+          log = log[:cause]
+          assert_equal 'ArgumentError', log[:class]
+          assert_equal 'nested exception 1', log[:message]
+          assert_equal({message: "Further #cause backtraces were omitted"}, log[:cause])
+          assert log[:backtrace].size > 0
+        end
+      end
+    end
+  end
+end
+
+require 'pp'

data/test/layouts/test_pattern.rb

@@ -26,7 +26,7 @@ module TestLayouts
 
       @layout.date_method = 'usec'
       assert_equal 'usec', @layout.date_method
-      assert_instance_of Fixnum, @layout.format_date(Time.now)
+      assert_kind_of Integer, @layout.format_date(Time.now)
 
       @layout.date_method = :to_s
       assert_equal :to_s, @layout.date_method
@@ -38,7 +38,7 @@ module TestLayouts
 
       @layout.date_method = 'usec'
       assert_equal 'usec', @layout.date_method
-      assert_instance_of Fixnum, @layout.format_date(Time.now)
+      assert_kind_of Integer, @layout.format_date(Time.now)
     end
 
     def test_date_pattern
@@ -105,7 +105,7 @@ module TestLayouts
                                     'log message', false)
       event.file = 'test_file.rb'
       event.line = '123'
-      event.method = 'method_name'
+      event.method_name = 'method_name'
 
       @layout.pattern = '%c'
       assert_equal 'TestLogger', @layout.format(event)
@@ -230,6 +230,19 @@ module TestLayouts
       assert_equal 'context a', @layout.format(event)
     end
 
+    def test_utc_offset
+      layout = Logging.layouts.pattern(:pattern => "%d", :utc_offset => "UTC")
+      event = Logging::LogEvent.new('DateLogger', @levels['info'], 'log message', false)
+      event.time = Time.utc(2016, 12, 1, 12, 0, 0).freeze
+
+      assert_equal "2016-12-01T12:00:00", layout.format(event)
+
+      layout.utc_offset = "-06:00"
+      assert_equal "2016-12-01T06:00:00", layout.format(event)
+
+      layout.utc_offset = "+01:00"
+      assert_equal "2016-12-01T13:00:00", layout.format(event)
+    end
   end  # TestBasic
 end  # TestLayouts
 end  # TestLogging

data/test/layouts/test_yaml.rb

@@ -68,7 +68,7 @@ module TestLayouts
                                     'log message', false)
       event.file = 'test_file.rb'
       event.line = 123
-      event.method = 'method_name'
+      event.method_name = 'method_name'
 
       @layout.items = %w[logger]
       assert_match %r/\A--- ?\nlogger: TestLogger\n/, @layout.format(event)
@@ -148,6 +148,20 @@ module TestLayouts
       assert_match %r/\nndc: \[\]\n/, format
     end
 
+    def test_utc_offset
+      layout = Logging.layouts.yaml(:items => %w[timestamp])
+      event = Logging::LogEvent.new('TimestampLogger', @levels['info'], 'log message', false)
+      event.time = Time.utc(2016, 12, 1, 12, 0, 0).freeze
+
+      assert_equal %Q{---\ntimestamp: '2016-12-01T12:00:00.000000Z'\n}, layout.format(event)
+
+      layout.utc_offset = "-06:00"
+      assert_equal %Q{---\ntimestamp: '2016-12-01T06:00:00.000000-06:00'\n}, layout.format(event)
+
+      layout.utc_offset = "+01:00"
+      assert_equal %Q{---\ntimestamp: '2016-12-01T13:00:00.000000+01:00'\n}, layout.format(event)
+    end
+
   private
 
     def assert_yaml_match( expected, actual )

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