logging 1.5.2 → 1.6.0

data/History.txt

@@ -1,3 +1,10 @@
+== 1.6.0 / 2011-08-
+
+Enhancements
+- Adding periodic flushing of buffered messages [issue #10]
+- Accessor for a logger's appenders [issue #9]
+- Better support for capturing log messages in RSpec version 1 & 2
+
 == 1.5.2 / 2011-07-07
 
 Bug Fixes

data/lib/logging/appenders/buffering.rb

@@ -26,6 +26,47 @@ module Logging::Appenders
     #
     attr_reader :auto_flushing
 
+    # When set, the buffer will be flushed at regular intervals defined by the
+    # flush_period.
+    #
+    attr_reader :flush_period
+
+    # Setup the message buffer and other variables for automatically and
+    # periodically flushing the buffer.
+    #
+    def initialize( *args, &block )
+      @buffer = []
+      @immediate = []
+      @auto_flushing = 1
+      @flush_period = @periodic_flusher = nil
+
+      super(*args, &block)
+    end
+
+    # Close the message buffer by flusing all log events to the appender. If a
+    # periodic flusher thread is running, shut it down and allow it to exit.
+    #
+    def close( *args )
+      flush
+
+      if @periodic_flusher
+        @periodic_flusher.stop
+        @periodic_flusher = nil
+        Thread.pass
+      end
+
+      super(*args)
+    end
+
+    # Reopen the connection to the underlying logging destination. In addtion
+    # if the appender is configured for periodic flushing, then the flushing
+    # thread will be stopped and restarted.
+    #
+    def reopen
+      _setup_periodic_flusher
+      super
+    end
+
     # Call +flush+ to force an appender to write out any buffered log events.
     # Similar to IO#flush, so use in a similar fashion.
     #
@@ -42,7 +83,7 @@ module Logging::Appenders
       self
     end
 
-    # Configure the levels that will trigger and immediate flush of the
+    # Configure the levels that will trigger an immediate flush of the
     # logging buffer. When a log event of the given level is seen, the
     # buffer will be flushed immediately. Only the levels explicitly given
     # in this assignment will flush the buffer; if an "error" message is
@@ -59,7 +100,6 @@ module Logging::Appenders
     #   immediate_at = "warn, error"
     #
     def immediate_at=( level )
-      @immediate ||= []
       @immediate.clear
 
       # get the immediate levels -- no buffering occurs at these levels, and
@@ -77,8 +117,8 @@ module Logging::Appenders
       end
     end
 
-    # Configure the auto-flushing period. Auto-flushing is used to flush the
-    # contents of the logging buffer to the logging destination
+    # Configure the auto-flushing threshold. Auto-flushing is used to flush
+    # the contents of the logging buffer to the logging destination
     # automatically when the buffer reaches a certain threshold.
     #
     # By default, the auto-flushing will be configured to flush after each
@@ -109,12 +149,50 @@ module Logging::Appenders
                 "unrecognized auto_flushing period: #{period.inspect}"
         end
 
-      if @auto_flushing < 0
+      if @auto_flushing <= 0
         raise ArgumentError,
-          "auto_flushing period cannot be negative: #{period.inspect}"
+          "auto_flushing period must be greater than zero: #{period.inspect}"
       end
+
+      @auto_flushing = DEFAULT_BUFFER_SIZE if @flush_period and @auto_flushing <= 1
     end
 
+    # Configure periodic flushing of the message buffer. Periodic flushing is
+    # used to flush the contents of the logging buffer at some regular
+    # interval. Periodic flushing is disabled by default.
+    #
+    # When enabling periodic flushing the flush period should be set using one
+    # of the following formats: "HH:MM:SS" or seconds as an numeric or string.
+    #
+    #   "01:00:00"  : every hour
+    #   "00:05:00"  : every 5 minutes
+    #   "00:00:30"  : every 30 seconds
+    #   60          : every 60 seconds (1 minute)
+    #   "120"       : every 120 seconds (2 minutes)
+    #
+    # For the periodic flusher to work properly, the auto-flushing threshold
+    # will be set to the default value of 500. The auto-flushing threshold can
+    # be changed, but it must be greater than 1.
+    #
+    # To disable the periodic flusher simply set the flush period to +nil+.
+    # The auto-flushing threshold will not be changed; it must be disabled
+    # manually if so desired.
+    #
+    def flush_period=( period )
+      period =
+        case period
+        when Integer, Float, nil; period
+        when String;
+          num = _parse_hours_minutes_seconds(period) || _parse_numeric(period)
+          num = ArgumentError.new("unrecognized flush period: #{period.inspect}") if num.nil?
+          num
+        else ArgumentError.new("unrecognized flush period: #{period.inspect}") end
+
+      raise period if Exception === period
+      @flush_period = period
+
+      _setup_periodic_flusher
+    end
 
   protected
 
@@ -127,9 +205,9 @@ module Logging::Appenders
     def configure_buffering( opts )
       ::Logging.init unless ::Logging.const_defined? :MAX_LEVEL_LENGTH
 
-      @buffer = []
       self.immediate_at = opts.getopt(:immediate_at, '')
       self.auto_flushing = opts.getopt(:auto_flushing, true)
+      self.flush_period = opts.getopt(:flush_period, nil)
     end
 
     # Returns true if the _event_ level matches one of the configured
@@ -151,7 +229,7 @@ module Logging::Appenders
     # formatted using the layout given to the appender when it was created.
     #
     # The _event_ will be formatted and then buffered until the
-    # "auto_flushing" level has been reached. At thsi time the canonical_write
+    # "auto_flushing" level has been reached. At this time the canonical_write
     # method will be used to log all events stored in the buffer.
     #
     def write( event )
@@ -163,12 +241,155 @@ module Logging::Appenders
         canonical_write(str)
       else
         sync { @buffer << str }
+        @periodic_flusher.signal if @periodic_flusher
         flush if @buffer.length >= @auto_flushing || immediate?(event)
       end
 
       self
     end
 
+    # Attempt to parse an hours/minutes/seconds value from the string and return
+    # an integer number of seconds.
+    #
+    #   _parse_hours_minutes_seconds("14:12:42")  #=> 51162
+    #   _parse_hours_minutes_seconds("foo")       #=> nil
+    #
+    def _parse_hours_minutes_seconds( str )
+      m = %r/^\s*(\d{2,}):(\d{2}):(\d{2}(?:\.\d+)?)\s*$/.match(str)
+      return if m.nil?
+
+      (3600 * m[1].to_i) + (60 * m[2].to_i) + (m[3].to_f)
+    end
+
+    # Convert the string into a numeric value. If the string does not
+    # represent a valid Integer or Float then +nil+ is returned.
+    #
+    #   _parse_numeric("10")   #=> 10
+    #   _parse_numeric("1.0")  #=> 1.0
+    #   _parse_numeric("foo")  #=> nil
+    #
+    def _parse_numeric( str )
+      Integer(str) rescue (Float(str) rescue nil)
+    end
+
+    # Using the flush_period, create a new PeriodicFlusher attached to this
+    # appender. If the flush_period is nil, then no action will be taken. If a
+    # PeriodicFlusher alreayd exists, it will be stopped and a new one will be
+    # created.
+    #
+    def _setup_periodic_flusher
+      # stop and remove any existing periodic flusher instance
+      if @periodic_flusher
+        @periodic_flusher.stop
+        @periodic_flusher = nil
+        Thread.pass
+      end
+
+      # create a new periodic flusher if we have a valid flush period
+      if @flush_period
+        @auto_flushing = DEFAULT_BUFFER_SIZE unless @auto_flushing > 1
+        @periodic_flusher = PeriodicFlusher.new(self, @flush_period)
+        @periodic_flusher.start
+      end
+    end
+
+    # :stopdoc:
+
+    # The PeriodicFlusher contains an internal run loop that will periodically
+    # wake up and flush any log events contained in the message buffer of the
+    # owning appender instance. The PeriodicFlusher relies on a _signal_ from
+    # the appender in order to wakeup and perform the flush on the appender.
+    #
+    class PeriodicFlusher
+
+      # Create a new PeriodicFlusher instance that will call the +flush+
+      # method on the given _appender_. The +flush+ method will be called
+      # every _period_ seconds, but only when the message buffer is non-empty.
+      #
+      def initialize( appender, period )
+        @appender = appender
+        @period = period
+
+        @mutex = Mutex.new
+        @cv = ConditionVariable.new
+        @thread = nil
+        @waiting = nil
+        @signaled = false
+      end
+
+      # Start the periodic flusher's internal run loop.
+      #
+      def start
+        return if @thread
+
+        @thread = Thread.new { loop {
+          begin
+            break if Thread.current[:stop]
+            _wait_for_signal
+            sleep @period unless Thread.current[:stop]
+            @appender.flush
+          rescue => err
+            ::Logging.log_internal {"PeriodicFlusher for appender #{@appender.inspect} encountered an error"}
+            ::Logging.log_internal(-2) {err}
+          end
+        }; @thread = nil }
+
+        self
+      end
+
+      # Stop the periodic flusher's internal run loop.
+      #
+      def stop
+        return if @thread.nil?
+        @thread[:stop] = true
+        signal if waiting?
+        self
+      end
+
+      # Signal the periodic flusher. This will wake up the run loop if it is
+      # currently waiting for something to do. If the signal method is never
+      # called, the periodic flusher will never perform the flush action on
+      # the appender.
+      #
+      def signal
+        return if Thread.current == @thread   # don't signal ourselves
+        return if @signaled                   # don't need to signal again
+
+        @mutex.synchronize {
+          @signaled = true
+          @cv.signal
+        }
+        self
+      end
+
+      # Returns +true+ if the flusher is waiting for a signal. Returns +false+
+      # if the flusher is somewhere in the processing loop.
+      #
+      def waiting?
+        @waiting
+      end
+
+    private
+
+      def _wait_for_signal
+        @mutex.synchronize {
+          begin
+            # wait on the condition variable only if we have NOT been signaled
+            unless @signaled
+              @waiting = true
+              @cv.wait(@mutex)
+              @waiting = false
+            end
+          ensure
+            @signaled = false
+          end
+        }
+      ensure
+        @waiting = false
+      end
+    end  # class PeriodicFlusher
+    # :startdoc:
+
   end  # module Buffering
 end  # module Logging::Appenders
 

data/lib/logging/appenders/file.rb

@@ -64,9 +64,9 @@ module Logging::Appenders
           flush
           @io.close rescue nil
         end
-        @closed = false
         @io = ::File.new(@fn, @mode)
       }
