logging 1.2.3 → 1.3.0

data/History.txt

@@ -1,3 +1,10 @@
+== 1.3.0 / 2009-12-18
+
+Minor Enhancements
+- Using copy/truncate semantics for a faster RollingFile appender
+- Global reopen method for using Logging in forked environments
+- RollingFile appender can use date stamps instead of numbers
+
 == 1.2.3 / 2009-12-01
 
 1 bug fix

data/Rakefile

@@ -29,7 +29,6 @@ Bones {
   enable_sudo
 
   depend_on 'little-plugger'
-  depend_on 'lockfile'
   depend_on 'flexmock',     :development => true
   depend_on 'bones-git',    :development => true
   depend_on 'bones-extras', :development => true

data/examples/fork.rb

@@ -0,0 +1,37 @@
+# :stopdoc:
+#
+# Because of the global interpreter lock, Kernel#fork is the best way
+# to acheive true concurrency in Ruby scripts. However, there are pecularities
+# when using frok and passing file descriptors between process. These
+# pecularities affect the logging framework.
+#
+# In short, always reopen file descriptors in the child process after fork has
+# been called. The RollingFile appender uses flock to safely coordinate the
+# rolling of the log file when multiple processes are writing to the same
+# file. If the file descriptor is opened in the parent and multiple children
+# are forked, then each child will use the same file descriptor lock; when one
+# child locks the file any other child will also have the lock. This creates a
+# race condition in the rolling code. The solution is to reopen the file to
+# obtain a new file descriptor in each of the children.
+#
+
+  require 'logging'
+
+  log = Logging.logger['example']
+  log.add_appenders(
+      Logging.appenders.rolling_file('roller.log', :age => 'daily')
+  )
+  log.level = :debug
+
+  # Create four child processes and reopen the "roller.log" file descriptor in
+  # each child. Now log rolling will work safely.
+  4.times do
+    fork {
+      Logging.reopen
+      log.info "This is child process #{Process.pid}"
+    }
+  end
+
+  log.info "This is the parent process #{Process.pid}"
+
+# :startdoc:

data/lib/logging.rb

@@ -11,9 +11,7 @@ require 'stringio'
 require 'thread'
 require 'little-plugger'
 
-HAVE_LOCKFILE = require? 'lockfile'
-HAVE_SYSLOG   = require? 'syslog'
-
+HAVE_SYSLOG = require? 'syslog'
 
 #
 #
@@ -21,7 +19,7 @@ module Logging
   extend LittlePlugger
 
   # :stopdoc:
-  VERSION = '1.2.3'
+  VERSION = '1.3.0'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
   LEVELS = {}
@@ -83,7 +81,7 @@ module Logging
     # The format of the log messages can be changed using a few optional
     # parameters. The <tt>:pattern</tt> can be used to change the log
     # message format. The <tt>:date_pattern</tt> can be used to change how
-    # timestamps are formatted. 
+    # timestamps are formatted.
     #
     #    log = Logging.logger(STDOUT,
     #              :pattern => "[%d] %-5l : %m\n",
@@ -131,7 +129,7 @@ module Logging
           case dev
           when String
             ::Logging::Appenders::RollingFile.new(name, a_opts)
-          else 
+          else
             ::Logging::Appenders::IO.new(name, dev, a_opts)
           end
 
@@ -163,6 +161,15 @@ module Logging
       ::Logging::Appenders
     end
 
+    # Reopen all appenders. This method should be called immediately after a
+    # fork to ensure no conflict with file descriptors and calls to fcntl or
+    # flock.
+    #
+    def reopen
+      log_internal {'re-opening all appenders'}
+      ::Logging::Appenders.each {|appender| appender.reopen}
+    end
+
     # call-seq:
     #    Logging.consolidate( 'First::Name', 'Second::Name', ... )
     #
@@ -272,7 +279,7 @@ module Logging
       args.each do |lvl|
         lvl = levelify lvl
         unless levels.has_key?(lvl) or lvl == 'all' or lvl == 'off'
-          levels[lvl] = id 
+          levels[lvl] = id
           names[id] = lvl.upcase
           id += 1
         end
@@ -286,7 +293,7 @@ module Logging
 
       levels.keys
     end
-   
+
     # call-seq:
     #    Logging.format_as( obj_format )
     #

data/lib/logging/appender.rb

@@ -196,6 +196,15 @@ class Appender
     @closed
   end
 
+  # Reopen the connection to the underlying logging destination. If the
+  # connection is currently closed then it will be opened. If the connection
+  # is currently open then it will be closed and immediately opened.
+  #
+  def reopen
+    @closed = false
+    self
+  end
+
   # call-seq:
   #    flush
   #

data/lib/logging/appenders/email.rb

@@ -41,7 +41,7 @@ class Email < ::Logging::Appender
     @subject  = opts.getopt :subject, "Message of #{$0}"
     @params   = [@server, @port, @domain, @acct, @passwd, @authtype]
   end
-  
+
   # call-seq:
   #    flush
   #

data/lib/logging/appenders/file.rb

@@ -43,15 +43,32 @@ module Logging::Appenders
       @fn = opts.getopt(:filename, name)
       raise ArgumentError, 'no filename was given' if @fn.nil?
       self.class.assert_valid_logfile(@fn)
-      mode = opts.getopt(:truncate) ? 'w' : 'a'
+      @mode = opts.getopt(:truncate) ? 'w' : 'a'
 
-      super(name, ::File.new(@fn, mode), opts)
+      super(name, ::File.new(@fn, @mode), opts)
     end
 
     # Returns the path to the logfile.
     #
     def filename() @fn.dup end
 
+    # Reopen the connection to the underlying logging destination. If the
+    # connection is currently closed then it will be opened. If the connection
+    # 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
+        @closed = false
+        @io = ::File.new(@fn, @mode)
+        @io.sync = true
+      }
+      self
+    end
+
   end  # class FileAppender
 end  # module Logging::Appenders
 

