log4r 1.1.2 → 1.1.3

data/src/log4r/outputter/rollingfileoutputter.rb

@@ -1,6 +1,6 @@
 
 # :nodoc:
-# Version:: $Id: rollingfileoutputter.rb,v 1.1.1.1 2004/03/19 03:31:10 fando Exp $
+# Version:: $Id: rollingfileoutputter.rb,v 1.2 2009/09/29 18:13:13 colbygk Exp $
 
 require "log4r/outputter/fileoutputter"
 require "log4r/staticlogger"
@@ -18,7 +18,7 @@ module Log4r
 
     def initialize(_name, hash={})
       @count = 0
-      super(_name, hash)
+      super( _name, hash.merge({:create => false}) )
       if hash.has_key?(:maxsize) || hash.has_key?('maxsize') 
         _maxsize = (hash[:maxsize] or hash['maxsize']).to_i
         if _maxsize.class != Fixnum
@@ -85,7 +85,12 @@ module Log4r
     # roll the file
     def roll
       begin
-        @out.close
+	# If @baseFilename == @filename, then this method is about to
+	# try to close out a file that is not actually opened because
+	# fileoutputter has been called with the parameter roll=true
+	if ( @baseFilename != @filename ) then
+	  @out.close
+	end
       rescue 
         Logger.log_internal {
           "RollingFileOutputter '#{@name}' could not close #{@filename}"

data/src/log4r/outputter/win32eventoutputter.rb

@@ -0,0 +1,136 @@
+# :include: ../rdoc/win32eventoutputter
+#
+# Version:: $Id: syslogoutputter.rb,v 1.5 2009/09/25 20:33:33 colbygk Exp $
+# Author:: Colby Gutierrez-Kraybill
+# 
+# NOTE: THIS IS A DEVELOPMENT VERSION AND IS NOT READY FOR USE
+# INFACT, IT MAY NEVER BE READY FOR USE, AS TRYING TO INTERACT
+# WITH THE WIN32 EVENTLOG API REQUIRES USER INTERVENTION TO LOOKUP
+# event_id AND category CODES THAT THIS LIBRARY CANNOT KNOW A PRIORI
+#
+# I have added this to the cvs tree to keep as a work in flight
+# It is presently UNUSABLE
+#
+
+require 'log4r/formatter/formatter'
+require 'log4r/outputter/outputter'
+require 'log4r/configurator'
+require 'win32/eventlog'
+
+module Log4r
+  include Win32
+
+  class Win32EventLogOutputter < Outputter
+
+    # maps default log4r levels to win32 event priorities
+    # (logevents never see ALL and OFF)
+    # WIN32EVENTLOG Levels are:
+    #  "SUCCESS"       => EVENTLOG_SUCCESS
+    #  "AUDIT_SUCCESS" => AUDIT_SUCCESS 
+    #  "INFO"          => EVENTLOG_INFO 
+    #  "WARN"          => EVENTLOG_WARN 
+    #  "ERROR"         => EVENTLOG_ERROR
+    #  "AUDIT_FAILURE" => AUDIT_FAILURE 
+    WIN32EVENTLOG_LEVELS_MAP = {
+      "SUCCESS"       => EVENTLOG_SUCCESS, 
+      "AUDIT_SUCCESS" => AUDIT_SUCCESS, 
+      "INFO"          => EVENTLOG_INFO, 
+      "WARN"          => EVENTLOG_WARN, 
+      "ERROR"         => EVENTLOG_ERROR, 
+      "AUDIT_FAILURE" => AUDIT_FAILURE 
+    }
+
+    # mapping from Log4r default levels to win32 eventlog, by string name
+    #  "DEBUG"  => "INFO"   # by default DEBUG is not in win32 eventlog
+    #  "INFO"   => "INFO" 
+    #  "WARN"   => "WARN"
+    #  "ERROR"  => "ERROR" 
+    #  "FATAL"  => "ERROR"  # by default FATAL is not in win32 eventlog
+    #  "SUCCESS" => "SUCCESS"  # by default SUCCESS is not in log4r
+    #  "AUDIT_SUCCESS"  => "AUDIT_SUCCESS"  # by default AUDIT_SUCCESS is not in log4r
+    #  "AUDIT_FAILURE"  => "AUDIT_FAILURE"   # by default AUDIT_FATAL is not in log4r
+    WIN32EVENTLOG_LOG4R_MAP = {
+      "DEBUG"  => "INFO",
+      "INFO"   => "INFO", 
+      "WARN"   => "WARN",
+      "ERROR"  => "ERROR", 
+      "FATAL"  => "ERROR",
+      "SUCCESS" => "SUCCESS",
+      "AUDIT_SUCCESS"  => "AUDIT_SUCCESS",
+      "AUDIT_FAILURE"  => "AUDIT_FAILURE"
+    }
+
+    @levels_map = WIN32EVENTLOG_LOG4R_MAP
+
+    # There are 3 hash arguments
+    #
+    # [<tt>:registry_source</tt>]   eventlog registry source, defaults to "Application"
+    # [<tt>:source</tt>]    eventlog source, defaults to _name
+    def initialize(_name, hash={})
+      super(_name, hash)
+      registry_source = (hash[:registry_source] or hash['registry_source'] or "Application")
+      @source = (hash[:source] or hash['source'] or _name)
+      logopt = (hash[:logopt] or hash['logopt'] or LOG_PID | LOG_CONS).to_i
+      facility = (hash[:facility] or hash['facility'] or LOG_USER).to_i
+      map_levels_by_name_to_eventlog()
+      if ( Syslog.opened? ) then
+	Logger.log_internal { "Syslog already initialized, to alter, " +
+	  "you must close first"}
+      end
+      # @syslog = ( Syslog.opened? ) ? Syslog : Syslog.open(ident, logopt, facility)
+    end
+
+    def closed?
+      return true # !@syslog.opened?
+    end
+
+    def close
+      #@syslog.close unless @syslog.nil?
+      #@level = OFF
+      OutputterFactory.create_methods(self)
+      Logger.log_internal {"Outputter '#{@name}' closed Syslog and set to OFF"}
+    end
+
+    # A single hash argument that maps custom names to eventlog names
+    # 
+    # [<tt>levels_map</tt>]	A map that will create a linkage between levels
+    # 				in a hash and underlying eventlog levels.
+    # 				By default, these are direct mapping of the log4r
+    # 				levels (e.g. "DEBUG" => "DEBUG")
+    # 				If you have defined your own custom levels, you
+    # 				should provide this underlying mapping, otherwise
+    # 				all messages will be mapped to the underlying eventlog
+    # 				level of INFO by default.
+    # 				e.g.
+    # 				You have created custom levels called:
+    # 				<tt>Configurator.custom_levels "HIGH", "MEDIUM", "LOW"</tt>
+    # 				To map these to 'equivilent' eventlog levels, after instantiatin
+    # 				a eventlogoutputter:
+    # 				<tt>EventLogOutputter.map_levels_by_name_to_eventlog(
+    # 				{ "HIGH" => "ALERT", "MEDIUM" => "WARN", "LOW" => "INFO" }
+    # 				)</tt>
+    def map_levels_by_name_to_eventlog( lmap = WIN32EVENTLOG_LOG4R_MAP )
+      @levels_map = lmap
+    end
+
+    def get_levels_map()
+      return @levels_map
+    end
+
+    private
+
+    def canonical_log(logevent)
+      pri = SYSLOG_LEVELS_MAP[@levels_map[LNAMES[logevent.level]]] rescue pri = LOG_INFO
+      o = format(logevent)
+      if o.kind_of? Exception then
+	msg = "#{o.class} at (#{o.backtrace[0]}): #{o.message}"
+      elsif o.respond_to? :to_str then
+	msg = o.to_str
+      else
+	msg = o.inspect
+      end
+
+      # @syslog.log(pri, '%s', msg)
+    end
+  end
+end

data/src/log4r/rdoc/GDC

@@ -0,0 +1,14 @@
+= GDC
+
+The GDC class implements a copy of the Global Diagnostic Context, which
+is not part of the Apache Log4j library, as of this writing (10 Jan 2009).
+
+The GDC is like the NDC and MDC classes, only it is global to the
+application (see NDC and MDC for details on those classes).
+
+The GDC is local to the main thread, and any new threads will return
+the value of the current GDC set in the main thread.
+
+Only the main thread can set the GDC, any other threads that
+attempt to will raise an exception.
+

data/src/log4r/rdoc/MDC

@@ -0,0 +1,16 @@
+= MDC
+
+The MDC class implements a copy of the Mapped Diagnostic Context, which
+is part of the Apache Log4j library.  See the NDC documentation for
+more details.  MDCs are much like NDCs, but instead of a stack context
+it uses a map for holding this information.
+
+This allows for selection of information out of the map when
+the log message is being created.
+
+MDCs are thread safe, and are unique to each thread.
+
+An important difference between MDCs in Log4r vs Log4j is that they
+only inherit from the main thread.  Ruby treats all new threads as
+being the children of the main thread, even if they are started
+from a thread that is not main.

data/src/log4r/rdoc/NDC

@@ -0,0 +1,41 @@
+= NDC
+
+The NDC class implements a copy of the Nested Diagnostic Context, which
+is part of the Apache Log4j library.  Nested Diagnostic Contexts were
+derived from Neil Harrison's article on "Patterns for Logging
+Diagnostic Messages", part of the book "Pattern Languages of Program
+Design 3" edited by Martin et al.
+
+NDCs in Log4r are thread safe.
+
+NDCs in log4r are close enough to NDCs in Log4j that I include its
+documentation directly:
+
+...
+A Nested Diagnostic Context, or NDC in short, is an instrument to
+distinguish interleaved log output from different sources. Log output
+is typically interleaved when a server handles multiple clients
+near-simultaneously.
+
+Interleaved log output can still be meaningful if each log entry from
+different contexts had a distinctive stamp. This is where NDCs come into
+play.
+
+Note that NDCs are managed on a per thread basis. NDC operations such as
+push, pop(), clear(), getDepth() and setMaxDepth(int) affect the NDC of
+the current thread only. NDCs of other threads remain unaffected.
+...
+
+An important difference between NDCs in Log4r vs Log4j is that you
+do not have to called NDC.remove() when exiting a thread.
+
+This class will automatically create Thread specific storage for the 
+current thread on the first call to any of its methods, i.e.
+
+  NDC.push( "client accept" );
+
+New threads may inherit the NDC of the parent thread by making use of
+the clone_stack() and inherit() methods.  By default, the NDC is not
+inherited automatically.  This is unlike MDCs, which will inherit from
+the main thread.
+

data/src/log4r/rdoc/win32eventoutputter

@@ -0,0 +1,7 @@
+= Win32EventOutputter
+
+THIS IS A DEVELOPMENT VERSION AND IS NOT READY FOR USE
+INFACT, IT MAY NEVER BE READY FOR USE, AS TRYING TO INTERACT
+WITH THE WIN32 EVENTLOG API REQUIRES USER INTERVENTION TO LOOKUP
+event_id AND category CODES THAT THIS LIBRARY CANNOT KNOW A PRIORI
+

data/src/log4r/repository.rb

@@ -1,65 +1,86 @@
 # :nodoc:
-# Version:: $Id: repository.rb,v 1.1.1.1 2004/03/19 03:31:07 fando Exp $
+# Version:: $Id: repository.rb,v 1.2 2009/09/29 02:34:05 colbygk Exp $
+#
+# 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 "singleton"
 
 module Log4r
-class Logger
+  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:
-    include Singleton
-    attr_reader :loggers
-    
-    def initialize
-      @loggers = Hash.new
-    end
+    # 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.
 
-    def self.[](fullname)
-      instance.loggers[fullname]
-    end
+    class Repository # :nodoc:
+      include Singleton
+      attr_reader :loggers
 
-    def self.[]=(fullname, logger)
-      instance.loggers[fullname] = logger
-    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
-      for fullname, logger in instance.loggers
-        yield logger if parent.is_root? || fullname =~ /#{daddy}/
+      def initialize
+	@loggers = Hash.new
       end
-    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)
-      for fullname, logger in instance.loggers
-        next if logger.is_root?
-        logger.parent = parent if logger.path =~ /^#{parent.fullname}$/
+      def self.[](fullname)
+	Thread.exclusive do
+	  instance.loggers[fullname]
+	end # exclusive
       end
-    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
-      while arr.size > 0 do
-        logger = Repository[arr.join(Log4rConfig::LoggerPathDelimiter)]
-        break unless logger.nil?
-        arr.pop
+
+      def self.[]=(fullname, logger)
+	Thread.exclusive 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
+	Thread.exclusive 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)
+	Thread.exclusive 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
+	Thread.exclusive do
+	  while arr.size > 0 do
+	    logger = Repository[arr.join(Log4rConfig::LoggerPathDelimiter)]
+	    break unless logger.nil?
+	    arr.pop
+	  end
+	end # exclusive
+	logger
       end
-      logger
-    end
 
-  end
-end
-end
+    end # class Repository
+  end # class Logger
+end # Module Log4r
+

data/tests/testGDC.rb

@@ -0,0 +1,26 @@
+$: << File.join("..","src")
+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,21 @@
+$: << File.join("..","src")
+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
+end

data/tests/testNDC.rb

@@ -0,0 +1,27 @@
+$: << File.join("..","src")
+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