TwP-logging 0.9.7

data/lib/logging/utils.rb

@@ -0,0 +1,130 @@
+
+class Hash
+
+  # call-seq:
+  #    getopt( key, default = nil, :as => class )
+  #
+  # Returns the value associated with the _key_. If the has does not contain
+  # the _key_, then the _default_ value is returned.
+  #
+  # Optionally, the value can be converted into to an instance of the given
+  # _class_. The supported classes are:
+  #
+  #     Integer
+  #     Float
+  #     Array
+  #     String
+  #     Symbol
+  #
+  # If the value is +nil+, then no converstion will be performed.
+  #
+  def getopt( *args )
+    opts = args.last.instance_of?(Hash) ? args.pop : {}
+    key, default = args
+
+    val = if has_key?(key);                self[key]
+          elsif has_key?(key.to_s);        self[key.to_s]
+          elsif has_key?(key.to_s.intern); self[key.to_s.intern]
+          else default end
+
+    return if val.nil?
+    return val unless opts.has_key?(:as)
+
+    case opts[:as].name.intern
+    when :Integer; Integer(val)
+    when :Float;   Float(val)
+    when :Array;   Array(val)
+    when :String;  String(val)
+    when :Symbol;  String(val).intern
+    else val end
+  end
+end
+
+class String
+
+  # call-seq:
+  #    reduce( width, ellipses = '...' )    #=> string
+  #
+  # Reduce the size of the current string to the given _width_ by removing
+  # characters from the middle of the string and replacing them with
+  # _ellipses_. If the _width_ is greater than the length of the string, the
+  # string is returned unchanged. If the _width_ is less than the length of
+  # the _ellipses_, then the _ellipses_ are returned.
+  #
+  def reduce( width, ellipses = '...')
+    raise ArgumentError, "width cannot be negative: #{width}" if width < 0
+
+    return self if length <= width
+
+    remove = length - width + ellipses.length
+    return ellipses.dup if remove >= length
+
+    left_end = (length + 1 - remove) / 2
+    right_start = left_end + remove
+
+    left = self[0,left_end]
+    right = self[right_start,length-right_start]
+
+    left << ellipses << right
+  end
+end
+
+class Module
+
+  # call-seq:
+  #    logger_name    #=> string
+  #
+  # Returns a predictable logger name for the current module or class. If
+  # used within an anonymous class, the first non-anonymous class name will
+  # be used as the logger name. If used within a meta-class, the name of the
+  # actual class will be used as the logger name. If used within an
+  # anonymous module, the string 'anonymous' will be returned.
+  #
+  def logger_name
+    return name unless name.nil? or name.empty?
+
+    # check if this is a metaclass (or eigenclass)
+    if ancestors.include? Class
+      inspect =~ %r/#<Class:([^#>]+)>/
+      return $1
+    end
+
+    # see if we have a superclass
+    if respond_to? :superclass
+      return superclass.logger_name
+    end
+
+    # we are an anonymous module
+    ::Logging.log_internal(-2) {
+      'cannot return a predictable, unique name for anonymous modules'
+    }
+    return 'anonymous'
+  end
+end
+
+class ReentrantMutex < Mutex
+
+  def initialize
+    super
+    @locker = nil
+  end
+
+  alias :original_synchronize :synchronize
+
+  def synchronize
+    if @locker == Thread.current
+      yield
+    else
+      original_synchronize {
+        begin
+          @locker = Thread.current
+          yield
+        ensure
+          @locker = nil
+        end
+      }
+    end
+  end
+end  # class ReentrantMutex
+
+# EOF

