log4r-color 1.1.11

data/lib/log4r.rb

@@ -0,0 +1,20 @@
+# :include: log4r/rdoc/log4r
+#
+# == Other Info
+#
+# Author::      Leon Torres
+# Version::     $Id$
+
+require "log4r/outputter/fileoutputter"
+require "log4r/outputter/consoleoutputters"
+require "log4r/outputter/staticoutputter"
+require "log4r/outputter/rollingfileoutputter"
+require "log4r/formatter/patternformatter"
+require "log4r/loggerfactory"
+require "log4r/GDC"
+require "log4r/NDC"
+require "log4r/MDC"
+
+module Log4r
+  Log4rVersion = [1, 1, 9].join '.'
+end

data/lib/log4r/GDC.rb

@@ -0,0 +1,41 @@
+# :include: rdoc/GDC
+#
+# == Other Info
+# 
+# Version:: $Id$
+# Author:: Colby Gutierrez-Kraybill <colby(at)astro.berkeley.edu>
+
+require 'monitor'
+
+module Log4r
+  GDCNAME = "log4rGDC"
+  $globalGDCLock = Monitor.new
+
+  # See log4r/GDC.rb
+  class GDC < Monitor
+    private_class_method :new
+
+    def self.clear()
+      Thread.main[GDCNAME] = ""
+    end
+
+    def self.get()
+      $globalGDCLock.synchronize do
+	if ( Thread.main[GDCNAME] == nil ) then
+	  Thread.main[GDCNAME] = $0
+	end
+      end
+      return Thread.main[GDCNAME]
+    end
+
+    def self.set( a_name )
+      if ( Thread.current != Thread.main ) then
+	raise "Can only initialize Global Diagnostic Context from Thread.main" 
+      end
+      $globalGDCLock.synchronize do
+	Thread.main[GDCNAME] = a_name
+      end
+    end
+  end
+end
+

data/lib/log4r/MDC.rb

@@ -0,0 +1,59 @@
+# :include: rdoc/MDC
+#
+# == Other Info
+# 
+# Version:: $Id$
+# Author:: Colby Gutierrez-Kraybill <colby(at)astro.berkeley.edu>
+
+require 'monitor'
+
+module Log4r
+  MDCNAME = "log4rMDC"
+  MDCNAMEMAXDEPTH = "log4rMDCMAXDEPTH"
+  $globalMDCLock = Monitor.new
+
+  # See log4r/MDC.rb
+  class MDC < Monitor
+    private_class_method :new
+
+    def self.check_thread_instance()
+      # need to interlock here, so that if
+      # another thread is entering this section
+      # of code before the main thread does,
+      # then the main thread copy of the MDC
+      # is setup before then attempting to clone
+      # it off
+      if ( Thread.current[MDCNAME] == nil ) then
+	$globalMDCLock.synchronize do 
+	  if ( Thread.main[MDCNAME] == nil ) then
+	    Thread.main[MDCNAME] = Hash.new
+	  end
+	  if ( Thread.current != Thread.main ) then
+	    Thread.current[MDCNAME] = Hash.new
+	    Thread.main[MDCNAME].each{ |k,v| Thread.current[MDCNAME][k] = v }
+	  end
+	end
+      end
+    end
+
+    def self.get( a_key )
+      self.check_thread_instance()
+      Thread.current[MDCNAME].fetch(a_key, "");
+    end
+
+    def self.get_context()
+      self.check_thread_instance()
+      return Thread.current[MDCNAME].clone
+    end
+
+    def self.put( a_key, a_value )
+      self.check_thread_instance()
+      Thread.current[MDCNAME][a_key] = a_value
+    end
+
+    def self.remove( a_key )
+      self.check_thread_instance()
+      Thread.current[MDCNAME].delete( a_key )
+    end
+  end
+end

data/lib/log4r/NDC.rb

