logging 0.1.0 → 0.2.0

data/lib/logging/config/yaml_configurator.rb

@@ -0,0 +1,190 @@
+# $Id: yaml_configurator.rb 22 2007-01-29 16:20:54Z tim_pease $
+
+require 'yaml'
+require 'logging'
+
+module Logging
+module Config
+
+  #
+  # The YamlConfigurator class is used to configure the Logging framework
+  # using information found in a YAML file.
+  #
+  class YamlConfigurator
+
+    class Error < StandardError; end  # :nodoc:
+
+    class << self
+      #
+      # call-seq:
+      #    YamlConfigurator.load( file )
+      #
+      # Load the given YAML _file_ and use it to configure the Logging
+      # framework. The file can be either a filename, and open File, or an
+      # IO object. If it is the latter two, the File / IO object will not be
+      # closed by this method.
+      #
+      def load( file )
+        io, close = nil, false
+        case file
+        when String
+          io = File.open(file, 'r')
+          close = true
+        when IO: io = file
+        else raise Error, 'expecting a filename or a File' end
+
+        begin new(io).load; ensure; io.close if close end
+        nil
+      end
+    end  # class << self
+
+    #
+    # call-seq:
+    #    YamlConfigurator.new( io )
+    #
+    # Creates a new YAML configurator that will load the Logging
+    # configuration from the given _io_ stream.
+    #
+    def initialize( io )
+      YAML.load_documents(io) do |doc|
+        @config = doc['logging_config']
+        break if @config.instance_of?(Hash)
+      end
+
+      unless @config.instance_of?(Hash)
+        raise Error, "Key 'logging_config' not defined in YAML configuration"
+      end
+    end
+    private :initialize
+
+    #
+    # call-seq:
+    #    load
+    #
+    # Loads the Logging configuration from the data loaded from the YAML
+    # file.
+    #
+    def load
+      pre_config @config['pre_config']
+      appenders @config['appenders']
+      loggers @config['loggers']
+    end
+
+    #
+    # call-seq:
+    #    pre_config( config )
+    #
+    # Configures the logging levels, object format style, and root logging
+    # level.
+    #
+    def pre_config( config )
+      # if no pre_config section was given, just create an empty hash
+      # we do this to ensure that some logging levels are always defined
+      config ||= Hash.new
+
+      # define levels
+      levels = config['define_levels']
+      ::Logging.define_levels(levels) unless levels.nil?
+
+      # format as
+      format = config['format_as']
+      ::Logging.format_as(format) unless format.nil?
+
+      # grab the root logger and set the logging level
+      root = ::Logging::Logger.root
+      if config.has_key?('root')
+        root.level = config['root']['level']
+      end
+    end
+
+    #
+    # call-seq:
+    #    appenders( ary )
+    #
+    # Given an array of Appender configurations, this method will iterate
+    # over each and create the Appender(s).
+    #
+    def appenders( ary )
+      return if ary.nil?
+
+      ary.each {|h| appender(h)}
+    end
+
+    #
+    # call-seq:
+    #    loggers( ary )
+    #
+    # Given an array of Logger configurations, this method will iterate over
+    # each and create the Logger(s).
+    #
+    def loggers( ary )
+      return if ary.nil?
+
+      ary.each do |config|
+        name = config['name']
+        raise Error, 'Logger name not given' if name.nil?
+
+        l = Logging::Logger.new name
+        l.level = config['level'] if config.has_key?('level')
+        l.additive = config['additive'] if l.respond_to? :additive=
+        l.trace = config['trace'] if l.respond_to? :trace=
+
+        if config.has_key?('appenders')
+          l.appenders = config['appenders'].map {|n| ::Logging::Appender[n]}
+        end
+      end
+    end
+
+    #
+    # call-seq:
+    #    appender( config )
+    #
+    # Creates a new Appender based on the given _config_ options (a hash).
+    # The type of Appender created is determined by the 'type' option in the
+    # config. The remaining config options are passed to the Appender
+    # initializer.
+    #
+    # The config options can also contain a 'layout' option. This should be
+    # another set of options used to create a Layout for this Appender.
+    #
+    def appender( config )
+      return if config.nil?
+      config = config.dup
+
+      type = config.delete('type')
+      raise Error, 'Appender type not given' if type.nil?
+
+      name = config.delete('name')
+      raise Error, 'Appender name not given' if type.nil?
+
+      config['layout'] = layout(config.delete('layout'))
+
+      clazz = ::Logging::Appenders.const_get type
+      clazz.new(name, config)
+    end
+
+    #
+    # call-seq:
+    #    layout( config )
+    #
+    # Creates a new Layout based on the given _config_ options (a hash).
+    # The type of Layout created is determined by the 'type' option in the
+    # config. The remaining config options are passed to the Layout
+    # initializer.
+    #
+    def layout( config )
+      return if config.nil?
+      config = config.dup
+
+      type = config.delete('type')
+      raise Error, 'Layout type not given' if type.nil?
+
+      clazz = ::Logging::Layouts.const_get type
+      clazz.new config
+    end
+
+  end  # class YamlConfigurator
+end  # module Config
+end  # module Logging
+
+# EOF