data/logging.gemspec

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{logging}
+  s.version = "0.9.7"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tim Pease"]
+  s.date = %q{2009-02-23}
+  s.description = %q{Logging is a flexible logging library for use in Ruby programs based on the design of Java's log4j library. It features a hierarchical logging system, custom level names, multiple output destinations per log event, custom formatting, and more.}
+  s.email = %q{tim.pease@gmail.com}
+  s.extra_rdoc_files = ["History.txt", "README.rdoc"]
+  s.files = ["History.txt", "README.rdoc", "Rakefile", "data/bad_logging_1.rb", "data/bad_logging_2.rb", "data/logging.rb", "data/logging.yaml", "data/simple_logging.rb", "lib/logging.rb", "lib/logging/appender.rb", "lib/logging/appenders/buffering.rb", "lib/logging/appenders/console.rb", "lib/logging/appenders/email.rb", "lib/logging/appenders/file.rb", "lib/logging/appenders/growl.rb", "lib/logging/appenders/io.rb", "lib/logging/appenders/rolling_file.rb", "lib/logging/appenders/syslog.rb", "lib/logging/config/configurator.rb", "lib/logging/config/yaml_configurator.rb", "lib/logging/layout.rb", "lib/logging/layouts/basic.rb", "lib/logging/layouts/pattern.rb", "lib/logging/log_event.rb", "lib/logging/logger.rb", "lib/logging/repository.rb", "lib/logging/root_logger.rb", "lib/logging/stats.rb", "lib/logging/utils.rb", "logging.gemspec", "test/appenders/test_buffered_io.rb", "test/appenders/test_console.rb", "test/appenders/test_email.rb", "test/appenders/test_file.rb", "test/appenders/test_growl.rb", "test/appenders/test_io.rb", "test/appenders/test_rolling_file.rb", "test/appenders/test_syslog.rb", "test/benchmark.rb", "test/config/test_configurator.rb", "test/config/test_yaml_configurator.rb", "test/layouts/test_basic.rb", "test/layouts/test_pattern.rb", "test/setup.rb", "test/test_appender.rb", "test/test_layout.rb", "test/test_log_event.rb", "test/test_logger.rb", "test/test_logging.rb", "test/test_repository.rb", "test/test_root_logger.rb", "test/test_stats.rb", "test/test_utils.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://logging.rubyforge.org/}
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{logging}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{A flexible and extendable logging library for Ruby}
+  s.test_files = ["test/appenders/test_buffered_io.rb", "test/appenders/test_console.rb", "test/appenders/test_email.rb", "test/appenders/test_file.rb", "test/appenders/test_growl.rb", "test/appenders/test_io.rb", "test/appenders/test_rolling_file.rb", "test/appenders/test_syslog.rb", "test/config/test_configurator.rb", "test/config/test_yaml_configurator.rb", "test/layouts/test_basic.rb", "test/layouts/test_pattern.rb", "test/test_appender.rb", "test/test_layout.rb", "test/test_log_event.rb", "test/test_logger.rb", "test/test_logging.rb", "test/test_repository.rb", "test/test_root_logger.rb", "test/test_stats.rb", "test/test_utils.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<flexmock>, [">= 0.8.2"])
+      s.add_runtime_dependency(%q<lockfile>, [">= 1.4.3"])
+      s.add_development_dependency(%q<bones>, [">= 2.4.0"])
+    else
+      s.add_dependency(%q<flexmock>, [">= 0.8.2"])
+      s.add_dependency(%q<lockfile>, [">= 1.4.3"])
+      s.add_dependency(%q<bones>, [">= 2.4.0"])
+    end
+  else
+    s.add_dependency(%q<flexmock>, [">= 0.8.2"])
+    s.add_dependency(%q<lockfile>, [">= 1.4.3"])
+    s.add_dependency(%q<bones>, [">= 2.4.0"])
+  end
+end

data/test/appenders/test_buffered_io.rb

@@ -0,0 +1,183 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestAppenders
+
+  class TestBufferedIO < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      ::Logging.init
+      @levels = ::Logging::LEVELS
+
+      @sio = StringIO.new
+      @appender = ::Logging::Appenders::IO.new(
+        'test_appender', @sio,
+        :auto_flushing => 3, :immediate_at => :error
+      )
+
+      begin readline rescue EOFError end
+    end
+
+    def test_append
+      event = ::Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                      [1, 2, 3, 4], false)
+      @appender.append event
+      assert_raise(EOFError) {readline}
+
+      @appender.append event
+      assert_raise(EOFError) {readline}
+
+      event.level = @levels['debug']
+      event.data = 'the big log message'
+      @appender.append event
+
+      assert_equal " WARN  TestLogger : <Array> #{[1, 2, 3, 4]}\n", readline
+      assert_equal " WARN  TestLogger : <Array> #{[1, 2, 3, 4]}\n", readline
+      assert_equal "DEBUG  TestLogger : the big log message\n", readline
+      assert_raise(EOFError) {readline}
+
+      @appender.close
+      assert_raise(RuntimeError) {@appender.append event}
+    end
+
+    def test_append_error
+      # setup an internal logger to capture error messages from the IO
+      # appender
+      log = StringIO.new
+      Logging::Logger[Logging].add_appenders(
+        Logging::Appenders::IO.new('__internal_io', log)
+      )
+      Logging::Logger[Logging].level = 'all'
+
+
+      # close the string IO object so we get an error
+      @sio.close
+      event = ::Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                      [1, 2, 3, 4], false)
+      @appender.append event
+      log.seek 0
+      assert_raise(EOFError) {log.readline}
+
+      @appender.append event
+      log.seek 0
+      assert_raise(EOFError) {log.readline}
+
+      @appender.append event
+      log.seek 0
+      assert_equal "INFO  Logging : appender \"test_appender\" has been disabled", log.readline.strip
+      assert_equal "ERROR  Logging : <IOError> not opened for writing", log.readline.strip
+
+      assert_equal false, @appender.closed?
+      assert_equal 5, @appender.level
+    end
+
+    def test_close
+      assert_equal false, @sio.closed?
+      assert_equal false, @appender.closed?
+
+      @appender.close
+      assert_equal true, @sio.closed?
+      assert_equal true, @appender.closed?
+
+      [STDIN, STDERR, STDOUT].each do |io|
+        @appender = ::Logging::Appenders::IO.new 'test', io
+        @appender.close
+        assert_equal false, io.closed?
+        assert_equal true, @appender.closed?
+      end
+    end
+
+    def test_concat
+      @appender << "this is a test message\n"
+      assert_raise(EOFError) {readline}
+
+      @appender << "this is another message\n"
+      assert_raise(EOFError) {readline}
+
+      @appender << "some other line\n"
+
+      assert_equal "this is a test message\n", readline
+      assert_equal "this is another message\n", readline
+      assert_equal "some other line\n", readline
+      assert_raise(EOFError) {readline}
+
+      @appender.close
+      assert_raise(RuntimeError) {@appender << 'message'}
+    end
+
+    def test_concat_error
+      # setup an internal logger to capture error messages from the IO
+      # appender
+      log = StringIO.new
+      Logging::Logger[Logging].add_appenders(
+        Logging::Appenders::IO.new('__internal_io', log)
+      )
+      Logging::Logger[Logging].level = 'all'
+
+      # close the string IO object so we get an error
+      @sio.close
+      @appender << 'oopsy'
+      log.seek 0
+      assert_raise(EOFError) {log.readline}
+
+      @appender << 'whoopsy'
+      log.seek 0
+      assert_raise(EOFError) {log.readline}
+
+      @appender << 'pooh'
+      log.seek 0
+      assert_equal "INFO  Logging : appender \"test_appender\" has been disabled", log.readline.strip
+      assert_equal "ERROR  Logging : <IOError> not opened for writing", log.readline.strip
+
+      # and the appender does not close itself
+      assert_equal false, @appender.closed?
+      assert_equal 5, @appender.level
+    end
+
+    def test_flush
+      ary = []
+      @sio.instance_variable_set :@ary, ary
+      def @sio.flush() @ary << :flush end
+
+      @appender << "this is a test message\n"
+      assert_raise(EOFError) {readline}
+
+      @appender.flush
+      assert_equal :flush, ary.pop
+      assert_equal "this is a test message\n", readline
+      assert_raise(EOFError) {readline}
+    end
+
+    def test_immediate_at
+      event = ::Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                      [1, 2, 3, 4], false)
+      @appender.append event
+      assert_raise(EOFError) {readline}
+
+      event.level = @levels['error']
+      event.data = 'an error message'
+      @appender.append event
+
+      assert_equal " WARN  TestLogger : <Array> #{[1, 2, 3, 4]}\n", readline
+      assert_equal "ERROR  TestLogger : an error message\n", readline
+      assert_raise(EOFError) {readline}
+    end
+
+    private
+    def readline
+      @pos ||= 0
+      @sio.seek @pos
+      line = @sio.readline
+      @pos = @sio.tell
+      line
+    end
+
+  end  # class TestBufferedIO
+
+end  # module TestAppenders
+end  # module TestLogging
+
+# EOF