+      super
       self
     end
 

data/lib/logging/appenders/io.rb

@@ -7,6 +7,12 @@ module Logging::Appenders
   class IO < ::Logging::Appender
     include Buffering
 
+    # The method that will be used to close the IO stream. Defaults to :close
+    # but can be :close_read, :close_write or nil. When nil, the IO stream
+    # will not be closed when the appender's close method is called.
+    #
+    attr_accessor :close_method
+
     # call-seq:
     #    IO.new( name, io )
     #    IO.new( name, io, :layout => layout )
@@ -21,9 +27,10 @@ module Logging::Appenders
 
       @io = io
       @io.sync = true if io.respond_to? :sync=    # syswrite complains if the IO stream is buffered
+      @close_method = :close
 
-      configure_buffering(opts)
       super(name, opts)
+      configure_buffering(opts)
     end
 
     # call-seq:
@@ -37,8 +44,11 @@ module Logging::Appenders
     def close( *args )
       return self if @io.nil?
       super
+
       io, @io = @io, nil
-      io.close unless [STDIN, STDERR, STDOUT].include?(io)
+      unless [STDIN, STDERR, STDOUT].include?(io)
+        io.send(@close_method) if @close_method and io.respond_to? @close_method
+      end
     rescue IOError => err
     ensure
       return self