data/lib/logging/appenders/rolling_file.rb

@@ -5,9 +5,8 @@ module Logging::Appenders
   # never exceeds some user specified level.
   #
   # The goal of this class is to write log messages to a file. When the file
-  # age or size exceeds a given limit then the log file is closed, the name
-  # is changed to indicate it is an older log file, and a new log file is
-  # created.
+  # age or size exceeds a given limit then the log file is copied and then
+  # truncated. The name of the copy indicates it is an older log file.
   #
   # The name of the log file is changed by inserting the age of the log file
   # (as a single number) between the log file name and the extension. If the
@@ -16,15 +15,30 @@ module Logging::Appenders
   #
   #    /var/log/ruby.log   =>   /var/log/ruby.1.log
   #
-  # New log messages will be appended to a newly opened log file of the same
-  # name (<tt>/var/log/ruby.log</tt> in our example above). The age number
-  # for all older log files is incremented when the log file is rolled. The
-  # number of older log files to keep can be given, otherwise all the log
-  # files are kept.
+  # New log messages will continue to be appended to the same log file
+  # (<tt>/var/log/ruby.log</tt> in our example above). The age number for all
+  # older log files is incremented when the log file is rolled. The number of
+  # older log files to keep can be given, otherwise all the log files are
+  # kept.
   #
   # The actual process of rolling all the log file names can be expensive if
   # there are many, many older log files to process.
   #
+  # If you do not wish to use numbered files when rolling, you can specify the
+  # :roll_by option as 'date'. This will use a date/time stamp to
+  # differentiate the older files from one another. If you configure your
+  # rolling file appender to roll daily and ignore the file size:
+  #
+  #    /var/log/ruby.log   =>   /var/log/ruby.20091225.log
+  #
+  # Where the date is expressed as <tt>%Y%m%d</tt> in the Time#strftime format.
+  #
+  # NOTE: this class is not safe to use when log messages are written to files
+  # on NFS mounts or other remote file system. It should only be used for log
+  # files on the local file system. The exception to this is when a single
+  # process is writing to the log file; remote file systems are safe to
+  # use in this case but still not recommended.
+  #
   class RollingFile < ::Logging::Appenders::IO
 
     # call-seq:
@@ -49,69 +63,51 @@ module Logging::Appenders
     #               rolled. The age can also be given as 'daily', 'weekly',
     #               or 'monthly'.
     #  [:keep]      The number of rolled log files to keep.
-    #  [:safe]      When set to true, extra checks are made to ensure that
-    #               only once process can roll the log files; this option
-    #               should only be used when multiple processes will be
-    #               logging to the same log file (does not work on Windows)
+    #  [:roll_by]   How to name the rolled log files. This can be 'number' or
+    #               'date'.
     #
     def initialize( name, opts = {} )
       # raise an error if a filename was not given
       @fn = opts.getopt(:filename, name)
+      @fn_copy = @fn + '._copy_'
       raise ArgumentError, 'no filename was given' if @fn.nil?
       ::Logging::Appenders::File.assert_valid_logfile(@fn)
 
-      # grab the information we need to properly roll files
-      ext = ::File.extname(@fn)
-      bn = ::File.join(::File.dirname(@fn), ::File.basename(@fn, ext))
-      @rgxp = %r/\.(\d+)#{Regexp.escape(ext)}\z/
-      @glob = "#{bn}.*#{ext}"
-      @logname_fmt = "#{bn}.%d#{ext}"
-
       # grab our options
-      @keep = opts.getopt(:keep, :as => Integer)
       @size = opts.getopt(:size, :as => Integer)
 
-      @lockfile = if HAVE_LOCKFILE and opts.getopt(:safe, false)
-        ::Lockfile.new(
-            @fn + '.lck',
-            :retries => 1,
-            :timeout => 2
-        )
-      end
-
       code = 'def sufficiently_aged?() false end'
       @age_fn = @fn + '.age'
+      @age_fn_mtime = nil
 
       case @age = opts.getopt(:age)
       when 'daily'
-        FileUtils.touch(@age_fn) unless test(?f, @age_fn)
         code = <<-CODE
         def sufficiently_aged?
+          @age_fn_mtime ||= ::File.mtime(@age_fn)
           now = Time.now
-          start = ::File.mtime(@age_fn)
-          if (now.day != start.day) or (now - start) > 86400
+          if (now.day != @age_fn_mtime.day) or (now - @age_fn_mtime) > 86400
             return true
           end
           false
         end
         CODE
       when 'weekly'
-        FileUtils.touch(@age_fn) unless test(?f, @age_fn)
         code = <<-CODE
         def sufficiently_aged?
-          if (Time.now - ::File.mtime(@age_fn)) > 604800
+          @age_fn_mtime ||= ::File.mtime(@age_fn)
+          if (Time.now - @age_fn_mtime) > 604800
             return true
           end
           false
         end
         CODE
       when 'monthly'
-        FileUtils.touch(@age_fn) unless test(?f, @age_fn)
         code = <<-CODE
         def sufficiently_aged?
+          @age_fn_mtime ||= ::File.mtime(@age_fn)
           now = Time.now
-          start = ::File.mtime(@age_fn)
-          if (now.month != start.month) or (now - start) > 2678400
+          if (now.month != @age_fn_mtime.month) or (now - @age_fn_mtime) > 2678400
             return true
           end
           false
@@ -119,30 +115,64 @@ module Logging::Appenders
         CODE
       when Integer, String
         @age = Integer(@age)
-        FileUtils.touch(@age_fn) unless test(?f, @age_fn)
         code = <<-CODE
         def sufficiently_aged?
-          if (Time.now - ::File.mtime(@age_fn)) > @age
+          @age_fn_mtime ||= ::File.mtime(@age_fn)
+          if (Time.now - @age_fn_mtime) > @age
             return true
           end
           false
         end
         CODE
       end
+
+      FileUtils.touch(@age_fn) if @age and !test(?f, @age_fn)
+
       meta = class << self; self end
       meta.class_eval code, __FILE__, __LINE__
 
