log4rails 1.1.11

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7fed18812138b6e4049cdde81a06f54d2c0e17f4
+  data.tar.gz: f83b7d97ecd7d1a0a97b990454b1062544b9abf8
+SHA512:
+  metadata.gz: 84e32f8e38727c3eb481f3e34aa844c2fcda0bc20c1a1251803d54a9e78e34ab6558440a156516be3464e54c427d03114407c93c4d4fdaf516d1427fb9aca8ac
+  data.tar.gz: aa9d042d2dd722afe2c4c6d27184656b4235d420a7143e9293a5bb2a0819d018b507b45fcfb3804ac8af61cb4bfa1382d0340d75124f0a511b70b359c633b222

data/LICENSE.bsd

@@ -0,0 +1,12 @@
+Copyright (c) 2014, Colby Gutierrez-Kraybill, bestmike007.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+  3. Neither the name of ShrewdRaven Inc nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,37 @@
+Log4r - A flexible logging library for Ruby
+Log4rails - A better log4r especially for rails
+
+```
+gem install log4rails
+```
+
+DO NOT USE THIS TOGETHER WITH `log4r`!
+
+``` ruby
+config.log4rails.<option> = <value>
+# enable log4rails integration
+config.log4rails.enabled = true
+# maximum action handling time to log with level INFO, default: 500ms.
+config.log4rails.action_mht = 500
+# auto-reload log4r configuration file from config/log4r.yaml (or config/log4r-production.yaml in production environment)
+config.log4rails.auto_reload = true
+```
+
+## Why this fork
+
+Log4r seems not to be actively maintained. And also I need these features:
+
++ Integrate with the latest rails
++ Reload the configuration file in production mode in order to switch ON/OFF logs
++ Better RollingFileOutputter, etc.
+
+## TODO
+
++ Better integrate with rails
++ Write more tests
++ Document is important, especially since rubyforge is dead
++ Refactor
++ Fix issues for general usage
++ Improve extensibility
+
+You're welcome to contribute!

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,74 @@
+# :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
+  
+    # 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