data/lib/logging/appenders/rolling_file.rb

@@ -170,9 +170,9 @@ module Logging::Appenders
           flush
           @io.close rescue nil
         end
-        @closed = false
         @io = ::File.new(@fn, 'a+')
       }
+      super
       self
     end
 

data/lib/logging/appenders/string_io.rb

@@ -22,11 +22,29 @@ module Logging::Appenders
       super(name, @sio, opts)
     end
 
+    # Reopen the underlying StringIO instance. If the instance is currently
+    # closed then it will be opened. If the instance is currently open then it
+    # will be closed and immediately opened.
+    #
+    def reopen
+      @mutex.synchronize {
+        if defined? @io and @io
+          flush
+          @io.close rescue nil
+        end
+        @io = @sio = StringIO.new
+        @sio.extend IoToS
+        @pos = 0
+      }
+      super
+      self
+    end
+
     # Clears the internal StringIO instance. All log messages are removed
     # from the buffer.
     #
     def clear
-      sync {
+      @mutex.synchronize {
         @pos = 0
         @sio.seek 0
         @sio.truncate 0

data/lib/logging/appenders/syslog.rb

@@ -156,8 +156,8 @@ module Logging::Appenders
           @syslog.close
         end
         @syslog = ::Syslog.open(@ident, @logopt, @facility)
-        @closed = false
       }
+      super
       self
     end
 

data/lib/logging/logger.rb

@@ -307,6 +307,12 @@ module Logging
       self.level
     end
 
+    # Returns the list of appenders.
+    #
+    def appenders
+      @appenders.dup
+    end
+
     # call-seq:
     #    appenders = app
     #

data/lib/rspec/logging_helper.rb

@@ -0,0 +1,39 @@
+
+module RSpec
+  module LoggingHelper
+
+    # Capture log messages from the Logging framework and make them
+    # available via a @log_output instance variable. The @log_output
+    # supports a readline method to access the log messags.
+    #
+    def capture_log_messages( opts = {} )
+      from = opts.getopt(:from, 'root')
+      to = opts.getopt(:to, '__rspec__')
+      exclusive = opts.getopt(:exclusive, true)
+
+      appender = Logging::Appenders[to] || Logging::Appenders::StringIo.new(to)
+      logger = Logging::Logger[from]
+      if exclusive
+        logger.appenders = appender
+      else
+        logger.add_appenders(appender)
+      end
+
+      before(:all) do
+        @log_output = Logging::Appenders[to]
+      end
+
+      before(:each) do
+        @log_output.reset
+      end
+    end
+
+  end  # module LoggingHelper
+end  # module RSpec
+
+if defined?  RSpec::Core::Configuration
+  class RSpec::Core::Configuration
+    include RSpec::LoggingHelper
+  end
+end
+

data/lib/spec/logging_helper.rb

@@ -1,34 +1,10 @@
 
-module Spec
-  module LoggingHelper
+require File.expand_path('../../rspec/logging_helper', __FILE__)
+Spec::LoggingHelper = RSpec::LoggingHelper
 
-    # Capture log messages from the Logging framework and make them
-    # available via a @log_output instance variable. The @log_output
-    # supports a readline method to access the log messags.
-    #
-    def capture_log_messages( opts = {} )
-      from = opts.getopt(:from, 'root')
-      to = opts.getopt(:to, '__rspec__')
-      exclusive = opts.getopt(:exclusive, true)
+if defined?  Spec::Runner::Configuration
+  class Spec::Runner::Configuration
+    include Spec::LoggingHelper
+  end
+end
 
-      appender = Logging::Appenders[to] || Logging::Appenders::StringIo.new(to)
-      logger = Logging::Logger[from]
-      if exclusive
-        logger.appenders = appender
-      else
-        logger.add_appenders(appender)
-      end
-
-      before(:all) do
-        @log_output = Logging::Appenders[to]
-      end
-
-      before(:each) do
-        @log_output.reset
-      end
-    end
-
-  end  # module LoggingHelper
-end  # module Spec
-
-# EOF

data/test/appenders/test_buffered_io.rb

@@ -74,6 +74,9 @@ module TestAppenders
       assert_raise(ArgumentError) {
         @appender.auto_flushing = -1
       }
+
+      @appender.auto_flushing = 0
+      assert_equal Logging::Appenders::Buffering::DEFAULT_BUFFER_SIZE, @appender.auto_flushing
     end
 
     def test_close

data/test/appenders/test_periodic_flushing.rb

@@ -0,0 +1,140 @@
+
+require File.expand_path('../setup', File.dirname(__FILE__))
+
+module TestLogging
+module TestAppenders
+
+  class TestPeriodicFlushing < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      @appender = Logging.appenders.string_io(
+        'test_appender', :flush_period => 2
+      )
+      @appender.clear
+      @sio = @appender.sio
+      @levels = Logging::LEVELS
+      begin readline rescue EOFError end
+      Thread.pass  # give the flusher thread a moment to start
+    end
+
+    def teardown
+      @appender.close
+      @appender = nil
+      super
+    end
+
+    def test_flush_period_set
+      assert_equal 2, @appender.flush_period
+      assert_equal Logging::Appenders::Buffering::DEFAULT_BUFFER_SIZE, @appender.auto_flushing
+
+      @appender.flush_period = '01:30:45'
+      assert_equal 5445, @appender.flush_period
+
+      @appender.flush_period = '245'
+      assert_equal 245, @appender.flush_period
+
+      @appender.auto_flushing = true
+      assert_equal Logging::Appenders::Buffering::DEFAULT_BUFFER_SIZE, @appender.auto_flushing
+
+      @appender.auto_flushing = 200
+      assert_equal 200, @appender.auto_flushing
+    end
+
+    def test_periodic_flusher_running
+      flusher = @appender.instance_variable_get(:@periodic_flusher)
+
+      assert_instance_of Logging::Appenders::Buffering::PeriodicFlusher, flusher
+      assert flusher.waiting?, 'the periodic flusher should be waiting for a signal'
+    end
+
+    def test_append
+      event = Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                    [1, 2, 3, 4], false)
+      @appender.append event
+      @appender.append event
+      event.level = @levels['debug']
+      event.data = 'the big log message'
+      @appender.append event
+
+      assert_nil(readline)
+      sleep 3
+
+      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_nil(readline)
+
+      @appender.close
+      assert_raise(RuntimeError) {@appender.append event}
+    end
+
+    def test_flush_on_close
+      assert_equal false, @sio.closed?
+      assert_equal false, @appender.closed?
+
+      event = Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                    [1, 2, 3, 4], false)
+
+      @appender.flush_period = "24:00:00"
+      @appender.append event
+      event.level = @levels['debug']
+      event.data = 'the big log message'
+      @appender.append event
+
+      assert_nil(readline)
+
+      @appender.close_method = :close_write
+      @appender.close
+      assert_equal false, @sio.closed?
+      assert_equal true, @appender.closed?
+
+      assert_equal " WARN  TestLogger : <Array> #{[1, 2, 3, 4]}\n", readline
+      assert_equal "DEBUG  TestLogger : the big log message\n", readline
+      assert_nil(readline)
+
+      @sio.close
+      assert_equal true, @sio.closed?
+    end
+
+    def test_auto_flushing
+      @appender.auto_flushing = 3
+
+      event = Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                    [1, 2, 3, 4], false)
+
+      @appender.append event
+      @appender.append event
+      event.level = @levels['debug']
+      event.data = 'the big log message'
+      @appender.append event
+      event.level = @levels['info']
+      event.data = 'just FYI'
+      @appender.append event
+      event.level = @levels['warn']
+      event.data = 'this is your last warning!'
+      @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_nil(readline)
+      sleep 3
+
+      assert_equal " INFO  TestLogger : just FYI\n", readline
+      assert_equal " WARN  TestLogger : this is your last warning!\n", readline
+      assert_nil(readline)
+    end
+
+  private
+    def readline
+      @appender.readline
+    end
+
+  end  # class TestPeriodicFlushing
+
+end  # module TestAppenders
+end  # module TestLogging
+