-      # if the truncate flag was set to true, then roll 
-      roll_now = opts.getopt(:truncate, false)
-      roll_files if roll_now
+      super(name, ::File.new(@fn, 'a'), opts)
+
+      # setup the file roller
+      @roller =
+          case opts.getopt(:roll_by)
+          when 'number'; NumberedRoller.new(@fn, opts)
+          when 'date'; DateRoller.new(@fn, opts)
+          else
+            (@age and !@size) ?
+                DateRoller.new(@fn, opts) :
+                NumberedRoller.new(@fn, opts)
+          end
 
-      super(name, open_logfile, opts)
+      # if the truncate flag was set to true, then roll
+      roll_now = opts.getopt(:truncate, false)
+      if roll_now
+        copy_truncate
+        @roller.roll_files
+      end
     end
 
     # Returns the path to the logfile.
     #
     def filename() @fn.dup end
 
+    # Reopen the connection to the underlying logging destination. If the
+    # connection is currently closed then it will be opened. If the connection
+    # 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
+        @closed = false
+        @io = ::File.new(@fn, 'a')
+        @io.sync = true
+      }
+      self
+    end
+
 
     private
 
@@ -158,43 +188,24 @@ module Logging::Appenders
             @layout.format(event) : event.to_s
       return if str.empty?
 
-      check_logfile
-      super(str)
-
-      if roll_required?(str)
-        return roll unless @lockfile
+      @io.flock_sh { super(str) }
 
