path-log4r 1.1.10

data/lib/log4r/yamlconfigurator.rb

@@ -0,0 +1,196 @@
+# :include: rdoc/yamlconfigurator
+#
+# == Other Info
+#
+# Version: $Id$
+
+require "log4r/logger"
+require "log4r/outputter/staticoutputter"
+require "log4r/logserver"
+require "log4r/outputter/remoteoutputter"
+
+require 'yaml'
+
+module Log4r
+  # Gets raised when Configurator encounters bad YAML.
+  class ConfigError < Exception
+  end
+
+  # See log4r/yamlconfigurator.rb
+  class YamlConfigurator
+    @@params = Hash.new
+
+    # Get a parameter's value
+    def self.[](param); @@params[param] end
+    # Define a parameter with a value
+    def self.[]=(param, value); @@params[param] = value end
+
+
+    def self.custom_levels( levels)
+      return Logger.root if levels.size == 0
+      for i in 0...levels.size
+        name = levels[i].to_s
+        if name =~ /\s/ or name !~ /^[A-Z]/
+          raise TypeError, "#{name} is not a valid Ruby Constant name", caller
+        end
+      end
+      Log4r.define_levels *levels
+    end
+
+    # Given a filename, loads the YAML configuration for Log4r.
+    def self.load_yaml_file( filename)
+      actual_load( File.open( filename))
+    end
+
+    # You can load a String YAML configuration instead of a file.
+    def self.load_yaml_string( string)
+      actual_load( string)
+    end
+
+    #######
+    private
+    #######
+
+    def self.actual_load( yaml_docs)
+      log4r_config = nil
+      YAML.load_documents( yaml_docs){ |doc|
+        doc.has_key?( 'log4r_config') and log4r_config = doc['log4r_config'] and break
+      }
+      if log4r_config.nil?
+        raise ConfigError, 
+        "Key 'log4r_config:' not defined in yaml documents", caller[1..-1]
+      end
+      decode_yaml( log4r_config)
+    end
+    
+    def self.decode_yaml( cfg)
+      decode_pre_config( cfg['pre_config'])
+      cfg['outputters'].each{ |op| decode_outputter( op)}
+      cfg['loggers'].each{ |lo| decode_logger( lo)}
+      cfg['logserver'].each{ |lo| decode_logserver( lo)} unless cfg['logserver'].nil?
+    end
+
+    def self.decode_pre_config( pre)
+      return Logger.root if pre.nil?
+      decode_custom_levels( pre['custom_levels'])
+      global_config( pre['global'])
+      global_config( pre['root'])
+      decode_parameters( pre['parameters'])
+    end
+
+    def self.decode_custom_levels( levels)
+      return Logger.root if levels.nil?
+      begin custom_levels( levels)
+      rescue TypeError => te
+        raise ConfigError, te.message, caller[1..-4]
+      end
+    end
+    
+    def self.global_config( e)
+      return if e.nil?
+      globlev = e['level']
+      return if globlev.nil?
+      lev = LNAMES.index(globlev)     # find value in LNAMES
+      Log4rTools.validate_level(lev, 4)  # choke on bad level
+      Logger.global.level = lev
+    end
+
+    def self.decode_parameters( params)
+      params.each{ |p| @@params[p['name']] = p['value']} unless params.nil?
+    end
+
+    def self.decode_outputter( op)
+      # fields
+      name = op['name']
+      type = op['type']
+      level = op['level']
+      only_at = op['only_at']
+      # validation
+      raise ConfigError, "Outputter missing name", caller[1..-3] if name.nil?
+      raise ConfigError, "Outputter missing type", caller[1..-3] if type.nil?
+      Log4rTools.validate_level(LNAMES.index(level)) unless level.nil?
+      only_levels = []
+      unless only_at.nil?
+        for lev in only_at
+          alev = LNAMES.index(lev)
+          Log4rTools.validate_level(alev, 3)
+          only_levels.push alev
+        end
+      end
+
+      formatter = decode_formatter( op['formatter'])
+      # build the eval string
+      buff = "Outputter[name] = #{type}.new name"
+      buff += ",:level=>#{LNAMES.index(level)}" unless level.nil?
+      buff += ",:formatter=>formatter" unless formatter.nil?
+      params = decode_hash_params( op)
+      buff += "," + params.join(',') if params.size > 0
+      begin eval buff
+      rescue Exception => ae
+        raise ConfigError, 
+        "Problem creating outputter: #{ae.message}", caller[1..-3]
+      end
+      Outputter[name].only_at( *only_levels) if only_levels.size > 0
+      Outputter[name]
+    end
+
+    def self.decode_formatter( fo)
+      return nil if fo.nil?
+      type = fo['type'] 
+      raise ConfigError, "Formatter missing type", caller[1..-4] if type.nil?
+      buff = "#{type}.new " + decode_hash_params( fo).join(',')
+      begin return eval( buff)
+      rescue Exception => ae
+        raise ConfigError,
+        "Problem creating outputter: #{ae.message}", caller[1..-4]
+      end
+    end
+
+    ExcludeParams = %w{formatter level name type only_at}
+
+    # Does the fancy parameter to hash argument transformation
+    def self.decode_hash_params( ph)
+      buff = []
+      ph.each{ |name, value| 
+        next if ExcludeParams.include? name
+        buff << ":" + name + "=>" + paramsub( value)
+      }
+      buff
+    end
+    
+    # Substitues any #{foo} in the YAML with Parameter['foo']
+    def self.paramsub( str)
+      return nil if str.nil?
+      return nil if str.class != String
+      @@params.each {|param, value|
+        str.sub!( '#{' + param + '}', value)
+      }
+      "'" + str + "'"
+    end
+
+    def self.decode_logger( lo)
+      l = Logger.new lo['name']
+      decode_logger_common( l, lo)
+    end
+
+    def self.decode_logserver( lo)
+      name = lo['name']
+      uri  = lo['uri']
+      l = LogServer.new name, uri
+      decode_logger_common(l, lo)
+    end
+
+    def self.decode_logger_common( l, lo)
+      level    = lo['level']
+      additive = lo['additive']
+      trace    = lo['trace']
+      l.level    = LNAMES.index( level) unless level.nil?
+      l.additive = additive unless additive.nil?
+      l.trace    = trace unless trace.nil?
+      # and now for outputters
+      outs = lo['outputters']
+      outs.each {|n| l.add n.strip} unless outs.nil?
+    end
+  end
+end
+