data/test/appenders/test_string_io.rb

@@ -0,0 +1,36 @@
+
+require File.expand_path('../setup', File.dirname(__FILE__))
+
+module TestLogging
+module TestAppenders
+
+  class TestStringIO < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+
+      @appender = Logging.appenders.string_io('test_appender')
+      @sio = @appender.sio
+      @levels = Logging::LEVELS
+    end
+
+    def teardown
+      @appender.close
+      @appender = nil
+      super
+    end
+
+    def test_reopen
+      assert_equal @sio.object_id, @appender.sio.object_id
+
+      @appender.reopen
+      assert @sio.closed?, 'StringIO instance is closed'
+      assert_not_equal @sio.object_id, @appender.sio.object_id
+    end
+
+  end  # class TestStringIO
+
+end  # module TestAppenders
+end  # module TestLogging
+

data/version.txt

@@ -1 +1 @@
-1.5.2
+1.6.0

metadata

@@ -1,117 +1,86 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: logging
-version: !ruby/object:Gem::Version 
-  hash: 7
-  prerelease: false
-  segments: 
-  - 1
-  - 5
-  - 2
-  version: 1.5.2
+version: !ruby/object:Gem::Version
+  version: 1.6.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Tim Pease
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-07-07 00:00:00 -06:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-08-22 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: little-plugger
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &2161856200 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 23
-        segments: 
-        - 1
-        - 1
-        - 2
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 1.1.2
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: flexmock
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *2161856200
+- !ruby/object:Gem::Dependency
+  name: flexmock
+  requirement: &2161855660 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 41
-        segments: 
-        - 0
-        - 8
-        - 11
-        version: 0.8.11
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.0
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: bones-git
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: *2161855660
+- !ruby/object:Gem::Dependency
+  name: bones-git
+  requirement: &2161855040 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 23
-        segments: 
-        - 1
-        - 2
-        - 4
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 1.2.4
   type: :development
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: bones-rcov
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  version_requirements: *2161855040
+- !ruby/object:Gem::Dependency
+  name: bones-rcov
+  requirement: &2161854480 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 21
-        segments: 
-        - 1
-        - 0
-        - 1
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 1.0.1
   type: :development
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: bones
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  version_requirements: *2161854480
+- !ruby/object:Gem::Dependency
+  name: bones
+  requirement: &2161853900 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 27
-        segments: 
-        - 3
-        - 7
-        - 0
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 3.7.0
   type: :development
