revolutionhealth-log4r 2.0.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007, 2008 Revolution Health
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,37 @@
+log4r
+=====
+
+Original manual provided here: http://log4r.sourceforge.net/
+
+== Enhancements
+
+We have added support for an Nested Diagnostic Context, or NDC and GDC.
+	
+=== NDC
+
+NDCs are per thread, and can be set by:
+
+Log4r::Logger::NDC.push('something')
+
+Then in the configuration xml it can be used:
+
+pattern="%x"
+
+Which will output the top most diagnostic message on the NDC stack.
+
+Based on the log4j NDC implementation: http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/NDC.html
+
+=== GDC
+
+We also added a Global Diagnostic Context for per application diagnostic messages.
+
+Log4r::Logger.GDC = "app1"
+
+Then in the configuration xml it can be used:
+
+pattern="%g"
+
+log4_logging.rb uses this to set the message to be the name of the rails application.  
+This can be useful for sorting messages if logs for multiple applications are aggregated at a single point, 
+for example in something like Splunk.
+

data/Rakefile

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+require 'fileutils'
+
+GEM = "log4r"
+GEM_VERSION = "2.0.0"
+AUTHOR = "Revolution Health"
+EMAIL = "rails-trunk@revolutionhealth.com"
+HOMEPAGE = %q{http://github.com/revolutionhealth/log4r/tree/master}
+SUMMARY = "Updated version of Log4r"
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = false
+  s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  
+  # Uncomment this to add a dependency
+  # s.add_dependency "foo"
+  
+  s.require_path = 'lib'
+  s.autorequire = GEM
+  s.files = %w(LICENSE README Rakefile TODO log4r_original_LICENSE) + Dir.glob("{lib,specs,test,config}/**/*")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+require 'test/unit'
+ 
+task :test do
+ FileUtils.mkdir(File.join(File.dirname(__FILE__), %w[log])) if !File.exists?(File.join(File.dirname(__FILE__), %w[log]))
+ FileUtils.rm(Dir.glob(File.join(File.dirname(__FILE__), %w[log *])))
+ runner = Test::Unit::AutoRunner.new(true)
+ runner.to_run << 'test'
+ runner.pattern = [/_test.rb$/]
+ exit if !runner.run
+end
+ 
+task :default => [:test, :package] do
+end

data/TODO

@@ -0,0 +1,4 @@
+TODO:
+Fix LICENSE with your name
+Fix Rakefile with your name and contact info
+Add your code to lib/<%= name %>.rb

data/config/log4r.xml

@@ -0,0 +1,59 @@
+<log4r_config>
+  <pre_config>
+    <global level="DEBUG"/>
+    <parameter name="log_pattern" value="[%5.5l] [%d] [%g] %m"/>
+  </pre_config>
+
+  <outputter name="env_file_log" type="RollingFileOutputter" maxsize="100MB" level="DEBUG" filename="#{RAILS_ROOT}/log/#{RAILS_ENV}.log" trunc="false" maxBackupIndex="2">
+    <formatter type="PatternFormatter" pattern="[%5.5l] [%d] [%g] %m"/>
+  </outputter>
+  
+  <outputter name="console" type="StdoutOutputter" level="DEBUG">
+    <formatter type="PatternFormatter" pattern="[%5.5l] [%d] [%g] %m"/>
+  </outputter>
+    
+  <outputter name="syslog" type="SyslogOutputter" level="DEBUG" facility="LOG_LOCAL0" ident="rails">
+    <formatter type="PatternFormatter" pattern="[%5.5l] [%g] %m"/>  <!-- syslog already has datetime, so dont need in message format -->
+  </outputter> 
+  
+  <logger name="development" level="DEBUG" outputters="env_file_log"/>
+  <logger name="test"        level="DEBUG" outputters="env_file_log"/>
+  <logger name="production"  level="DEBUG" outputters="env_file_log,syslog"/> 
+  
+  <!-- db -->
+  <outputter name="db_env_file_log" type="RollingFileOutputter" maxsize="100MB" level="DEBUG" filename="#{RAILS_ROOT}/log/#{RAILS_ENV}_database.log" trunc="false" maxBackupIndex="2">
+    <formatter type="PatternFormatter" pattern="[%5.5l] [%d] [%g] %m"/>
+  </outputter>
+  
+  <logger name="development_db" level="DEBUG" outputters="db_env_file_log"/>
+  <logger name="test_db"        level="DEBUG" outputters="db_env_file_log"/>
+  <logger name="production_db"  level="ERROR" outputters="db_env_file_log"/> 
+  
+  <!-- ares -->
+  <outputter name="ares_env_file_log" type="FileOutputter" level="DEBUG" filename="#{RAILS_ROOT}/log/#{RAILS_ENV}_ares.log" trunc="false" >
+    <formatter type="PatternFormatter" pattern="[%5.5l] [%d] [%g] %m"/>
+  </outputter>
+  
+  <logger name="development_ares" level="DEBUG" outputters="ares_env_file_log"/>
+  <logger name="test_ares"        level="DEBUG" outputters="ares_env_file_log"/>
+  <logger name="production_ares"  level="ERROR" outputters="ares_env_file_log"/> 
+  
+  <!-- mailer -->
+  <outputter name="mailer_env_file_log" type="RollingFileOutputter" maxsize="100MB" level="DEBUG" filename="#{RAILS_ROOT}/log/#{RAILS_ENV}_mailer.log" trunc="false" maxBackupIndex="2">
+    <formatter type="PatternFormatter" pattern="[%5.5l] [%d] [%g] %m"/>
+  </outputter>
+  
+  <logger name="development_mailer" level="DEBUG" outputters="mailer_env_file_log"/>
+  <logger name="test_mailer"        level="DEBUG" outputters="mailer_env_file_log"/>
+  <logger name="production_mailer"  level="ERROR" outputters="mailer_env_file_log"/> 
+  
+  <!-- metrics -->
+  <outputter name="metrics_env_file_log" type="RollingFileOutputter" maxsize="100MB" level="DEBUG" filename="#{RAILS_ROOT}/log/#{RAILS_ENV}_metrics.log" trunc="false" maxBackupIndex="2">
+    <formatter type="PatternFormatter" pattern="[%5.5l] [%d] [%g] %m"/>
+  </outputter>
+  
+  <logger name="development_metrics" level="DEBUG" outputters="metrics_env_file_log"/>
+  <logger name="test_metrics"        level="DEBUG" outputters="metrics_env_file_log"/>
+  <logger name="production_metrics"  level="INFO" outputters="metrics_env_file_log"/> 
+  
+</log4r_config> 

data/lib/log4r.rb

@@ -0,0 +1,29 @@
+# :include: log4r/rdoc/log4r
+#
+# == Other Info
+#
+# Author::      Leon Torres
+# Version::     $Id: log4r.rb,v 1.10 2002/08/20 04:15:04 cepheus Exp $
+
+require 'log4r/configurator'
+require 'log4r/formatter/formatter'
+require "log4r/formatter/patternformatter"
+require "log4r/outputter/fileoutputter"
+require "log4r/outputter/consoleoutputters"
+require "log4r/outputter/staticoutputter"
+require "log4r/outputter/rollingfileoutputter"
+require "log4r/outputter/syslogoutputter"
+require "log4r/loggerfactory"
+require "test/log_sql_per_test.rb"
+
+module Log4r
+  Log4rVersion = [2, 0, 0].join '.'
+end
+
+if defined?(Rails)
+  if Rails::VERSION::MAJOR < 2
+    require 'rails_patch_for_migrations'
+  end
+
+  require 'log4r_logging'
+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: config.rb,v 1.9 2002/01/28 16:05:04 cepheus Exp $
+
+module Log4r
+  module Log4rConfig #:nodoc:
+    LogLevels = ['DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL']
+    LoggerPathDelimiter = '::'
+  end    
+end

data/lib/log4r/configurator.rb

@@ -0,0 +1,229 @@
+# :include: rdoc/configurator
+#
+# == Other Info
+#
+# Version:: $Id: configurator.rb,v 1.12 2004/03/17 19:13:07 fando Exp $
+
+require "log4r/logger"
+require "log4r/outputter/staticoutputter"
+require "log4r/lib/xmlloader"
+require "log4r/logserver"
+require "log4r/outputter/remoteoutputter"
+require "log4r/outputter/fileoutputter"
+require "log4r/outputter/fileoutputter"
+require "log4r/outputter/consoleoutputters"
+require "log4r/formatter/formatter"
+require "log4r/formatter/patternformatter"
+
+# 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