data/tests/README

@@ -0,0 +1,10 @@
+The unit tests are currently out of date. The examples actually provide
+a decent test suite for log4r. But the unit tests are still very important
+because of bounds-checking and a quicker turnaround for bug discovery.
+The unit files need to be converted to the new 'test/unit' paradigm.
+
+Because Log4r dynamically defines constants according to user preferences, 
+the unit testing can't all be done in one instance of ruby. It is planned
+to use popen to run each test that needs a clean ruby instance.
+
+The logs/ directory is where these tests dump generated log files.

data/tests/testGDC.rb

@@ -0,0 +1,26 @@
+$: << File.join("..","lib")
+require "test/unit"
+require "log4r"
+include Log4r
+
+class TestGDC < Test::Unit::TestCase
+
+  def test_gdc_default
+    assert(GDC.get() == "testGDC.rb", "Expected 'testGDC.rb' got '#{GDC.get()}'" )
+  end
+
+  def test_gdc_set
+    assert_nothing_raised() { GDC.set("testGDCset") }
+    assert(GDC.get() == "testGDCset", "Expected 'testGDCset' got '#{GDC.get()}'" )
+  end
+  
+  def test_gdc_threaded
+    assert_nothing_raised() { GDC.set("testGDCset") }
+    t = Thread.new("test GDC thread") do |name|
+       assert_raise(RuntimeError) { GDC.set("somethingelse") }
+    end
+    t.join
+    assert(GDC.get() == "testGDCset", "Expected 'testGDCset' got '#{GDC.get()}'" )
+  end
+
+end

data/tests/testMDC.rb