-  version_requirements: *id005
-description: |-
-  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,
+  prerelease: false
+  version_requirements: *2161853900
+description: ! '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.
+
+  formatting, and more.'
 email: tim.pease@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - History.txt
 - README.rdoc
-files: 
+files:
 - History.txt
 - README.rdoc
 - Rakefile
@@ -158,6 +127,7 @@ files:
 - lib/logging/root_logger.rb
 - lib/logging/stats.rb
 - lib/logging/utils.rb
+- lib/rspec/logging_helper.rb
 - lib/spec/logging_helper.rb
 - test/appenders/test_buffered_io.rb
 - test/appenders/test_console.rb
@@ -165,7 +135,9 @@ files:
 - test/appenders/test_file.rb
 - test/appenders/test_growl.rb
 - test/appenders/test_io.rb
+- test/appenders/test_periodic_flushing.rb
 - test/appenders/test_rolling_file.rb
+- test/appenders/test_string_io.rb
 - test/appenders/test_syslog.rb
 - test/benchmark.rb
 - test/config/test_configurator.rb
@@ -189,49 +161,42 @@ files:
 - test/test_stats.rb
 - test/test_utils.rb
 - version.txt
-has_rdoc: true
 homepage: http://rubygems.org/gems/logging
 licenses: []
-
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --main
 - README.rdoc
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: logging
-rubygems_version: 1.3.7
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: A flexible and extendable logging library for Ruby
-test_files: 
+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_periodic_flushing.rb
 - test/appenders/test_rolling_file.rb
+- test/appenders/test_string_io.rb
 - test/appenders/test_syslog.rb
 - test/config/test_configurator.rb
 - test/config/test_yaml_configurator.rb