log4r 1.1.9 → 1.1.10

data/examples/yaml.rb

@@ -6,9 +6,9 @@ require 'log4r/yamlconfigurator'
 # we use various outputters, so require them, otherwise config chokes
 require 'log4r/outputter/datefileoutputter'
 require 'log4r/outputter/emailoutputter'
-include Log4r
+require 'log4r/outputter/scribeoutputter'
 
-cfg = YamlConfigurator # shorthand
+cfg = Log4r::YamlConfigurator # shorthand
 cfg['HOME'] = '.'      # the only parameter in the YAML, our HOME directory
 
 # load the YAML file with this
@@ -25,6 +25,6 @@ def do_logging(log)
 end
 
 # turn off the email outputter
-Outputter['email'].level = OFF
+Log4r::Outputter['email'].level = Log4r::OFF
 # the other two outputters log to stderr and a timestamped file in ./logs
-do_logging( Logger['mylogger'])
+do_logging( Log4r::Logger['mylogger'])

data/lib/log4r.rb

@@ -5,6 +5,7 @@
 # Author::      Leon Torres
 # Version::     $Id$
 
+require 'log4r/version'
 require "log4r/outputter/fileoutputter"
 require "log4r/outputter/consoleoutputters"
 require "log4r/outputter/staticoutputter"
@@ -14,7 +15,3 @@ require "log4r/loggerfactory"
 require "log4r/GDC"
 require "log4r/NDC"
 require "log4r/MDC"
-
-module Log4r
-  Log4rVersion = [1, 1, 9].join '.'
-end

data/lib/log4r/formatter/formatter.rb

@@ -70,7 +70,7 @@ module Log4r
     def format_object(obj)
       if obj.kind_of? Exception
         return "Caught #{obj.class}: #{obj.message}\n\t" +\
-               obj.backtrace[0...@depth].join("\n\t")
+               (obj.backtrace.nil? ? [] : obj.backtrace[0...@depth]).join("\n\t")
       elsif obj.kind_of? String
         return obj
       else # inspect the object

data/lib/log4r/formatter/log4jxmlformatter.rb

@@ -1,4 +1,4 @@
-# INCLUDE TODO ../rdoc/log4jxmlformatter
+# :include: ../rdoc/log4jxmlformatter
 #
 # == Other Info
 #
@@ -7,7 +7,11 @@
 require "log4r/formatter/formatter"
 
 require "rubygems"
-require "builder"
+begin
+  require "builder"
+rescue LoadError
+  puts "builder gem is required to use log4jxmlformatter, i.e. gem install builder"
+end
 
 module Log4r
 

data/lib/log4r/outputter/fileoutputter.rb

@@ -40,7 +40,7 @@ module Log4r
 
       @filename = _filename
       if ( @create == true ) then
-	@out = File.new(@filename, (@trunc ? "w" : "a")) 
+	@out = File.new(@filename, (@trunc ? "wb" : "ab")) 
 	Logger.log_internal {
 	  "FileOutputter '#{@name}' writing to #{@filename}"
 	}

data/lib/log4r/outputter/scribeoutputter.rb

@@ -0,0 +1,37 @@
+# :nodoc:
+# Version:: $Id$
+
+require "log4r/outputter/outputter"
+require "rubygems"
+require "scribe"
+
+module Log4r
+  class ScribeOutputter < Outputter
+    attr_reader :host, :port, :category
+
+    def initialize(_name, hash={})
+      super(_name, hash)
+      @host = (hash[:host] or hash[:host] or 'localhost')
+      @port = (hash[:port] or hash[:port] or '1463')
+      @category = (hash[:category] or hash[:category] or 'default')
+
+      @client = Scribe.new("#{@host}:#{@port}", category=@category, add_newlines=false)
+    end
+
+    private
+
+    def write(data)
+      begin
+        @client.log(data.strip, @category)
+      rescue ScribeThrift::Client::TransportException => e
+        Logger.log_internal(-2) {
+          "Caught TransportException, is the scribe server alive?"
+        }
+      rescue ThriftClient::NoServersAvailable => e
+        Logger.log_internal(-2) {
+          "No scribe servers are available!"
+        }
+      end
+    end
+  end
+end

data/lib/log4r/outputter/udpoutputter.rb

@@ -17,8 +17,8 @@ module Log4r
      
     def initialize(_name, hash={})
       super(_name, hash)