@@ -0,0 +1,42 @@
+$: << File.join("..","lib")
+require "test/unit"
+require "log4r"
+include Log4r
+
+class TestMDC < Test::Unit::TestCase
+
+  def test_multithread_copy
+    Log4r::MDC.put("user","colbygk")
+    t = Thread.new("test first copy") do |name|
+      assert(Log4r::MDC.get("user") == "colbygk",
+	     "Did not get back expected value, '#{MDC.get("user")}'")
+      Log4r::MDC.put("user","unique")
+      assert(Log4r::MDC.get("user") == "unique",
+	     "Did not get back expected value, '#{MDC.get("user")}'")
+    end
+    t.join
+    assert(Log4r::MDC.get("user") == "colbygk",
+	   "Did not get back expected value, '#{MDC.get("user")}'")
+  end
+
+  def test_MDCoutput
+    Log4r::MDC.put(:user, "symbol")
+    Log4r::MDC.put("string", "string")
+    Log4r::MDC.put(5, "number")
+    l = Logger.new 'test'
+    o = StdoutOutputter.new 'test' 
+    l.add o
+    assert_nothing_raised { 
+      f = PatternFormatter.new :pattern=> "%l user: %X{:user} %X{strng} %X{5}"
+      Outputter['test'].formatter = f
+      l.debug "And this?"
+      l.info "How's this?"
+      l.error "and a really freaking huge line which we hope will be trimmed?"
+      e = ArgumentError.new("something barfed")
+      e.set_backtrace Array.new(5, "trace junk at thisfile.rb 154")
+      l.fatal e
+      l.info [1, 3, 5]
+    }
+
+  end
+end

data/tests/testNDC.rb

@@ -0,0 +1,27 @@
+$: << File.join("..","lib")
+require "test/unit"
+require "log4r"
+include Log4r
+
+class TestNDC < Test::Unit::TestCase
+
+  def test_ndc_remove_push
+    NDC.remove()
+    NDC.push("ndc")
+    assert(Log4r::NDC.get() == "ndc", "Expected 'ndc' got '#{NDC.get()}'" )
+    NDC.push("ndc")
+    assert(Log4r::NDC.get() == "ndc ndc", "Expected 'ndc ndc' got '#{NDC.get()}'" )
+  end
+
+  def test_ndc_remove_push_clone_and_inherit
+    NDC.remove()
+    NDC.push("ndc")
+    NDC.push("ndc")
+    a = NDC.clone_stack()
+    NDC.remove()
+    assert(NDC.get() == "", "Expected '' got '#{NDC.get()}'" )
+    NDC.inherit(a)
+    assert(NDC.get() == "ndc ndc", "Expected 'ndc ndc' got '#{NDC.get()}'" )
+  end
+
+end

data/tests/testall.rb

@@ -0,0 +1,6 @@
+$: << File.join("..", "lib")
+
+# because constants are dynamically defined, some tests need to
+# be opened in a fresh instance of Ruby, hence the popens
+
+IO.popen("date") { |f| puts f.gets }

data/tests/testbase.rb

@@ -0,0 +1,49 @@
+$: << File.join("..","lib")
+require "test/unit"
+require "log4r"
+include Log4r
+
+class TestBase < Test::Unit::TestCase
+  # check that LNAMES loads properly (it uses an eval to load)
+  def test_default_levels
+    Logger.root              # doing this loads the default levels
+    assert_equal(ALL,0)
+    assert_equal(DEBUG,1)
+    assert_equal(INFO,2)
+    assert_equal(WARN,3)
+    assert_equal(ERROR,4)
+    assert_equal(FATAL,5)
+    assert_equal(OFF,6)
+    assert_equal(LEVELS, 7)
+    assert_equal(LNAMES.size, 7)
+  end
+  # check bad input and bounds for validate_level
+  def test_validate_level
+    7.times{|i| assert_nothing_raised {Log4rTools.validate_level(i)} }
+    assert_raises(ArgumentError) {Log4rTools.validate_level(-1)}
+    assert_raises(ArgumentError) {Log4rTools.validate_level(LEVELS)}
+    assert_raises(ArgumentError) {Log4rTools.validate_level(String)}
+    assert_raises(ArgumentError) {Log4rTools.validate_level("bogus")}
+  end
+  # decode_bool turns a string 'true' into true and so on
+  def test_decode_bool
+    # when the key is a symbol :data
+    assert(Log4rTools.decode_bool({:data=> 'true'}   ,:data,false) == true)
+    assert(Log4rTools.decode_bool({:data=> true}     ,:data,false) == true)
+    assert(Log4rTools.decode_bool({:data=> 'false'}  ,:data,true) == false)
+    assert(Log4rTools.decode_bool({:data=> false}    ,:data,true) == false)
+    assert(Log4rTools.decode_bool({:data=> nil}      ,:data,true) == true)
+    assert(Log4rTools.decode_bool({:data=> nil}      ,:data,false) == false)
+    assert(Log4rTools.decode_bool({:data=> String}   ,:data,true) == true)
+    assert(Log4rTools.decode_bool({:data=> String}   ,:data,false) == false)
+    # now the key is a string 'data'
+    assert(Log4rTools.decode_bool({'data'=> 'true'}  ,:data,false) == true)
+    assert(Log4rTools.decode_bool({'data'=> true}    ,:data,false) == true)
+    assert(Log4rTools.decode_bool({'data'=> 'false'} ,:data,true) == false)
+    assert(Log4rTools.decode_bool({'data'=> false}   ,:data,true) == false)
+    assert(Log4rTools.decode_bool({'data'=> nil}     ,:data,true) == true)
+    assert(Log4rTools.decode_bool({'data'=> nil}     ,:data,false) == false)
+    assert(Log4rTools.decode_bool({'data'=> String}  ,:data,true) == true)
+    assert(Log4rTools.decode_bool({'data'=> String}  ,:data,false) == false)
+  end
+end

