mtn_log4r 1.1.11

data/lib/log4r/repository.rb

@@ -0,0 +1,88 @@
+# :nodoc:
+# Version:: $Id$
+#
+# Using Thread.exclusive seems to be more efficient than using
+# a class wide instance of Sync.synchronize in ruby 1.8.6 - Colby
+#
+# Using Sync.synchronize, 5000 iterations:
+# real	3m55.493s user	3m45.557s sys	0m3.478s
+#
+# Using Thread.exclusive, 5000 iterations:
+# real	2m35.859s user	2m33.951s sys	0m1.224s
+#
+
+require 'monitor'
+require "singleton"
+
+module Log4r
+  class Logger
+
+    # The repository stores a Hash of loggers keyed to their fullnames and
+    # provides a few functions to reduce the code bloat in log4r/logger.rb.
+    # This class is supposed to be transparent to end users, hence it is
+    # a class within Logger. If anyone knows how to make this private,
+    # let me know.
+
+    class Repository # :nodoc:
+      extend MonitorMixin
+      include Singleton
+      attr_reader :loggers
+
+      def initialize
+	@loggers = Hash.new
+      end
+
+      def self.[](fullname)
+	self.synchronize do
+	  instance.loggers[fullname]
+	end # exclusive
+      end
+
+      def self.[]=(fullname, logger)
+	self.synchronize do
+	  instance.loggers[fullname] = logger
+	end # exclusive
+      end
+
+      # Retrieves all children of a parent
+      def self.all_children(parent)
+	# children have the parent name + delimiter in their fullname
+	daddy = parent.name + Private::Config::LoggerPathDelimiter
+	self.synchronize do
+	  for fullname, logger in instance.loggers
+	    yield logger if parent.is_root? || fullname =~ /#{daddy}/
+	  end
+	end # exclusive
+      end
+
+      # when new loggers are introduced, they may get inserted into
+      # an existing inheritance tree. this method
+      # updates the children of a logger to link their new parent
+      def self.reassign_any_children(parent)
+	self.synchronize do
+	  for fullname, logger in instance.loggers
+	    next if logger.is_root?
+	    logger.parent = parent if logger.path =~ /^#{parent.fullname}$/
+	  end
+	end # exclusive
+      end
+
+      # looks for the first defined logger in a child's path 
+      # or nil if none found (which will then be rootlogger)
+      def self.find_ancestor(path)
+	arr = path.split Log4rConfig::LoggerPathDelimiter
+	logger = nil
+	self.synchronize do
+	  while arr.size > 0 do
+	    logger = Repository[arr.join(Log4rConfig::LoggerPathDelimiter)]
+	    break unless logger.nil?
+	    arr.pop
+	  end
+	end # exclusive
+	logger
+      end
+
+    end # class Repository
+  end # class Logger
+end # Module Log4r
+

data/lib/log4r/staticlogger.rb

@@ -0,0 +1,49 @@
+# :nodoc:
+module Log4r
+  class Logger
+    # Returns the root logger. Identical to Logger.global
+    def self.root; return RootLogger.instance end
+    # Returns the root logger. Identical to Logger.root
+    def self.global; return root end
+    
+    # Get a logger with a fullname from the repository or nil if logger
+    # wasn't found.
+
+    def self.[](_fullname)
+      # forces creation of RootLogger if it doesn't exist yet.
+      return RootLogger.instance if _fullname=='root' or _fullname=='global'
+      Repository[_fullname]
+    end
+
+    # Like Logger[] except that it raises NameError if Logger wasn't found.
+
+    def self.get(_fullname)
+      logger = self[_fullname]
+      if logger.nil?
+        raise NameError, "Logger '#{_fullname}' not found.", caller
+      end
+      logger
+    end
+
+    # Yields fullname and logger for every logger in the system.
+    def self.each
+      for fullname, logger in Repository.instance.loggers
+        yield fullname, logger
+      end
+    end
+
+    def self.each_logger
+      Repository.instance.loggers.each_value {|logger| yield logger}
+    end
+
+    # Internal logging for Log4r components. Accepts only blocks.
+    # To see such log events, create a logger named 'log4r' and give 
+    # it an outputter.
+
+    def self.log_internal(level=1)
+      internal = Logger['log4r']
+      return if internal.nil?
+      internal.send(LNAMES[level].downcase, yield)
+    end
+  end
+end

data/lib/log4r/version.rb

@@ -0,0 +1,4 @@
+module Log4r
+  Log4rVersion = [1, 1, 11].join '.' # deprecate?
+  VERSION = Log4rVersion
+end

data/lib/log4r/yamlconfigurator.rb