-        @lockfile.lock {
-          check_logfile
-          roll if roll_required?
+      if roll_required?
+        @io.flock? {
+          @age_fn_mtime = nil
+          copy_truncate if roll_required?
         }
+        @roller.roll_files
       end
     end
 
-    # call-seq:
-    #    roll
-    #
-    # Close the currently open log file, roll all the log files, and open a
-    # new log file.
-    #
-    def roll
-      @io.close rescue nil
-      roll_files
-      open_logfile
-    end
-
-    # call-seq:
-    #    roll_required?( str )    => true or false
-    #
     # Returns +true+ if the log file needs to be rolled.
     #
-    def roll_required?( str = nil )
+    def roll_required?
+      return false if ::File.exist? @fn_copy
+
       # check if max size has been exceeded
-      s = if @size 
-        @file_size = @stat.size if @stat.size > @file_size
-        @file_size += str.size if str
-        @file_size > @size
-      end
+      s = @size ? ::File.size(@fn) > @size : false
 
       # check if max age has been exceeded
       a = sufficiently_aged?
@@ -202,90 +213,113 @@ module Logging::Appenders
       return (s || a)
     end
 
-    # call-seq:
-    #    roll_files
+    # Copy the contents of the logfile to another file. Truncate the logfile
+    # to zero length. This method will set the roll flag so that all the
+    # current logfiles will be rolled along with the copied file.
     #
-    # Roll the log files. This is accomplished by renaming the log files
-    # starting with the oldest and working towards the youngest.
-    #
-    #    test.10.log  =>  deleted (we are only keeping 10)
-    #    test.9.log   =>  test.10.log
-    #    test.8.log   =>  test.9.log
-    #    ...
-    #    test.1.log   =>  test.2.log
-    #    
-    # Lastly the current log file is rolled to a numbered log file.
-    #
-    #    test.log     =>  test.1.log
-    #
-    # This method leaves no <tt>test.log</tt> file when it is done. This
-    # file will be created elsewhere.
-    #
-    def roll_files
+    def copy_truncate
       return unless ::File.exist?(@fn)
+      FileUtils.copy @fn, @fn_copy
+      @io.truncate 0
+
+      # touch the age file if needed
+      if @age
+        FileUtils.touch @age_fn
+        @age_fn_mtime = nil
+      end
 
-      files = Dir.glob(@glob).find_all {|fn| @rgxp =~ fn}
-      unless files.empty?
-        # sort the files in revese order based on their count number
-        files = files.sort do |a,b|
-                  a = Integer(@rgxp.match(a)[1])
-                  b = Integer(@rgxp.match(b)[1])
-                  b <=> a
-                end
-
-        # for each file, roll its count number one higher
-        files.each do |fn|
-          cnt = Integer(@rgxp.match(fn)[1])
-          if @keep and cnt >= @keep
-            ::File.delete fn
-            next
+      @roller.roll = true
+    end
+
+
+    # :stopdoc:
+    class NumberedRoller
+      attr_accessor :roll
+
+      def initialize( fn, opts )
+        # grab the information we need to properly roll files
+        ext = ::File.extname(fn)
+        bn = ::File.join(::File.dirname(fn), ::File.basename(fn, ext))
+        @rgxp = %r/\.(\d+)#{Regexp.escape(ext)}\z/
+        @glob = "#{bn}.*#{ext}"
+        @logname_fmt = "#{bn}.%d#{ext}"
+        @fn_copy = fn + '._copy_'
+        @keep = opts.getopt(:keep, :as => Integer)
+        @roll = false
+      end
+
+      def roll_files
+        return unless @roll and ::File.exist?(@fn_copy)
+
+        files = Dir.glob(@glob).find_all {|fn| @rgxp =~ fn}
+        unless files.empty?
+          # sort the files in revese order based on their count number
+          files = files.sort do |a,b|
+                    a = Integer(@rgxp.match(a)[1])
+                    b = Integer(@rgxp.match(b)[1])
+                    b <=> a
+                  end
+
+          # for each file, roll its count number one higher
+          files.each do |fn|
+            cnt = Integer(@rgxp.match(fn)[1])
+            if @keep and cnt >= @keep
+              ::File.delete fn
+              next
+            end
+            ::File.rename fn, sprintf(@logname_fmt, cnt+1)
           end
-          ::File.rename fn, sprintf(@logname_fmt, cnt+1)
         end
+
+        # finally reanme the copied log file
+        ::File.rename(@fn_copy, sprintf(@logname_fmt, 1))
+      ensure
+        @roll = false
       end
+    end
 
-      # finally reanme the base log file
-      ::File.rename(@fn, sprintf(@logname_fmt, 1))
+    class DateRoller
+      attr_accessor :roll
 
-      # touch the age file if needed
-      FileUtils.touch(@age_fn) if @age
-    end
+      def initialize( fn, opts )
+        @fn_copy = fn + '._copy_'
+        @roll = false
+        @keep = opts.getopt(:keep, :as => Integer)
 
-    # call-seq:
-    #    open_logfile    => io
-    #
-    # Opens the logfile and stores the current file szie and inode.
-    #
-    def open_logfile
-      @io = ::File.new(@fn, 'a')
-      @io.sync = true
+        ext = ::File.extname(fn)
+        bn = ::File.join(::File.dirname(fn), ::File.basename(fn, ext))
 
-      @stat = ::File.stat(@fn)
-      @file_size = @stat.size
-      @inode = @stat.ino
+        if @keep
+          @rgxp = %r/\.(\d+)(-\d+)?#{Regexp.escape(ext)}\z/
+          @glob = "#{bn}.*#{ext}"
+        end
 
-      return @io
-    end
+        if %w[daily weekly monthly].include?(opts.getopt(:age)) and !opts.getopt(:size)
+          @logname_fmt = "#{bn}.%Y%m%d#{ext}"
+        else
+          @logname_fmt = "#{bn}.%Y%m%d-%H%M%S#{ext}"
+        end
+      end
 
-    #
-    #
-    def check_logfile
-      retry_cnt ||= 0
+      def roll_files
+        return unless @roll and ::File.exist?(@fn_copy)
 
-      if ::File.exist?(@fn) then
-        @stat = ::File.stat(@fn)
-        return unless @lockfile
-        return if @inode == @stat.ino
+        # reanme the copied log file
+        ::File.rename(@fn_copy, Time.now.strftime(@logname_fmt))
 
-        @io.close rescue nil
+        # prune old log files
+        if @keep
+          files = Dir.glob(@glob).find_all {|fn| @rgxp =~ fn}
+          length = files.length
+          if length > @keep
+            files.sort {|a,b| b <=> a}.last(length-@keep).each {|fn| ::File.delete fn}
+          end
+        end
+      ensure
+        @roll = false
       end
-      open_logfile
-    rescue SystemCallError
-      raise if retry_cnt > 3
-      retry_cnt += 1
-      sleep 0.08
-      retry
     end
+    # :startdoc:
 
   end  # class RollingFile
 end  # module Logging::Appenders

data/lib/logging/appenders/syslog.rb

@@ -86,10 +86,10 @@ module Logging::Appenders
     #                  through LOG_LOCAL7.
     #
     def initialize( name, opts = {} )
-      ident = opts.getopt(:ident, name)
-      logopt = opts.getopt(:logopt, (LOG_PID | LOG_CONS), :as => Integer)
-      facility = opts.getopt(:facility, LOG_USER, :as => Integer)
-      @syslog = ::Syslog.open(ident, logopt, facility)
+      @ident = opts.getopt(:ident, name)
+      @logopt = opts.getopt(:logopt, (LOG_PID | LOG_CONS), :as => Integer)
+      @facility = opts.getopt(:facility, LOG_USER, :as => Integer)
+      @syslog = ::Syslog.open(@ident, @logopt, @facility)
 
       # provides a mapping from the default Logging levels
       # to the syslog levels
@@ -145,6 +145,22 @@ module Logging::Appenders
       !@syslog.opened?
     end
 
+    # Reopen the connection to the underlying logging destination. If the
+    # connection is currently closed then it will be opened. If the connection
+    # is currently open then it will be closed and immediately opened.
+    #
+    def reopen
+      @mutex.synchronize {
+        if @syslog.opened?
+          flush
+          @syslog.close
+        end
+        @syslog = ::Syslog.open(@ident, @logopt, @facility)
+        @closed = false
+      }
+      self
+    end
+
 
     private
 

data/lib/logging/utils.rb

@@ -124,6 +124,46 @@ module Kernel
   end
 end  # module Kernel
 
+# --------------------------------------------------------------------------
+class File
+
+  # Returns <tt>true</tt> if another process holds an exclusive lock on the
+  # file. Returns <tt>false</tt> if this is not the case.
+  #
+  # If a <tt>block</tt> of code is passed to this method, it will be run iff
+  # this process can obtain an exclusive lock on the file. The block will be
+  # run while this lock is held, and the exclusive lock will be released when
+  # the method returns.
+  #
+  # The exclusive lock is requested in a non-blocking mode. This method will
+  # return immediately (and the block will not be executed) if an exclusive
+  # lock cannot be obtained.
+  #
+  def flock?( &block )
+    status = flock(LOCK_EX|LOCK_NB)
+    case status
+    when false; true
+    when 0; block ? block.call : false
+    else
+      raise SystemCallError, "flock failed with status: #{status}"
+    end
+  ensure
+    flock LOCK_UN
+  end
+
+  # Execute the <tt>block</tt> in the context of a shared lock on this file. A
+  # shared lock will be obtained on the file, the block executed, and the lock
+  # released.
+  #
+  def flock_sh( &block )
+    flock LOCK_SH
+    block.call
+  ensure
+    flock LOCK_UN
+  end
+
+end
+
 # --------------------------------------------------------------------------
 class ReentrantMutex < Mutex
 

data/test/appenders/test_rolling_file.rb

@@ -75,7 +75,8 @@ module TestAppenders
       assert_equal 13, Dir.glob(@glob).length
 
       # force the appender to roll the files
-      ap.send :roll
+      ap.send :copy_truncate
+      ap.instance_variable_get(:@roller).roll_files
       assert_equal 6, Dir.glob(@glob).length
 
       (1..5).each do |cnt|
@@ -86,6 +87,10 @@ module TestAppenders
     end
 
     def test_age
+      d_glob = File.join(TMP, 'test.*.log')
+      dt_glob = File.join(TMP, 'test.*-*.log')
+      age_fn = @fn + '.age'
+
       assert_equal [], Dir.glob(@glob)
 
       assert_raise(ArgumentError) do
@@ -96,47 +101,61 @@ module TestAppenders
       ap << "random message\n"
       assert_equal 1, Dir.glob(@glob).length
 
-      sleep 1.250
+      now = ::File.mtime(age_fn)
+      start = now - 42
+      ::File.utime(start, start, age_fn)
+      ap.instance_variable_set(:@age_fn_mtime, nil)
       ap << "another random message\n"
-      assert_equal 2, Dir.glob(@glob).length
+      assert_equal 1, Dir.glob(dt_glob).length
 
+      Dir.glob(d_glob).each {|fn| ::File.delete fn}
       cleanup
+
       ap = Logging.appenders.rolling_file(NAME, :filename => @fn, 'age' => 'daily')
       ap << "random message\n"
-      assert_equal 2, Dir.glob(@glob).length
+      assert_equal 1, Dir.glob(@glob).length
 
-      age_fn = @fn + '.age'
       now = ::File.mtime(age_fn)
       start = now - 3600 * 24
       ::File.utime(start, start, age_fn)
+      ap.instance_variable_set(:@age_fn_mtime, nil)
 
       sleep 0.250
       ap << "yet another random message\n"
-      assert_equal 3, Dir.glob(@glob).length
+      assert_equal 0, Dir.glob(dt_glob).length
+      assert_equal 1, Dir.glob(d_glob).length
 
+      Dir.glob(d_glob).each {|fn| ::File.delete fn}
       cleanup
+
       ap = Logging.appenders.rolling_file(NAME, :filename => @fn, :age => 'weekly')
       ap << "random message\n"
-      assert_equal 3, Dir.glob(@glob).length
+      assert_equal 1, Dir.glob(@glob).length
 
       start = now - 3600 * 24 * 7
       ::File.utime(start, start, age_fn)
+      ap.instance_variable_set(:@age_fn_mtime, nil)
 
       sleep 0.250
       ap << "yet another random message\n"
-      assert_equal 4, Dir.glob(@glob).length
+      assert_equal 0, Dir.glob(dt_glob).length
+      assert_equal 1, Dir.glob(d_glob).length
 
+      Dir.glob(d_glob).each {|fn| ::File.delete fn}
       cleanup
+
       ap = Logging.appenders.rolling_file(NAME, :filename => @fn, :age => 'monthly')
       ap << "random message\n"
-      assert_equal 4, Dir.glob(@glob).length
+      assert_equal 1, Dir.glob(@glob).length
 
       start = now - 3600 * 24 * 31
       ::File.utime(start, start, age_fn)
+      ap.instance_variable_set(:@age_fn_mtime, nil)
 
       sleep 0.250
       ap << "yet another random message\n"
-      assert_equal 5, Dir.glob(@glob).length
+      assert_equal 0, Dir.glob(dt_glob).length
+      assert_equal 1, Dir.glob(d_glob).length
     end
 
     def test_size
@@ -173,16 +192,6 @@ module TestAppenders
       ap << 'X' * 100; ap.flush
       assert_equal 1, Dir.glob(@glob).length
       assert_equal 100, File.size(@fn)
-
-      # Now remove @fn and make sure that the log file is written to
-      # again
-      File.unlink(@fn)
-      assert_equal 0, Dir.glob(@glob).length
-
-      ap << 'X' * 50; ap.flush
-      assert_equal 1, Dir.glob(@glob).length
-      assert_equal 50, File.size(@fn)
-
     end
 
     private

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: logging
 version: !ruby/object:Gem::Version 
-  version: 1.2.3
+  version: 1.3.0
 platform: ruby
 authors: 
 - Tim Pease
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-01 00:00:00 -07:00
+date: 2009-12-21 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,16 +22,6 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.1.1
     version: 
-- !ruby/object:Gem::Dependency 
-  name: lockfile
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.4.3
-    version: 
 - !ruby/object:Gem::Dependency 
   name: flexmock
   type: :development
@@ -60,7 +50,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.2.0
+        version: 1.2.2
     version: 
 - !ruby/object:Gem::Dependency 
   name: bones
@@ -70,7 +60,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 3.1.0
+        version: 3.2.0
     version: 
 description: |-
   Logging is a flexible logging library for use in Ruby programs based on the
@@ -97,6 +87,7 @@ files:
 - examples/appenders.rb
 - examples/classes.rb
 - examples/consolidation.rb
+- examples/fork.rb
 - examples/formatting.rb
 - examples/hierarchies.rb
 - examples/layouts.rb