data/tests/testchainsaw.rb

@@ -0,0 +1,48 @@
+$: << File.join("..", "lib")
+
+require 'log4r'
+require 'log4r/staticlogger'
+require 'log4r/formatter/log4jxmlformatter'
+require 'log4r/outputter/udpoutputter'
+require 'log4r/outputter/consoleoutputters'
+
+include Log4r
+
+log4r = Logger.new 'log4r'
+log4r.trace = true
+log4r.outputters = StdoutOutputter.new 'log4r'
+log4r.level = ALL
+
+formatter = Log4jXmlFormatter.new
+outputter = UDPOutputter.new 'udp', :hostname => "localhost", :port => 8071
+outputter.formatter = formatter
+
+mylog = Logger.new 'mylog'
+mylog.trace = true
+mylog.outputters = [outputter]
+
+# Log4r::Formatter throws when formatting
+# an excpetion with a nil backtrace (line 73).
+def get_exception(msg)
+  begin
+    raise msg
+  rescue Exception => e
+    e
+  end
+end
+
+NDC.push "saw test"
+
+MDC.put "clientip", %q{10.33.33.33}
+
+def do_log(log)
+    log.debug "This is a message with level DEBUG"
+    log.info "This is a message with level INFO"
+    log.warn "This is a message with level WARN"
+    log.error "This is a message with level ERROR"
+    log.fatal "This is a message with level FATAL"
+
+    log.fatal get_exception( "This is an exception" )
+end
+
+do_log(mylog)

data/tests/testconf.xml

@@ -0,0 +1,37 @@
+<test>
+<log4r_config>
+
+  <pre_config>
+    <custom_levels>Foo, Bar,Baz, Bing</custom_levels>
+    <global level="Foo"/>
+    <parameters>
+      <mypattern>[%l] %d %t - %m</mypattern>
+    </parameters>
+    <parameter name="datem" value="usec"/>
+  </pre_config>
+
+  <!-- level and formatter are optional, -->
+  <outputter name="SO" type="StdoutOutputter">
+    <level>Foo</level>
+    <formatter type="Log4r::PatternFormatter">
+      <pattern>%d %c %l&gt; %m</pattern>
+      <date_method>#{datem}</date_method>
+    </formatter>
+  </outputter>
+  <outputter name="SE" type="StderrOutputter" level="Baz">
+    <formatter type="PatternFormatter" pattern="#{mypattern}">
+      <date_pattern>%H:%S</date_pattern>
+    </formatter>
+  </outputter>
+  <outputter name="F" type="FileOutputter">
+    <filename>#{logpath}/junk/foo.log</filename>
+    <trunc>true</trunc>
+    <only_at>Foo, Bar, Bing</only_at>
+  </outputter>
+  <!-- optional level, additive and outputters -->
+  <logger name="first::second" level="Bar" additive="false">
+    <trace>true</trace>
+    <outputters>SO, SE, F, stdout, stderr</outputters>
+  </logger>
+</log4r_config>
+</test>