TwP-logging 0.9.8 → 0.9.8.1

data/lib/logging/layouts/pattern.rb

@@ -1,6 +1,5 @@
 
-module Logging
-module Layouts
+module Logging::Layouts
 
   # A flexible layout configurable with pattern string.
   #
@@ -22,7 +21,7 @@ module Layouts
   # Let the conversion pattern be "%-5l [%c]: %m\n" and assume that the
   # logging environment was set to use a Pattern layout. Then the statements
   #
-  #    root = Logging::Logger[:root]
+  #    root = Logging.logger[:root]
   #    root.debug("Message 1")
   #    root.warn("Message 2")
   #
@@ -57,9 +56,9 @@ module Layouts
   #  [t]  Used to output the object ID of the thread that generated the
   #       log event.
   #  [T]  Used to output the name of the thread that generated the log event.
-  #       Name can be specified using Thread.current[:name] notation. Output empty
-  #       string if name not specified. This options helps to create more human
-  #       readable output for multithread application log.
+  #       Name can be specified using Thread.current[:name] notation. Output
+  #       empty string if name not specified. This option helps to create
+  #       more human readable output for multithread application logs.
   #  [%]  The sequence '%%' outputs a single percent sign.
   #
   # The directives F, L, and M will only work if the Logger generating the
@@ -290,7 +289,6 @@ module Layouts
     # :startdoc:
 
   end  # class Pattern
-end  # module Layouts
-end  # module Logging
+end  # module Logging::Layouts
 
 # EOF

data/lib/logging/layouts.rb

@@ -0,0 +1,47 @@
+
+module Logging
+  module Layouts
+
+    # Accessor / Factory for the Basic layout.
+    #
+    def basic( *args )
+      return ::Logging::Layouts::Basic if args.empty?
+      ::Logging::Layouts::Basic.new(*args)
+    end
+
+    # Accessor / Factory for the Pattern layout.
+    #
+    def pattern( *args )
+      return ::Logging::Layouts::Pattern if args.empty?
+      ::Logging::Layouts::Pattern.new(*args)
+    end
+
+    # Accessor for the Parseable layout.
+    #
+    def parseable
+      ::Logging::Layouts::Parseable
+    end
+
+    # Factory for the Parseable layout using JSON formatting.
+    #
+    def json( *args )
+      ::Logging::Layouts::Parseable.json(*args)
+    end
+
+    # Factory for the Parseable layout using YAML formatting.
+    #
+    def yaml( *args )
+      ::Logging::Layouts::Parseable.yaml(*args)
+    end
+
+    extend self
+  end  # module Layouts
+end  # module Logging
+
+
+%w[basic parseable pattern].
+each do |fn|
+  require ::Logging.libpath('logging', 'layouts', fn)
+end
+
+# EOF

data/lib/logging/log_event.rb

@@ -37,7 +37,7 @@ module Logging
 
         m = CALLER_RGXP.match(t)
         @file = m[1]
-        @line = m[2]
+        @line = Integer(m[2])
         @method = m[3] unless m[3].nil?
       end
     end

data/lib/logging/logger.rb

@@ -12,8 +12,8 @@ module Logging
   #
   # Example:
   #
-  #    log = Logging::Logger['my logger']
-  #    log.add_appenders( Logging::Appender.stdout )   # append to STDOUT
+  #    log = Logging.logger['my logger']
+  #    log.add_appenders( Logging.appenders.stdout )   # append to STDOUT
   #    log.level = :info                               # log 'info' and above
   #
   #    log.info 'starting foo operation'
@@ -312,8 +312,8 @@ module Logging
     #
     def add_appenders( *args )
       args.flatten.each do |arg|
-        o = arg.kind_of?(::Logging::Appender) ? arg : ::Logging::Appender[arg]
-        raise ArgumentError, "unknown appender '#{arg}'" if o.nil?
+        o = arg.kind_of?(::Logging::Appender) ? arg : ::Logging::Appenders[arg.to_s]
+        raise ArgumentError, "unknown appender #{arg.inspect}" if o.nil?
         @appenders << o unless @appenders.include?(o)
       end
       self

data/lib/logging.rb

@@ -3,7 +3,24 @@
 # Used to prevent the class/module from being loaded more than once
 unless defined? Logging
 
+require 'yaml'
+require 'stringio'
 require 'thread'
+
+begin
+  require 'lockfile'
+rescue LoadError
+  retry if require 'rubygems'
+  raise
+end
+
+begin
+  require 'syslog'
+  HAVE_SYSLOG = true
+rescue LoadError
+  HAVE_SYSLOG = false
+end
+
 begin require 'fastthread'; rescue LoadError; end
 
 # TODO: Windows Log Service appender
@@ -13,7 +30,7 @@ begin require 'fastthread'; rescue LoadError; end
 module Logging
 
   # :stopdoc:
-  VERSION = '0.9.8'
+  VERSION = '0.9.8.1'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
   WIN32 = %r/djgpp|(cyg|ms|bcc)win|mingw/ =~ RUBY_PLATFORM
@@ -85,6 +102,8 @@ module Logging
     # full description of the :pattern and :date_pattern formatting strings.
     #
     def logger( *args )