@@ -0,0 +1,198 @@
+# :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'])
+
+      opts = {}
+      opts[:level] = LNAMES.index(level) unless level.nil?
+      opts[:formatter] = formatter unless formatter.nil?
+      opts.merge!(decode_hash_params(op))
+      begin
+        Outputter[name] = Log4r.const_get(type).new name, opts
+      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?
+      begin
+        return Log4r.const_get(type).new(decode_hash_params(fo))
+      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)
+      case ph
+      when Hash
+        ph.inject({}){|a,(k,v)| a[k] = self.decode_hash_params(v); a}
+      when Array
+        ph.map{|v| self.decode_hash_params(v)}
+      when String
+        self.paramsub(ph)
+      else
+        ph
+      end
+    end
+
+    # Substitues any #{foo} in the YAML with Parameter['foo']
+    def self.paramsub(str)
+      @@params.each {|param, value|
+        str = 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/lib/log4r.rb

@@ -0,0 +1,18 @@
+# :include: log4r/rdoc/log4r
+#
+# == Other Info
+#
+# Author::      Leon Torres
+# Version::     $Id$
+
+require 'log4r/version'
+require "log4r/outputter/fileoutputter"
+require "log4r/outputter/consoleoutputters"
+require "log4r/outputter/staticoutputter"
+require "log4r/outputter/rabbitoutputter"
+require "log4r/outputter/rollingfileoutputter"
+require "log4r/formatter/patternformatter"
+require "log4r/loggerfactory"
+require "log4r/GDC"
+require "log4r/NDC"
+require "log4r/MDC"

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,24 @@
+require 'test_helper'
+
+class TestGDC < TestCase
+  include Log4r
+
+  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,40 @@
+require 'test_helper'
+
+class TestMDC < TestCase
+  include Log4r
+
+  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,25 @@
+require 'test_helper'
+
+class TestNDC < TestCase
+  include Log4r
+
+  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/test_helper.rb

@@ -0,0 +1,12 @@
+$:.unshift(File.dirname(__FILE__))
+
+require "test/unit"
+require 'log4r'
+require 'log4r/configurator'
+require 'log4r/staticlogger'
+require 'log4r/formatter/log4jxmlformatter'
+require 'log4r/outputter/udpoutputter'
+require 'log4r/outputter/consoleoutputters'
+require 'log4r/yamlconfigurator'
+
+include Test::Unit

data/tests/testall.rb

@@ -0,0 +1,6 @@
+require 'test_helper'
+
+# 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,48 @@
+require 'test_helper'
+
+class TestBase < TestCase
+  include Log4r
+
+  # 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_raise(ArgumentError) {Log4rTools.validate_level(-1)}
+    assert_raise(ArgumentError) {Log4rTools.validate_level(LEVELS)}
+    assert_raise(ArgumentError) {Log4rTools.validate_level(String)}
+    assert_raise(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,42 @@
+require 'test_helper'
+
+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>

data/tests/testcustom.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+# tests the customization of Log4r levels
+class TestCustom < TestCase
+  include Log4r
+
+  def test_validation
+    assert_raise(TypeError) { Configurator.custom_levels "lowercase" }
+    assert_raise(TypeError) { Configurator.custom_levels "With space" }
+  end
+
+  def test_create
+    assert_nothing_raised { Configurator.custom_levels "Foo", "Bar", "Baz" }
+    assert_nothing_raised { Configurator.custom_levels }
+    assert_nothing_raised { Configurator.custom_levels "Bogus", "Levels" }
+  end
+#  def test_methods
+#    l = Logger.new 'custom1'
+#    assert_respond_to(l, :foo)
+#    assert_respond_to(l, :foo?)
+#    assert_respond_to(l, :bar)
+#    assert_respond_to(l, :bar?)
+#    assert_respond_to(l, :baz)
+#    assert_respond_to(l, :baz?)
+#    assert_nothing_raised { Bar }
+#    assert_nothing_raised { Baz }
+#    assert_nothing_raised { Foo }
+#  end
+
+end

data/tests/testformatter.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class TestFormatter < TestCase
+  include Log4r
+
+  def test_creation
+    assert_nothing_raised { Formatter.new.format(3) }
+    assert_nothing_raised { DefaultFormatter.new }
+    assert_kind_of(Formatter, DefaultFormatter.new)
+  end
+  def test_simple_formatter
+    sf = SimpleFormatter.new
+    f = Logger.new('simple formatter')
+    event = LogEvent.new(0, f, nil, "some data")
+    assert_match(sf.format(event), /simple formatter/)
+  end
+  def test_basic_formatter
+    b = BasicFormatter.new
+    f = Logger.new('fake formatter')
+    event = LogEvent.new(0, f, caller, "fake formatter")
+    event2 = LogEvent.new(0, f, nil, "fake formatter")
+    # this checks for tracing
+    assert_match(b.format(event), /in/)
+    assert_not_match(b.format(event2), /in/)
+    e = ArgumentError.new("argerror")
+    e.set_backtrace ['backtrace']
+    event3 = LogEvent.new(0, f, nil, e)
+    assert_match(b.format(event3), /ArgumentError/)
+    assert_match(b.format(LogEvent.new(0,f,nil,[1,2,3])), /Array/)
+  end
+end