data/test/appenders/test_console.rb

@@ -0,0 +1,66 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestAppenders
+
+  class TestStdout < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def test_initialize
+      ::Logging::Repository.instance
+
+      appender = ::Logging::Appenders::Stdout.new
+      assert_equal 'stdout', appender.name
+      assert_same STDOUT, appender.instance_variable_get(:@io)
+
+      appender.close
+      assert_equal true, appender.closed?
+      assert_equal false, STDOUT.closed?
+
+      appender = ::Logging::Appenders::Stdout.new('foo')
+      assert_equal 'foo', appender.name
+
+      appender = ::Logging::Appenders::Stdout.new(:level => :warn)
+      assert_equal 'stdout', appender.name
+      assert_equal 2, appender.level
+
+      appender = ::Logging::Appenders::Stdout.new('bar', :level => :error)
+      assert_equal 'bar', appender.name
+      assert_equal 3, appender.level
+    end
+
+  end  # class TestStdout
+
+  class TestStderr < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def test_initialize
+      ::Logging::Repository.instance
+
+      appender = ::Logging::Appenders::Stderr.new
+      assert_equal 'stderr', appender.name
+      assert_same STDERR, appender.instance_variable_get(:@io)
+
+      appender.close
+      assert_equal true, appender.closed?
+      assert_equal false, STDERR.closed?
+
+      appender = ::Logging::Appenders::Stderr.new('foo')
+      assert_equal 'foo', appender.name
+
+      appender = ::Logging::Appenders::Stderr.new(:level => :warn)
+      assert_equal 'stderr', appender.name
+      assert_equal 2, appender.level
+
+      appender = ::Logging::Appenders::Stderr.new('bar', :level => :error)
+      assert_equal 'bar', appender.name
+      assert_equal 3, appender.level
+    end
+
+  end  # class TestStderr
+
+end  # module TestAppenders
+end  # module TestLogging
+
+# EOF