data/lib/logging/layout.rb

@@ -1,4 +1,4 @@
-# $Id: layout.rb 9 2007-01-11 23:51:41Z tim_pease $
+# $Id: layout.rb 17 2007-01-20 18:47:43Z tim_pease $
  
 require 'yaml'
 require 'logging'
@@ -18,11 +18,10 @@ module Logging
 
     #
     # call-seq:
-    #    Layout.new
-    #    Layout.new( obj_format )
+    #    Layout.new( :format_as => :string )
     #
-    # Creates a new layout that uses the given _obj_format_ when converting
-    # objects to strings. _obj_format_ can be one of <tt>:string</tt>,
+    # Creates a new layout that will format objecs as strings using the
+    # given <tt>:format_as</tt> style. This can be one of <tt>:string</tt>,
     # <tt>:inspect</tt>, or <tt>:yaml</tt>. These formatting commands map to
     # the following object methods:
     #
@@ -30,12 +29,15 @@ module Logging
     # * :inspect => inspect
     # * :yaml    => to_yaml
     #
-    # If _obj_format_ is not given then the global object format is used
+    # If the format is not specified then the global object format is used
     # (see Logging#format_as). If the global object format is not specified
-    # then +:string+ is used.
+    # then <tt>:string</tt> is used.
     #
-    def initialize( f = nil )
+    def initialize( opts = {} )
+      f = opts[:format_as] || opts['format_as']
       f ||= ::Logging::OBJ_FORMAT if ::Logging.const_defined? 'OBJ_FORMAT'
+      f = f.intern if f.instance_of? String
+
       @obj_format = case f
                     when :inspect, :yaml: f
                     else :string end

data/lib/logging/layouts/pattern.rb

@@ -1,4 +1,4 @@
-# $Id: pattern.rb 13 2007-01-15 17:19:37Z tim_pease $
+# $Id: pattern.rb 17 2007-01-20 18:47:43Z tim_pease $
 
 require 'logging'
 require 'logging/layout'
@@ -243,14 +243,12 @@ module Layouts
     # If used, :date_method will supersede :date_pattern.
     #
     def initialize( opts = {} )
-      f = opts.delete(:obj_format)
-      super(f)
-
+      super
       @created_at = Time.now
 
-      @pattern = opts[:pattern]
-      @date_pattern = opts[:date_pattern]
-      @date_method = opts[:date_method]
+      @pattern = opts[:pattern] || opts['pattern']
+      @date_pattern = opts[:date_pattern] || opts['date_pattern']
+      @date_method = opts[:date_method] || opts['date_method']
 
       @pattern ||= "[%d] %-#{::Logging::MAX_LEVEL_LENGTH}l -- %c : %m\n"
       @date_pattern = ISO8601 if @date_pattern.nil? and @date_method.nil?
@@ -268,7 +266,7 @@ module Layouts
     # Set the message formatting pattern to be used by the layout.
     #
     def pattern=( var )
-      @pattern = var.to_s
+      @pattern = var
       Pattern.create_format_methods(self)
     end
 
@@ -280,7 +278,7 @@ module Layouts
     # in the log messages.
     #
     def date_pattern=( var )
-      @date_pattern = var.to_s
+      @date_pattern = var
       Pattern.create_date_format_methods(self)
     end
 

data/lib/logging/logger.rb

@@ -1,6 +1,6 @@
-# $Id: logger.rb 15 2007-01-15 19:03:45Z tim_pease $
+# $Id: logger.rb 22 2007-01-29 16:20:54Z tim_pease $
 
-require 'sync'
+require 'thread'
 require 'logging'
 require 'logging/appender'
 require 'logging/log_event'
@@ -33,10 +33,9 @@ module Logging
   #
   class Logger
 
-    @mutex = Sync.new  # :nodoc:
+    @mutex = Mutex.new  # :nodoc:
 
     class << self
-
       #
       # call-seq:
       #    Logger.root
@@ -59,7 +58,7 @@ module Logging
         repo = ::Logging::Repository.instance
         name = repo.to_key(args.shift)
 
-        @mutex.synchronize(:EX) do
+        @mutex.synchronize do
           logger = repo[name]
           if logger.nil?
             logger = super(name, *args)
@@ -121,8 +120,7 @@ module Logging
 
     end  # class << self
 
-    attr_reader :level, :name, :parent
-    attr_accessor :additive, :trace
+    attr_reader :level, :name, :parent, :additive, :trace
 
     #
     # call-seq:
@@ -192,6 +190,38 @@ module Logging
       @parent << msg if @additive
     end
 