@@ -0,0 +1,86 @@
+# :include: rdoc/NDC
+#
+# == Other Info
+# 
+# Version:: $Id$
+# Author:: Colby Gutierrez-Kraybill <colby(at)astro.berkeley.edu>
+
+module Log4r
+  NDCNAME = "log4rNDC"
+  NDCNAMEMAXDEPTH = "log4rNDCMAXDEPTH"
+  NDCDEFAULTMAXDEPTH = 256
+
+  # See log4r/NDC.rb
+  class NDC
+    private_class_method :new
+
+    def self.check_thread_instance()
+      if ( Thread.current[NDCNAME] == nil ) then
+	Thread.current[NDCNAME] = Array.new
+	Thread.current[NDCNAMEMAXDEPTH] = NDCDEFAULTMAXDEPTH
+      end
+    end
+
+    def self.clear()
+      self.check_thread_instance()
+      Thread.current[NDCNAME].clear
+    end
+
+    def self.clone_stack()
+      self.check_thread_instance()
+      return Thread.current[NDCNAME].clone
+    end
+
+    def self.get_depth()
+      self.check_thread_instance()
+      return Thread.current[NDCNAME].length
+    end
+
+    def self.inherit( a_stack )
+      if ( a_stack.class == Array ) then
+	if ( Thread.current[NDCNAME] != nil ) then
+	  Thread.current[NDCNAME].clear
+	  Thread.current[NDCNAME] = nil
+	end
+	Thread.current[NDCNAME] = a_stack
+      else
+	raise "Expecting Array in NDC.inherit"
+      end
+    end
+
+    def self.get()
+      self.check_thread_instance
+      return Thread.current[NDCNAME] * " "
+    end
+
+    def self.peek()
+      self.check_thread_instance()
+      return Thread.current[NDCNAME].last
+    end
+
+    def self.pop()
+      self.check_thread_instance()
+      return Thread.current[NDCNAME].pop
+    end
+
+    def self.push( value )
+      self.check_thread_instance()
+      if ( Thread.current[NDCNAME].length < Thread.current[NDCNAMEMAXDEPTH] ) then
+	Thread.current[NDCNAME].push( value )
+      end
+    end
+
+    def self.remove()
+      self.check_thread_instance()
+      Thread.current[NDCNAME].clear
+      Thread.current[NDCNAMEMAXDEPTH] = nil
+      Thread.current[NDCNAME] = nil
+    end
+
+    def self.set_max_depth( max_depth )
+      self.check_thread_instance()
+      Thread.current[NDCNAMEMAXDEPTH] = max_depth
+    end
+  end
+end
+

data/lib/log4r/base.rb

@@ -0,0 +1,90 @@
+# :nodoc:
+require "log4r/config"
+
+module Log4r
+  ALL = 0
+  LNAMES = ['ALL']
+
+  # Defines the log levels of the Log4r module at runtime. It is given
+  # either the default level spec (when root logger is created) or the
+  # user-specified level spec (when Logger.custom_levels is called).
+  #
+  # The last constant defined by this method is OFF. Other level-sensitive 
+  # parts of the code check to see if OFF is defined before deciding what 
+  # to do. The typical action would be to force the creation of RootLogger 
+  # so that the custom levels get loaded and business can proceed as usual.
+  #
+  # For purposes of formatting, a constant named MaxLevelLength is defined
+  # in this method. It stores the max level name string size.
+
+  def Log4r.define_levels(*levels) #:nodoc:
+    return if const_defined? :OFF
+    for i in 0...levels.size
+      name = levels[i].to_s
+      module_eval "#{name} = #{i} + 1; LNAMES.push '#{name}'"
+    end
+    module_eval %{
+      LNAMES.push 'OFF'
+      LEVELS = LNAMES.size
+      OFF = LEVELS - 1
+      MaxLevelLength = Log4rTools.max_level_str_size
+    }
+  end
+
+  # Some common functions 
+  class Log4rTools
+    # Raises ArgumentError if level argument is an invalid level. Depth
+    # specifies how many trace entries to remove.
+    def self.validate_level(level, depth=0)
+      unless valid_level?(level)
+        raise ArgumentError, "Log level must be in 0..#{LEVELS}",
+              caller[1..-(depth + 1)]
+      end
+    end
+    
+    def self.valid_level?(lev)
+      not lev.nil? and lev.kind_of?(Numeric) and lev >= ALL and lev <= OFF
+    end
+    
+    def self.max_level_str_size #:nodoc:
+      size = 0
+      LNAMES.each {|i| size = i.length if i.length > size}
+      size
+    end
+
+    def self.validate_colors(colors)      
+      raise ArgumentError, "Colors option must consist of a hash where each key is the log level to define a color scheme for" if !colors.kind_of? Hash
+      invalid_levels = colors.keys.reject {|level| valid_levels.include? level}
+      if !invalid_levels.empty?
+        raise ArgumentError, "Color schemes can not be defined for these invalid log levels: #{invalid_levels.join(', ')}"
+      end
+    end
+
+    def self.level_key level 
+      valid_levels[level]
+    end
+
+    def self.valid_levels
+      [:debug, :info, :debug, :warn, :error, :fatal]
+    end
+  
+    # Shortcut for decoding 'true', 'false', true, false or nil into a bool
+    # from a hash parameter. E.g., it looks for true/false values for
+    # the keys 'symbol' and :symbol.
+
+    def self.decode_bool(hash, symbol, default)
+      data = hash[symbol]
+      data = hash[symbol.to_s] if data.nil?
+      return case data
+        when 'true',true then true
+        when 'false',false then false
+        else default
+        end
+    end
+
+    # Splits comma-delimited lists with arbitrary \s padding
+    def self.comma_split(string)
+      string.split(/\s*,\s*/).collect {|s| s.strip}
+    end
+  end
+end

data/lib/log4r/config.rb

@@ -0,0 +1,9 @@
+# :nodoc:
+# Version:: $Id$
+
+module Log4r
+  module Log4rConfig #:nodoc:
+    LogLevels = ['DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL']
+    LoggerPathDelimiter = '::'
+  end    
+end

data/lib/log4r/configurator.rb