+      return ::Logging::Logger if args.empty?
+
       opts = args.pop if args.last.instance_of?(Hash)
       opts ||= Hash.new
 
@@ -141,6 +160,18 @@ module Logging
       logger
     end
 
+    # Access to the layouts.
+    #
+    def layouts
+      ::Logging::Layouts
+    end
+
+    # Access to the appenders.
+    #
+    def appenders
+      ::Logging::Appenders
+    end
+
     # call-seq:
     #    Logging.init( levels )
     #
@@ -182,8 +213,8 @@ module Logging
       args = %w(debug info warn error fatal) if args.empty?
 
       args.flatten!
-      levels = ::Logging::LEVELS.clear
-      names = ::Logging::LNAMES.clear
+      levels = LEVELS.clear
+      names = LNAMES.clear
 
       id = 0
       args.each do |lvl|
@@ -274,19 +305,6 @@ module Logging
       args.empty? ? PATH : ::File.join(PATH, args.flatten)
     end
 
-    # Utility method used to rquire all files ending in .rb that lie in the
-    # directory below this file that has the same name as the filename passed
-    # in. Optionally, a specific _directory_ name can be passed in such that
-    # the _filename_ does not have to be equivalent to the directory.
-    #
-    def require_all_libs_relative_to( fname, dir = nil )
-      dir ||= ::File.basename(fname, '.*')
-      search_me = ::File.expand_path(
-          ::File.join(::File.dirname(fname), dir, '*.rb'))
-
-      Dir.glob(search_me).sort.each {|rb| require rb}
-    end
-
     # call-seq:
     #    show_configuration( io = STDOUT, logger = 'root' )
     #
@@ -386,17 +404,29 @@ module Logging
   end
 end  # module Logging
 
-Logging.require_all_libs_relative_to(__FILE__)
-Logging.require_all_libs_relative_to(__FILE__, 'logging/config')
+
+require Logging.libpath(%w[logging utils])
+require Logging.libpath(%w[logging appender])
+require Logging.libpath(%w[logging layout])
+require Logging.libpath(%w[logging log_event])
+require Logging.libpath(%w[logging logger])
+require Logging.libpath(%w[logging repository])
+require Logging.libpath(%w[logging root_logger])
+require Logging.libpath(%w[logging stats])
+require Logging.libpath(%w[logging appenders])
+require Logging.libpath(%w[logging layouts])
+
+require Logging.libpath(%w[logging config configurator])
+require Logging.libpath(%w[logging config yaml_configurator])
+
 
 # This exit handler will close all the appenders that exist in the system.
 # This is needed for closing IO streams and connections to the syslog server
 # or e-mail servers, etc.
 #
 at_exit {
-  Logging::Appender.instance_variable_get(:@appenders).values.each do |ap|
-    ap.close
-  end
+  Logging.log_internal {'at_exit hook called - closing all appenders'}
+  Logging::Appenders.each {|appender| appender.close}
 }
 
 end  # unless defined?

data/lib/spec/logging_helper.rb

@@ -0,0 +1,34 @@
+
+module Spec
+  module LoggingHelper
+
+    # Capture log messages from the Logging framework and make them
+    # available via a @log_output instance variable. The @log_output
+    # supports a readline method to access the log messags.
+    #
+    def capture_log_messages( opts = {} )
+      from = opts.getopt(:from, 'root')
+      to = opts.getopt(:to, '__rspec__')
+      exclusive = opts.getopt(:exclusive, true)
+
+      appender = Logging::Appenders[to] || Logging::Appenders::StringIo.new(to)
+      logger = Logging::Logger[from]
+      if exclusive
+        logger.appenders = appender
+      else
+        logger.add_appenders(appender)
+      end
+
+      before(:all) do
+        @log_output = Logging::Appenders[to]
+      end
+
+      before(:each) do
+        @log_output.reset
+      end
+    end
+
+  end  # module LoggingHelper
+end  # module Spec
+
+# EOF

data/test/appenders/test_buffered_io.rb

@@ -9,20 +9,18 @@ module TestAppenders
 
     def setup
       super
-      ::Logging.init
-      @levels = ::Logging::LEVELS
-
-      @appender = ::Logging::Appenders::StringIo.new(
+      @appender = Logging.appenders.string_io(
         'test_appender', :auto_flushing => 3, :immediate_at => :error
       )
+      @appender.clear
       @sio = @appender.sio
-
+      @levels = Logging::LEVELS
       begin readline rescue EOFError end
     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_nil(readline)
 
@@ -45,15 +43,15 @@ 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_nil(log.readline)
 
@@ -68,6 +66,16 @@ module TestAppenders
       assert_equal 5, @appender.level
     end
 
+    def test_auto_flushing
+      assert_raise(ArgumentError) {
+        @appender.auto_flushing = Object.new
+      }
+
+      assert_raise(ArgumentError) {
+        @appender.auto_flushing = -1
+      }
+    end
+
     def test_close
       assert_equal false, @sio.closed?
       assert_equal false, @appender.closed?
@@ -77,7 +85,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?
@@ -105,9 +113,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
@@ -141,8 +149,8 @@ module TestAppenders
     end
 
     def test_immediate_at
-      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_nil(readline)
 

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)