-      @host = hash[:hostname]
-      @port = hash[:port]
+      @host = (hash[:hostname] or hash["hostname"])
+      @port = (hash[:port] or hash["port"])
 
       begin 
 	Logger.log_internal {

data/lib/log4r/rdoc/log4jxmlformatter

@@ -0,0 +1,21 @@
+= Configuring Log4r with Log4r::YamlConfigurator
+
+The YamlConfigurator class allows one to set up Log4r via YAML.
+It is used almost exactly as Log4r::Configurator and has the same features,
+
+  ycfg = YamlConfigurator    # handy shorthand
+  ycfg['foo'] = bar          # replaces instances of #{foo} in the YAML with bar
+  ycfg.load_yaml_file('foo.yaml')
+
+Ruby 1.7 and 1.8 comes with a YAML parser. Hence, YAML can be used
+to configure Log4r out of the box.
+
+A comprehensive example of a Log4r YAML configuration is provided in the 
+examples directory.
+
+To use this class:
+
+  require 'log4r/yamlconfigurator'
+
+Thanks to Andreas Hund for making this possible.
+

data/lib/log4r/rdoc/scribeoutputter

@@ -0,0 +1,16 @@
+= ScribeOutputter
+
+A ScribeOutputter transforms a Log4r::LogEvent into an event passed to Scribe. The user can configure the outputter with
+the host and port of the scribe scribe server.
+
+== Usage
+
+To use,
+  <tt>require 'log4r'</tt>
+
+An example,
+
+  require 'log4r'
+
+  logger = Log4r::ScribeOutputter.new('name', '127.0.0.1', 1463)
+  logger.debug("Hello World")

data/lib/log4r/version.rb

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

data/lib/log4r/yamlconfigurator.rb

@@ -119,13 +119,13 @@ module Log4r
       end
 
       formatter = decode_formatter( op['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( op)
-      buff += "," + params.join(',') if params.size > 0
-      begin eval buff
+
+      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]
@@ -138,8 +138,8 @@ module Log4r
       return nil if fo.nil?
       type = fo['type'] 
       raise ConfigError, "Formatter missing type", caller[1..-4] if type.nil?
-      buff = "#{type}.new " + decode_hash_params( fo).join(',')
-      begin return eval( buff)
+      begin
+        return Log4r.const_get(type).new(decode_hash_params(fo))
       rescue Exception => ae
         raise ConfigError,
         "Problem creating outputter: #{ae.message}", caller[1..-4]
@@ -149,23 +149,25 @@ module Log4r
     ExcludeParams = %w{formatter level name type only_at}
 
     # Does the fancy parameter to hash argument transformation
-    def self.decode_hash_params( ph)
-      buff = []
-      ph.each{ |name, value| 
-        next if ExcludeParams.include? name
-        buff << ":" + name + "=>" + paramsub( value)
-      }
-      buff
+    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)
-      return nil if str.nil?
-      return nil if str.class != String
+    def self.paramsub(str)
       @@params.each {|param, value|
-        str.sub!( '#{' + param + '}', value)
+        str = str.sub("\#{#{param}}", value)
       }
-      "'" + str + "'"
+      str
     end
 
     def self.decode_logger( lo)

data/tests/testGDC.rb

@@ -1,9 +1,7 @@
-$: << File.join("..","lib")
-require "test/unit"
-require "log4r"
-include Log4r
+require 'test_helper'
 
-class TestGDC < Test::Unit::TestCase
+class TestGDC < TestCase
+  include Log4r
 
   def test_gdc_default
     assert(GDC.get() == "testGDC.rb", "Expected 'testGDC.rb' got '#{GDC.get()}'" )

data/tests/testMDC.rb

@@ -1,9 +1,7 @@
-$: << File.join("..","lib")
-require "test/unit"
-require "log4r"
-include Log4r
+require 'test_helper'
 
-class TestMDC < Test::Unit::TestCase
+class TestMDC < TestCase
+  include Log4r
 
   def test_multithread_copy
     Log4r::MDC.put("user","colbygk")
@@ -24,9 +22,9 @@ class TestMDC < Test::Unit::TestCase
     Log4r::MDC.put("string", "string")
     Log4r::MDC.put(5, "number")
     l = Logger.new 'test'
-    o = StdoutOutputter.new 'test' 
+    o = StdoutOutputter.new 'test'
     l.add o
-    assert_nothing_raised { 
+    assert_nothing_raised {
       f = PatternFormatter.new :pattern=> "%l user: %X{:user} %X{strng} %X{5}"
       Outputter['test'].formatter = f
       l.debug "And this?"

data/tests/testNDC.rb

@@ -1,9 +1,7 @@
-$: << File.join("..","lib")
-require "test/unit"
-require "log4r"
-include Log4r
+require 'test_helper'
 
-class TestNDC < Test::Unit::TestCase
+class TestNDC < TestCase
+  include Log4r
 
   def test_ndc_remove_push
     NDC.remove()

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

@@ -1,4 +1,4 @@
-$: << File.join("..", "lib")
+require 'test_helper'
 
 # because constants are dynamically defined, some tests need to
 # be opened in a fresh instance of Ruby, hence the popens

data/tests/testbase.rb

@@ -1,9 +1,8 @@
-$: << File.join("..","lib")
-require "test/unit"
-require "log4r"
-include Log4r
+require 'test_helper'
+
+class TestBase < TestCase
+  include Log4r
 
-class TestBase < Test::Unit::TestCase
   # check that LNAMES loads properly (it uses an eval to load)
   def test_default_levels
     Logger.root              # doing this loads the default levels
@@ -20,10 +19,10 @@ class TestBase < Test::Unit::TestCase
   # check bad input and bounds for validate_level
   def test_validate_level
     7.times{|i| assert_nothing_raised {Log4rTools.validate_level(i)} }
-    assert_raises(ArgumentError) {Log4rTools.validate_level(-1)}
-    assert_raises(ArgumentError) {Log4rTools.validate_level(LEVELS)}
-    assert_raises(ArgumentError) {Log4rTools.validate_level(String)}
-    assert_raises(ArgumentError) {Log4rTools.validate_level("bogus")}
+    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

data/tests/testchainsaw.rb

@@ -1,10 +1,4 @@
-$: << File.join("..", "lib")
-
-require 'log4r'
-require 'log4r/staticlogger'
-require 'log4r/formatter/log4jxmlformatter'
-require 'log4r/outputter/udpoutputter'
-require 'log4r/outputter/consoleoutputters'
+require 'test_helper'
 
 include Log4r
 

data/tests/testcustom.rb

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

@@ -1,7 +1,11 @@
+require 'test_helper'
+
 class TestFormatter < TestCase
+  include Log4r
+
   def test_creation
-    assert_no_exception { Formatter.new.format(3) }
-    assert_no_exception { DefaultFormatter.new }
+    assert_nothing_raised { Formatter.new.format(3) }
+    assert_nothing_raised { DefaultFormatter.new }
     assert_kind_of(Formatter, DefaultFormatter.new)
   end
   def test_simple_formatter
@@ -24,4 +28,4 @@ class TestFormatter < TestCase
     assert_match(b.format(event3), /ArgumentError/)
     assert_match(b.format(LogEvent.new(0,f,nil,[1,2,3])), /Array/)
   end
-end 
+end

data/tests/testlogger.rb

@@ -1,16 +1,20 @@
-class MyFormatter1 < Formatter
+require 'test_helper'
+
+class MyFormatter1 < Log4r::Formatter
   def format(event)
     return "MyFormatter1\n"
   end
 end
 
-class MyFormatter2 < Formatter
+class MyFormatter2 < Log4r::Formatter
   def format(event)
     return "MyFormatter2\n"
   end
 end
 
 class TestLogger < TestCase
+  include Log4r
+
   def test_root
     l1 = Logger.root
     l2 = Logger['root']
@@ -21,8 +25,8 @@ class TestLogger < TestCase
     assert(l1.parent == nil, "Root's parent wasn't nil!")
   end
   def test_validation
-    assert_exception(ArgumentError) { Logger.new }
-    assert_no_exception { Logger.new('validate', nil) }
+    assert_raise(ArgumentError) { Logger.new }
+    assert_nothing_raised { Logger.new('validate', nil) }
   end
   def test_all_off
     l = Logger.new("create_method")
@@ -45,14 +49,14 @@ class TestLogger < TestCase
     StdoutOutputter.new('fake1')
     StdoutOutputter.new('fake2')
     a = Logger.new("add")
-    assert_exception(TypeError) { a.add 'bogus' }
-    assert_exception(TypeError) { a.add Class }
-    assert_exception(TypeError) { a.add 'fake1', Class }
-    assert_no_exception { a.add 'fake1', 'fake2' }
+    assert_raise(TypeError) { a.add 'bogus' }
+    assert_raise(TypeError) { a.add Class }
+    assert_raise(TypeError) { a.add 'fake1', Class }
+    assert_nothing_raised { a.add 'fake1', 'fake2' }
   end
   def test_repository
-    assert_exception(NameError) { Logger.get('bogusbogus') }
-    assert_no_exception { Logger['bogusbogus'] }
+    assert_raise(NameError) { Logger.get('bogusbogus') }
+    assert_nothing_raised { Logger['bogusbogus'] }
   end
   def test_heiarchy
     a = Logger.new("a")
@@ -79,7 +83,7 @@ class TestLogger < TestCase
     assert(d.path == "a", "path wasn't set properly")
     assert(d.level == a.level, "didn't inherit parent's level") 
     assert(d.parent == a, "parent wasn't what is expected")
-    assert_exception(ArgumentError) { Logger.new("::a") }
+    assert_raise(ArgumentError) { Logger.new("::a") }
   end
   def test_undefined_parents
     a = Logger.new 'has::no::real::parents::me'
@@ -130,7 +134,7 @@ class TestLogger < TestCase
     l = Logger.new 'logblocks'
     l.level = WARN
     l.add(Outputter.stdout)
-    assert_no_exception {
+    assert_nothing_raised {
       l.debug { puts "should not show up"; "LOGBLOCKS" }
       l.fatal { puts "should show up"; "LOGBLOCKS" }
       l.fatal { nil }