@@ -0,0 +1,224 @@
+# :include: rdoc/configurator
+#
+# == Other Info
+#
+# Version:: $Id$
+
+require "log4r/logger"
+require "log4r/outputter/staticoutputter"
+require "log4r/lib/xmlloader"
+require "log4r/logserver"
+require "log4r/outputter/remoteoutputter"
+
+# TODO: catch unparsed parameters #{FOO} and die
+module Log4r
+  # Gets raised when Configurator encounters bad XML.
+  class ConfigError < Exception
+  end
+
+  # See log4r/configurator.rb
+  class Configurator
+    include REXML if HAVE_REXML
+    @@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
+
+    # Sets the custom levels. This method accepts symbols or strings.
+    #
+    #   Configurator.custom_levels('My', 'Custom', :Levels)
+    #
+    # Alternatively, you can specify custom levels in XML:
+    # 
+    #   <log4r_config>
+    #     <pre_config>
+    #       <custom_levels>
+    #         My, Custom, Levels
+    #       </custom_levels>
+    #       ...
+
+    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 XML configuration for Log4r.
+    def self.load_xml_file(filename)
+      detect_rexml
+      actual_load Document.new(File.new(filename))
+    end
+
+    # You can load a String XML configuration instead of a file.
+    def self.load_xml_string(string)
+      detect_rexml
+      actual_load Document.new(string)
+    end
+
+    #######
+    private
+    #######
+
+    def self.detect_rexml
+      unless HAVE_REXML
+        raise LoadError,
+        "Need REXML to load XML configuration", caller[1..-1]
+      end
+    end
+
+    def self.actual_load(doc)
+      confignode = doc.elements['//log4r_config']
+      if confignode.nil?
+        raise ConfigError, 
+        "<log4r_config> element not defined", caller[1..-1]
+      end
+      decode_xml(confignode)
+    end
+    
+    def self.decode_xml(doc)
+      decode_pre_config(doc.elements['pre_config'])
+      doc.elements.each('outputter') {|e| decode_outputter(e)}
+      doc.elements.each('logger') {|e| decode_logger(e)}
+      doc.elements.each('logserver') {|e| decode_logserver(e)}
+    end
+
+    def self.decode_pre_config(e)
+      return Logger.root if e.nil?
+      decode_custom_levels(e.elements['custom_levels'])
+      global_config(e.elements['global'])
+      global_config(e.elements['root'])
+      decode_parameters(e.elements['parameters'])
+      e.elements.each('parameter') {|p| decode_parameter(p)}
+    end
+
+    def self.decode_custom_levels(e)
+      return Logger.root if e.nil? or e.text.nil?
+      begin custom_levels *Log4rTools.comma_split(e.text)
+      rescue TypeError => te
+        raise ConfigError, te.message, caller[1..-4]
+      end
+    end
+    
+    def self.global_config(e)
+      return if e.nil?
+      globlev = e.value_of '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(e)
+      e.elements.each{|p| @@params[p.name] = p.text} unless e.nil?
+    end
+
+    def self.decode_parameter(e)
+      @@params[e.value_of('name')] = e.value_of 'value'
+    end
+
+    def self.decode_outputter(e)
+      # fields
+      name = e.value_of 'name'
+      type = e.value_of 'type'
+      level = e.value_of 'level'
+      only_at = e.value_of '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 Log4rTools.comma_split(only_at)
+          alev = LNAMES.index(lev)
+          Log4rTools.validate_level(alev, 3)
+          only_levels.push alev
+        end
+      end
+      formatter = decode_formatter(e.elements['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(e)
+      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(e)
+      return nil if e.nil?
+      type = e.value_of 'type' 
+      raise ConfigError, "Formatter missing type", caller[1..-4] if type.nil?
+      buff = "#{type}.new " + decode_hash_params(e).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}
+
+    # Does the fancy parameter to hash argument transformation
+    def self.decode_hash_params(e)
+      buff = []
+      e.attributes.each_attribute {|p| 
+        next if ExcludeParams.include? p.name
+        buff << ":" + p.name + "=>" + paramsub(p.value)
+      }
+      e.elements.each {|p| 
+        next if ExcludeParams.include? p.name
+        buff << ":" + p.name + "=>" + paramsub(p.text)
+      }
+      buff
+    end
+    
+    # Substitues any #{foo} in the XML with Parameter['foo']
+    def self.paramsub(str)
+      return nil if str.nil?
+      @@params.each {|param, value| str.sub! '#{'+param+'}', value}
+      "'" + str + "'"
+    end
+
+    def self.decode_logger(e)
+      l = Logger.new e.value_of('name')
+      decode_logger_common(l, e)
+    end
+
+    def self.decode_logserver(e)
+      return unless HAVE_REXML
+      name = e.value_of 'name'
+      uri = e.value_of 'uri'
+      l = LogServer.new name, uri
+      decode_logger_common(l, e)
+    end
+
+    def self.decode_logger_common(l, e)
+      level = e.value_of 'level'
+      additive = e.value_of 'additive'
+      trace = e.value_of '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 = e.value_of 'outputters'
+      Log4rTools.comma_split(outs).each {|n| l.add n.strip} unless outs.nil?
+      e.elements.each('outputter') {|e|
+        name = (e.value_of 'name' or e.text)
+        l.add Outputter[name]
+      }
+    end
+  end
+end