data/test/appenders/test_email.rb

@@ -0,0 +1,171 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+require 'flexmock'
+
+module TestLogging
+module TestAppenders
+
+  class TestEmail < Test::Unit::TestCase
+    include FlexMock::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      ::Logging.init
+      @levels = ::Logging::LEVELS
+
+      flexmock(Net::SMTP).new_instances do |m|
+        m.should_receive(:start).at_least.once.with(
+            'test.logging', 'test', 'test', :cram_md5, Proc).and_yield(m)
+        m.should_receive(:sendmail).at_least.once.with(String, 'me', ['you'])
+      end
+
+      @appender = ::Logging::Appenders::Email.new('email',
+          'from' => 'me', 'to' => 'you',
+          :buffer_size => '3', :immediate_at => 'error, fatal',
+          :domain => 'test.logging', :acct => 'test', :passwd => 'test'
+      )
+    end
+
+    def test_initialize
+      assert_raise(ArgumentError, 'Must specify from address') {
+        ::Logging::Appenders::Email.new('email')
+      }
+      assert_raise(ArgumentError, 'Must specify to address') {
+        ::Logging::Appenders::Email.new('email', :from => 'me')
+      }
+      assert_nothing_raised {
+        ::Logging::Appenders::Email.new('email', :from => 'me', :to => 'you')
+      }
+
+      appender = ::Logging::Appenders::Email.new('email',
+          'from' => 'me', 'to' => 'you'
+      )
+
+      assert_equal(100, appender.auto_flushing)
+      assert_equal([], appender.instance_variable_get(:@immediate))
+      assert_equal('localhost', appender.server)
+      assert_equal(25, appender.port)
+
+      domain = ENV['HOSTNAME'] || 'localhost.localdomain'
+      assert_equal(domain, appender.domain)
+      assert_equal(nil, appender.acct)
+      assert_equal(:cram_md5, appender.authtype)
+      assert_equal("Message of #{$0}", appender.subject)
+
+      appender = ::Logging::Appenders::Email.new('email',
+          'from' => 'lbrinn@gmail.com', 'to' => 'everyone',
+          :buffsize => '1000', :immediate_at => 'error, fatal',
+          :server => 'smtp.google.com', :port => '443',
+          :domain => 'google.com', :acct => 'lbrinn',
+          :passwd => '1234', :authtype => 'tls',
+          :subject => "I'm rich and you're not"
+      )
+
+      assert_equal('lbrinn@gmail.com', appender.instance_variable_get(:@from))
+      assert_equal(['everyone'], appender.instance_variable_get(:@to))
+      assert_equal(1000, appender.auto_flushing)
+      assert_equal('1234', appender.instance_variable_get(:@passwd))
+      assert_equal([nil, nil, nil, true, true],
+                   appender.instance_variable_get(:@immediate))
+      assert_equal('smtp.google.com', appender.server)
+      assert_equal(443, appender.port)
+      assert_equal('google.com', appender.domain)
+      assert_equal('lbrinn', appender.acct)
+      assert_equal(:tls, appender.authtype)
+      assert_equal("I'm rich and you're not", appender.subject)
+
+      appender = ::Logging::Appenders::Email.new('email',
+          'from' => 'me', 'to' => 'you', :auto_flushing => 42
+      )
+      assert_equal(42, appender.auto_flushing)
+    end
+
+    def test_append
+      # with auto_flushing enabled, mail will be sent each time a log event
+      # occurs
+      @appender.auto_flushing = true
+      event = ::Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                      [1, 2, 3, 4], false)
+      @appender.append event
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+
+      # increase the buffer size and log a few events
+      @appender.auto_flushing = 3
+      @appender.append event
+      @appender.append event
+      assert_equal(2, @appender.buffer.length)
+
+      @appender.append event
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+
+      # error and fatal messages should be send immediately (no buffering)
+      error = ::Logging::LogEvent.new('ErrLogger', @levels['error'],
+                                      'error message', false)
+      fatal = ::Logging::LogEvent.new('FatalLogger', @levels['fatal'],
+                                      'fatal message', false)
+
+      @appender.append event
+      @appender.append fatal
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+
+      @appender.append error
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+
+      @appender.append event
+      assert_equal(1, @appender.buffer.length)
+    end
+
+    def test_concat
+      # with auto_flushing enabled, mail will be sent each time a log event
+      # occurs
+      @appender.auto_flushing = true
+      @appender << 'test message'
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+
+      # increase the buffer size and log a few events
+      @appender.auto_flushing = 3
+      @appender << 'another test message'
+      @appender << 'a second test message'
+      assert_equal(2, @appender.buffer.length)
+
+      @appender << 'a third test message'
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+    end
+
+    def test_flush
+      event = ::Logging::LogEvent.new('TestLogger', @levels['info'],
+                                      [1, 2, 3, 4], false)
+      @appender.append event
+      @appender << 'test message'
+      assert_equal(2, @appender.buffer.length)
+
+      @appender.flush
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+    end
+
+    def test_close
+      event = ::Logging::LogEvent.new('TestLogger', @levels['info'],
+                                      [1, 2, 3, 4], false)
+      @appender.append event
+      @appender << 'test message'
+      assert_equal(2, @appender.buffer.length)
+
+      @appender.close
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+      assert(@appender.closed?)
+    end
+
+  end  # class TestEmail
+end  # module TestLogging
+end  # module TestAppenders
+
+# EOF