+    #
+    # call-seq:
+    #    additive = true
+    #
+    # Sets the additivity of the logger. Acceptable values are +true+,
+    # 'true', +false+, 'false', or +nil+. In this case +nil+ does not
+    # change the additivity
+    #
+    def additive=( val )
+      @additive = case val
+                  when true, 'true': true
+                  when false, 'false': false
+                  when nil: @additive
+                  else raise ArgumentError, 'expecting a boolean' end
+    end
+
+    #
+    # call-seq:
+    #    trace = true
+    #
+    # Sets the tracing of the logger. Acceptable values are +true+,
+    # 'true', +false+, 'false', or +nil+. In this case +nil+ does not
+    # change the tracing.
+    #
+    def trace=( val )
+      @trace = case val
+               when true, 'true': true
+               when false, 'false': false
+               when nil: @trace
+               else raise ArgumentError, 'expecting a boolean' end
+    end
+
     #
     # call-seq:
     #    level = :all

data/test/appenders/test_console.rb

@@ -1,15 +1,15 @@
-# $Id: test_console.rb 2 2007-01-09 18:10:50Z tim_pease $
+# $Id: test_console.rb 17 2007-01-20 18:47:43Z tim_pease $
 
 require 'test/setup.rb'
 
 module TestLogging
 module TestAppenders
 
-  class TestStdOut < Test::Unit::TestCase
+  class TestStdout < Test::Unit::TestCase
     include LoggingTestCase
 
     def test_initialize
-      appender = ::Logging::Appenders::StdOut.new
+      appender = ::Logging::Appenders::Stdout.new
       assert_equal 'stdout', appender.name
       assert_same STDOUT, appender.instance_variable_get(:@io)
 
@@ -18,12 +18,12 @@ module TestAppenders
       assert_equal false, STDOUT.closed?
     end
 
-  end  # class TestStdOut
+  end  # class TestStdout
 
-  class TestStdErr < Test::Unit::TestCase
+  class TestStderr < Test::Unit::TestCase
 
     def test_initialize
-      appender = ::Logging::Appenders::StdErr.new
+      appender = ::Logging::Appenders::Stderr.new
       assert_equal 'stderr', appender.name
       assert_same STDERR, appender.instance_variable_get(:@io)
 
@@ -32,7 +32,7 @@ module TestAppenders
       assert_equal false, STDERR.closed?
     end
 
-  end  # class TestStdErr
+  end  # class TestStderr
 
 end  # module TestAppenders
 end  # module TestLogging

data/test/appenders/test_file.rb

@@ -1,4 +1,4 @@
-# $Id: test_file.rb 2 2007-01-09 18:10:50Z tim_pease $
+# $Id: test_file.rb 17 2007-01-20 18:47:43Z tim_pease $
 
 require 'test/setup.rb'
 require 'fileutils'
@@ -27,19 +27,26 @@ module TestAppenders
 
     def test_initialize
       log = File.join(TMP, 'uw_dir', 'file.log')
-      assert_raise(StandardError) {::Logging::Appenders::File.new log}
+      assert_raise(StandardError) do
+        ::Logging::Appenders::File.new(nil, :filename => log)
+      end
 
       log = File.join(TMP, 'dir')
-      assert_raise(StandardError) {::Logging::Appenders::File.new log}
+      assert_raise(StandardError) do
+        ::Logging::Appenders::File.new(nil, :filename => log)
+      end
 
       log = File.join(TMP, 'uw_file')
-      assert_raise(StandardError) {::Logging::Appenders::File.new log}
+      assert_raise(StandardError) do
+        ::Logging::Appenders::File.new(nil, :filename => log)
+      end
 
       log = File.join(TMP, 'file.log')
-      appender = ::Logging::Appenders::File.new log
-      assert_equal log, appender.name
+      appender = ::Logging::Appenders::File.new 'logfile', 'filename' => log
+      assert_equal 'logfile', appender.name
       appender << "This will be the first line\n"
       appender << "This will be the second line\n"
+      appender.flush
       File.open(log, 'r') do |file|
         assert_equal "This will be the first line\n", file.readline
         assert_equal "This will be the second line\n", file.readline
@@ -47,9 +54,10 @@ module TestAppenders
       end
       appender.close
 
-      appender = ::Logging::Appenders::File.new log
-      assert_equal log, appender.name
+      appender = ::Logging::Appenders::File.new 'logfile', :filename => log
+      assert_equal 'logfile', appender.name
       appender << "This will be the third line\n"
+      appender.flush
       File.open(log, 'r') do |file|
         assert_equal "This will be the first line\n", file.readline
         assert_equal "This will be the second line\n", file.readline
@@ -58,9 +66,11 @@ module TestAppenders
       end
       appender.close
 
-      appender = ::Logging::Appenders::File.new log, :truncate => true
-      assert_equal log, appender.name
+      appender = ::Logging::Appenders::File.new 'logfile', :filename => log,
+                                                           :truncate => true
+      assert_equal 'logfile', appender.name
       appender << "The file was truncated\n"
+      appender.flush
       File.open(log, 'r') do |file|
         assert_equal "The file was truncated\n", file.readline
         assert_raise(EOFError) {file.readline}